@pnpm/lockfile.fs 1100.0.7 → 1100.1.0

package/lib/index.d.ts

@@ -3,7 +3,8 @@ export { existsNonEmptyWantedLockfile } from './existsWantedLockfile.js';
 export { getLockfileImporterId } from './getLockfileImporterId.js';
 export { cleanGitBranchLockfiles } from './gitBranchLockfile.js';
 export { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
+export { getWantedLockfileName } from './lockfileName.js';
 export * from './read.js';
-export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, writeWantedLockfile, } from './write.js';
+export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, type WriteLockfilesResult, writeWantedLockfile, } from './write.js';
 export { extractMainDocument } from './yamlDocuments.js';
 export * from '@pnpm/lockfile.types';

package/lib/index.js

@@ -3,6 +3,7 @@ export { existsNonEmptyWantedLockfile } from './existsWantedLockfile.js';
 export { getLockfileImporterId } from './getLockfileImporterId.js';
 export { cleanGitBranchLockfiles } from './gitBranchLockfile.js';
 export { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
+export { getWantedLockfileName } from './lockfileName.js';
 export * from './read.js';
 export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, writeWantedLockfile, } from './write.js';
 export { extractMainDocument } from './yamlDocuments.js';

package/lib/read.d.ts

@@ -19,6 +19,7 @@ export declare function readWantedLockfile(pkgPath: string, opts: {
     useGitBranchLockfile?: boolean;
     mergeGitBranchLockfiles?: boolean;
 }): Promise<LockfileObject | null>;
+export declare function wantedLockfileHasMergeConflictsSync(pkgPath: string): boolean;
 export declare function createLockfileObject(importerIds: ProjectId[], opts: {
     lockfileVersion: string;
     autoInstallPeers: boolean;

package/lib/read.js

@@ -1,4 +1,4 @@
-import { promises as fs } from 'node:fs';
+import fs, { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import util from 'node:util';
 import { LOCKFILE_VERSION, WANTED_LOCKFILE, } from '@pnpm/constants';
@@ -28,11 +28,23 @@ export async function readWantedLockfileAndAutofixConflicts(pkgPath, opts) {
 export async function readWantedLockfile(pkgPath, opts) {
     return (await _readWantedLockfile(pkgPath, opts)).lockfile;
 }
+export function wantedLockfileHasMergeConflictsSync(pkgPath) {
+    try {
+        const lockfileRawContent = stripBom(fs.readFileSync(path.join(pkgPath, WANTED_LOCKFILE), 'utf8'));
+        return isDiff(extractMainDocument(lockfileRawContent));
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return false;
+        }
+        throw err;
+    }
+}
 async function _read(lockfilePath, prefix, // only for logging
 opts) {
     let lockfileRawContent;
     try {
-        lockfileRawContent = stripBom(await fs.readFile(lockfilePath, 'utf8'));
+        lockfileRawContent = stripBom(await fsp.readFile(lockfilePath, 'utf8'));
     }
     catch (err) {
         if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {

package/lib/write.d.ts

@@ -1,12 +1,32 @@
 import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
 export declare function lockfileYamlDump(obj: object): string;
+/**
+ * Returns the canonical post-write lockfile — structurally identical
+ * to what `readWantedLockfile` would parse back. Lets callers like
+ * the verification cache hash the as-saved form without re-reading.
+ */
 export declare function writeWantedLockfile(pkgPath: string, wantedLockfile: LockfileObject, opts?: {
     useGitBranchLockfile?: boolean;
     mergeGitBranchLockfiles?: boolean;
-}): Promise<void>;
-export declare function writeCurrentLockfile(virtualStoreDir: string, currentLockfile: LockfileObject): Promise<void>;
+    /** Pre-resolved filename; skips the `getWantedLockfileName` (and
+     *  its `getCurrentBranch`) call when supplied. */
+    lockfileName?: string;
+}): Promise<LockfileObject>;
+export declare function writeCurrentLockfile(virtualStoreDir: string, currentLockfile: LockfileObject): Promise<LockfileObject | undefined>;
 export declare function writeLockfileFile(lockfilePath: string, wantedLockfile: LockfileFile): Promise<void>;
 export declare function isEmptyLockfile(lockfile: LockfileObject): boolean;
+export interface WriteLockfilesResult {
+    /**
+     * The canonical "as-saved" wanted lockfile — the inverse converter
+     * applied to the same object that was serialized to YAML. Hashing
+     * this is equivalent to hashing the lockfile the next install will
+     * load from disk (modulo undefined values that YAML drops, which any
+     * sensible canonicalization-then-hash routine should strip).
+     */
+    wantedLockfile: LockfileObject;
+    /** Same as above for the current lockfile, or undefined when it was skipped because empty. */
+    currentLockfile: LockfileObject | undefined;
+}
 export declare function writeLockfiles(opts: {
     wantedLockfile: LockfileObject;
     wantedLockfileDir: string;
@@ -14,4 +34,6 @@ export declare function writeLockfiles(opts: {
     currentLockfileDir: string;
     useGitBranchLockfile?: boolean;
     mergeGitBranchLockfiles?: boolean;
-}): Promise<void>;
+    /** See {@link writeWantedLockfile}'s `lockfileName` option. */
+    wantedLockfileName?: string;
+}): Promise<WriteLockfilesResult>;

package/lib/write.js

@@ -5,7 +5,7 @@ import { rimraf } from '@zkochan/rimraf';
 import yaml from 'js-yaml';
 import { isEmpty } from 'ramda';
 import writeFileAtomic from 'write-file-atomic';
-import { convertToLockfileFile } from './lockfileFormatConverters.js';
+import { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
 import { getWantedLockfileName } from './lockfileName.js';
 import { lockfileLogger as logger } from './logger.js';
 import { sortLockfileKeys } from './sortLockfileKeys.js';
@@ -20,15 +20,20 @@ const LOCKFILE_YAML_FORMAT = {
 export function lockfileYamlDump(obj) {
     return yaml.dump(obj, LOCKFILE_YAML_FORMAT);
 }
+/**
+ * Returns the canonical post-write lockfile — structurally identical
+ * to what `readWantedLockfile` would parse back. Lets callers like
+ * the verification cache hash the as-saved form without re-reading.
+ */
 export async function writeWantedLockfile(pkgPath, wantedLockfile, opts) {
-    const wantedLockfileName = await getWantedLockfileName(opts);
+    const wantedLockfileName = opts?.lockfileName ?? await getWantedLockfileName(opts);
     return writeLockfile(wantedLockfileName, pkgPath, wantedLockfile);
 }
 export async function writeCurrentLockfile(virtualStoreDir, currentLockfile) {
     // empty lockfile is not saved
     if (isEmptyLockfile(currentLockfile)) {
         await rimraf(path.join(virtualStoreDir, 'lock.yaml'));
-        return;
+        return undefined;
     }
     await fs.mkdir(virtualStoreDir, { recursive: true });
     return writeLockfile('lock.yaml', virtualStoreDir, currentLockfile);
@@ -45,9 +50,29 @@ async function writeLockfile(lockfileFilename, pkgPath, wantedLockfile) {
         // in the OS page cache and streaming stops at the first separator.
         const envDoc = await streamReadFirstYamlDocument(lockfilePath);
         const envPrefix = envDoc != null ? `${YAML_DOCUMENT_START}${envDoc}${YAML_DOCUMENT_SEPARATOR}` : '';
-        return writeFileAtomic(lockfilePath, `${envPrefix}${yamlDoc}`);
+        await writeFileAtomic(lockfilePath, `${envPrefix}${yamlDoc}`);
     }
-    return writeFileAtomic(lockfilePath, yamlDoc);
+    else {
+        await writeFileAtomic(lockfilePath, yamlDoc);
+    }
+    // YAML drops undefined on serialize, so the in-memory LockfileFile
+    // can carry fields (like an unset settings.dedupePeers) that won't
+    // survive a round-trip; strip them to mirror what the next reader
+    // will parse back.
+    return convertToLockfileObject(stripUndefinedDeep(lockfileToStringify));
+}
+function stripUndefinedDeep(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(stripUndefinedDeep);
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (v === undefined)
+            continue;
+        out[k] = stripUndefinedDeep(v);
+    }
+    return out;
 }
 export function writeLockfileFile(lockfilePath, wantedLockfile) {
     const yamlDoc = yamlStringify(wantedLockfile);
@@ -61,7 +86,7 @@ export function isEmptyLockfile(lockfile) {
     return Object.values(lockfile.importers).every((importer) => isEmpty(importer.specifiers ?? {}) && isEmpty(importer.dependencies ?? {}));
 }
 export async function writeLockfiles(opts) {
-    const wantedLockfileName = await getWantedLockfileName(opts);
+    const wantedLockfileName = opts.wantedLockfileName ?? await getWantedLockfileName(opts);
     const wantedLockfilePath = path.join(opts.wantedLockfileDir, wantedLockfileName);
     const currentLockfilePath = path.join(opts.currentLockfileDir, 'lock.yaml');
     const wantedLockfileToStringify = convertToLockfileFile(opts.wantedLockfile);
@@ -92,7 +117,12 @@ export async function writeLockfiles(opts) {
                 }
             })(),
         ]);
-        return;
+        // Both files share the same source object; strip once and reuse.
+        const normalized = convertToLockfileObject(stripUndefinedDeep(wantedLockfileToStringify));
+        return {
+            wantedLockfile: normalized,
+            currentLockfile: isEmptyLockfile(opts.wantedLockfile) ? undefined : normalized,
+        };
     }
     logger.debug({
         message: `\`${WANTED_LOCKFILE}\` differs from \`${path.relative(opts.wantedLockfileDir, currentLockfilePath)}\``,
@@ -100,10 +130,13 @@ export async function writeLockfiles(opts) {
     });
     const currentLockfileToStringify = convertToLockfileFile(opts.currentLockfile);
     const currentYamlDoc = yamlStringify(currentLockfileToStringify);
+    // Filtered-current callers (deps-restorer) can pass an empty
+    // current against a non-empty wanted; key off the current.
+    const currentIsEmpty = isEmptyLockfile(opts.currentLockfile);
     await Promise.all([
         writeFileAtomic(wantedLockfilePath, wantedYamlDoc),
         (async () => {
-            if (isEmptyLockfile(opts.wantedLockfile)) {
+            if (currentIsEmpty) {
                 await rimraf(currentLockfilePath);
             }
             else {
@@ -112,5 +145,11 @@ export async function writeLockfiles(opts) {
             }
         })(),
     ]);
+    return {
+        wantedLockfile: convertToLockfileObject(stripUndefinedDeep(wantedLockfileToStringify)),
+        currentLockfile: currentIsEmpty
+            ? undefined
+            : convertToLockfileObject(stripUndefinedDeep(currentLockfileToStringify)),
+    };
 }
 //# sourceMappingURL=write.js.map

package/lib/yamlDocuments.js

@@ -24,6 +24,8 @@ export async function streamReadFirstYamlDocument(filePath) {
             else {
                 buffer += chunk.value;
             }
+            // Normalize CRLF (Windows) to LF so document separator detection works.
+            buffer = buffer.replace(/\r\n/g, '\n');
             if (buffer.length >= YAML_DOCUMENT_START.length)
                 break;
         }
@@ -41,7 +43,8 @@ export async function streamReadFirstYamlDocument(filePath) {
             const chunk = await chunks.next(); // eslint-disable-line no-await-in-loop
             if (chunk.done)
                 break;
-            buffer += chunk.value;
+            // Normalize CRLF (Windows) to LF so the separator search matches on Windows-checked-out files.
+            buffer = (buffer + chunk.value).replace(/\r\n/g, '\n');
         }
     }
     catch (err) {
@@ -60,6 +63,7 @@ export async function streamReadFirstYamlDocument(filePath) {
  * Otherwise returns the entire content (no env document present).
  */
 export function extractMainDocument(content) {
+    content = content.replace(/\r\n/g, '\n');
     if (!content.startsWith(YAML_DOCUMENT_START))
         return content;
     const sep = content.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/lockfile.fs",
-  "version": "1100.0.7",
+  "version": "1100.1.0",
   "description": "Read/write pnpm-lock.yaml files",
   "keywords": [
     "pnpm",
@@ -35,14 +35,14 @@
     "strip-bom": "^5.0.0",
     "write-file-atomic": "^7.0.0",
     "@pnpm/deps.path": "1100.0.3",
-    "@pnpm/error": "1100.0.0",
-    "@pnpm/lockfile.merger": "1100.0.5",
-    "@pnpm/lockfile.utils": "1100.0.7",
+    "@pnpm/constants": "1100.0.0",
+    "@pnpm/lockfile.merger": "1100.0.6",
     "@pnpm/object.key-sorting": "1100.0.0",
-    "@pnpm/lockfile.types": "1100.0.5",
-    "@pnpm/types": "1101.1.0",
     "@pnpm/network.git-utils": "1100.0.1",
-    "@pnpm/constants": "1100.0.0"
+    "@pnpm/lockfile.utils": "1100.0.8",
+    "@pnpm/types": "1101.1.0",
+    "@pnpm/lockfile.types": "1100.0.6",
+    "@pnpm/error": "1100.0.0"
   },
   "peerDependencies": {
     "@pnpm/logger": ">=1001.0.0 <1002.0.0"
@@ -57,8 +57,8 @@
     "tempy": "3.0.0",
     "write-yaml-file": "^6.0.0",
     "yaml-tag": "1.1.0",
-    "@pnpm/lockfile.fs": "1100.0.7",
-    "@pnpm/logger": "1100.0.0"
+    "@pnpm/logger": "1100.0.0",
+    "@pnpm/lockfile.fs": "1100.1.0"
   },
   "engines": {
     "node": ">=22.13"