@pnpm/workspace.project-manifest-reader 1100.0.29 → 1100.1.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @pnpm/read-project-manifest
 
+## 1100.1.0
+
+### Minor Changes
+
+- Added `findWorkspaceDirSync`, `findPackagesSync`, `findWorkspaceProjectsSync`, `findWorkspaceProjectsNoCheckSync`, `readWorkspaceManifestSync`, and `readExactProjectManifestSync`.
+
+### Patch Changes
+
+- `pnpm add` and `pnpm install` keep an empty `peerDependencies`, `dependencies`, `devDependencies`, or `optionalDependencies` field that was already in `package.json`. pnpm still drops such a field when it removes the last entry itself, as `pnpm remove` does [#5096](https://github.com/pnpm/pnpm/issues/5096).
+
+- Dependencies and executable binaries are now correctly linked and accessible for workspace packages using `publishConfig.directory` and `publishConfig.linkDirectory` [pnpm/pnpm#8338](https://github.com/pnpm/pnpm/issues/8338).
+
+- Preserve CRLF line endings when modifying project manifests.
+
+- Updated dependencies:
+  - @pnpm/error@1100.2.0
+  - @pnpm/fs.graceful-fs@1100.2.3
+  - @pnpm/pkg-manifest.utils@1100.4.6
+  - @pnpm/types@1102.1.1
+  - @pnpm/workspace.project-manifest-writer@1100.0.18
+
 ## 1100.0.29
 
 ### Patch Changes

package/lib/index.d.ts

@@ -1,6 +1,12 @@
 import type { ProjectManifest } from '@pnpm/types';
 export type WriteProjectManifest = (manifest: ProjectManifest, force?: boolean) => Promise<void>;
 export declare function safeReadProjectManifestOnly(projectDir: string): Promise<ProjectManifest | null>;
+export declare function safeReadPublishManifest(projectDir: string): Promise<ProjectManifest | null>;
+/**
+ * Finds the manifest of a project whose `publishConfig.directory` is `publishDir`,
+ * searching the ancestors of `publishDir`.
+ */
+export declare function safeReadParentPublishManifest(publishDir: string): Promise<ProjectManifest | null>;
 export declare function readProjectManifest(projectDir: string): Promise<{
     fileName: string;
     manifest: ProjectManifest;
@@ -17,4 +23,5 @@ interface ReadExactProjectManifestResult {
     writeProjectManifest: WriteProjectManifest;
 }
 export declare function readExactProjectManifest(manifestPath: string): Promise<ReadExactProjectManifestResult>;
+export declare function readExactProjectManifestSync(manifestPath: string): ReadExactProjectManifestResult;
 export {};

package/lib/index.js

@@ -8,8 +8,8 @@ import detectIndent from 'detect-indent';
 import equal from 'fast-deep-equal';
 import isWindows from 'is-windows';
 import pLimit from 'p-limit';
-import { readYamlFile } from 'read-yaml-file';
-import { readJson5File, readJsonFile, } from './readFile.js';
+import { readYamlFile, readYamlFileSync } from 'read-yaml-file';
+import { readJson5File, readJson5FileSync, readJsonFile, readJsonFileSync, } from './readFile.js';
 const limitProjectManifestReads = pLimit(4);
 export async function safeReadProjectManifestOnly(projectDir) {
     return limitProjectManifestReads(async () => {
@@ -24,6 +24,29 @@ export async function safeReadProjectManifestOnly(projectDir) {
         }
     });
 }
+export async function safeReadPublishManifest(projectDir) {
+    return (await safeReadProjectManifestOnly(projectDir)) ?? safeReadParentPublishManifest(projectDir);
+}
+/**
+ * Finds the manifest of a project whose `publishConfig.directory` is `publishDir`,
+ * searching the ancestors of `publishDir`.
+ */
+export async function safeReadParentPublishManifest(publishDir) {
+    const normalizedTarget = path.resolve(publishDir);
+    let searchDir = path.dirname(normalizedTarget);
+    while (true) {
+        // eslint-disable-next-line no-await-in-loop
+        const parentManifest = await safeReadProjectManifestOnly(searchDir);
+        if (parentManifest?.publishConfig?.directory &&
+            path.resolve(searchDir, parentManifest.publishConfig.directory) === normalizedTarget) {
+            return parentManifest;
+        }
+        const next = path.dirname(searchDir);
+        if (next === searchDir)
+            return null;
+        searchDir = next;
+    }
+}
 export async function readProjectManifest(projectDir) {
     const result = await tryReadProjectManifest(projectDir);
     if (result.manifest !== null) {
@@ -39,11 +62,13 @@ export async function tryReadProjectManifest(projectDir) {
     try {
         const manifestPath = path.join(projectDir, 'package.json');
         const { data, text } = await readJsonFile(manifestPath);
+        const emptyDependencyFields = findEmptyDependencyFields(data);
         return {
             fileName: 'package.json',
             manifest: convertManifestAfterRead(data),
             writeProjectManifest: createManifestWriter({
                 ...detectFileFormatting(text),
+                emptyDependencyFields,
                 initialManifest: data,
                 manifestPath,
             }),
@@ -56,11 +81,13 @@ export async function tryReadProjectManifest(projectDir) {
     try {
         const manifestPath = path.join(projectDir, 'package.json5');
         const { data, text } = await readJson5File(manifestPath);
+        const emptyDependencyFields = findEmptyDependencyFields(data);
         return {
             fileName: 'package.json5',
             manifest: convertManifestAfterRead(data),
             writeProjectManifest: createManifestWriter({
                 ...detectFileFormattingAndComments(text),
+                emptyDependencyFields,
                 initialManifest: data,
                 manifestPath,
             }),
@@ -73,10 +100,11 @@ export async function tryReadProjectManifest(projectDir) {
     try {
         const manifestPath = path.join(projectDir, 'package.yaml');
         const manifest = await readPackageYaml(manifestPath);
+        const emptyDependencyFields = findEmptyDependencyFields(manifest);
         return {
             fileName: 'package.yaml',
             manifest: convertManifestAfterRead(manifest),
-            writeProjectManifest: createManifestWriter({ initialManifest: manifest, manifestPath }),
+            writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
         };
     }
     catch (err) { // eslint-disable-line
@@ -110,12 +138,14 @@ function detectFileFormattingAndComments(text) {
     const { comments, text: newText, hasFinalNewline } = extractComments(text);
     return {
         comments,
+        crlf: text.includes('\r\n'),
         indent: detectIndent(newText).indent,
         insertFinalNewline: hasFinalNewline,
     };
 }
 function detectFileFormatting(text) {
     return {
+        crlf: text.includes('\r\n'),
         indent: detectIndent(text).indent,
         insertFinalNewline: text.endsWith('\n'),
     };
@@ -125,10 +155,12 @@ export async function readExactProjectManifest(manifestPath) {
     switch (base) {
         case 'package.json': {
             const { data, text } = await readJsonFile(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(data);
             return {
                 manifest: convertManifestAfterRead(data),
                 writeProjectManifest: createManifestWriter({
                     ...detectFileFormatting(text),
+                    emptyDependencyFields,
                     initialManifest: data,
                     manifestPath,
                 }),
@@ -136,10 +168,12 @@ export async function readExactProjectManifest(manifestPath) {
         }
         case 'package.json5': {
             const { data, text } = await readJson5File(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(data);
             return {
                 manifest: convertManifestAfterRead(data),
                 writeProjectManifest: createManifestWriter({
                     ...detectFileFormattingAndComments(text),
+                    emptyDependencyFields,
                     initialManifest: data,
                     manifestPath,
                 }),
@@ -147,9 +181,50 @@ export async function readExactProjectManifest(manifestPath) {
         }
         case 'package.yaml': {
             const manifest = await readPackageYaml(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(manifest);
             return {
                 manifest: convertManifestAfterRead(manifest),
-                writeProjectManifest: createManifestWriter({ initialManifest: manifest, manifestPath }),
+                writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
+            };
+        }
+    }
+    throw new Error(`Not supported manifest name "${base}"`);
+}
+export function readExactProjectManifestSync(manifestPath) {
+    const base = path.basename(manifestPath).toLowerCase();
+    switch (base) {
+        case 'package.json': {
+            const { data, text } = readJsonFileSync(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(data);
+            return {
+                manifest: convertManifestAfterRead(data),
+                writeProjectManifest: createManifestWriter({
+                    ...detectFileFormatting(text),
+                    emptyDependencyFields,
+                    initialManifest: data,
+                    manifestPath,
+                }),
+            };
+        }
+        case 'package.json5': {
+            const { data, text } = readJson5FileSync(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(data);
+            return {
+                manifest: convertManifestAfterRead(data),
+                writeProjectManifest: createManifestWriter({
+                    ...detectFileFormattingAndComments(text),
+                    emptyDependencyFields,
+                    initialManifest: data,
+                    manifestPath,
+                }),
+            };
+        }
+        case 'package.yaml': {
+            const manifest = readPackageYamlSync(manifestPath);
+            const emptyDependencyFields = findEmptyDependencyFields(manifest);
+            return {
+                manifest: convertManifestAfterRead(manifest),
+                writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
             };
         }
     }
@@ -167,31 +242,64 @@ async function readPackageYaml(filePath) {
         throw err;
     }
 }
+function readPackageYamlSync(filePath) {
+    try {
+        return readYamlFileSync(filePath);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.name !== 'YAMLException')
+            throw err;
+        err.message = `${err.message}\nin ${filePath}`;
+        err.code = 'ERR_PNPM_YAML_PARSE';
+        throw err;
+    }
+}
 function createManifestWriter(opts) {
-    let initialManifest = normalize(opts.initialManifest);
+    let emptyDependencyFields = opts.emptyDependencyFields ?? findEmptyDependencyFields(opts.initialManifest);
+    let initialManifest = normalize(opts.initialManifest, emptyDependencyFields);
     return async (updatedManifest, force) => {
-        updatedManifest = convertManifestBeforeWrite(normalize(updatedManifest));
+        updatedManifest = convertManifestBeforeWrite(normalize(updatedManifest, emptyDependencyFields));
         if (force === true || !equal(initialManifest, updatedManifest)) {
             await writeProjectManifest(opts.manifestPath, updatedManifest, {
                 comments: opts.comments,
+                crlf: opts.crlf,
                 indent: opts.indent,
                 insertFinalNewline: opts.insertFinalNewline,
             });
-            initialManifest = normalize(updatedManifest);
+            emptyDependencyFields = findEmptyDependencyFields(updatedManifest);
+            initialManifest = normalize(updatedManifest, emptyDependencyFields);
             return Promise.resolve(undefined);
         }
         return Promise.resolve(undefined);
     };
 }
 function convertManifestAfterRead(manifest) {
-    convertEnginesRuntimeToDependencies(manifest, 'devEngines', 'devDependencies');
-    convertEnginesRuntimeToDependencies(manifest, 'engines', 'dependencies');
-    return manifest;
+    const cloned = cloneManifestForRuntimeConversion(manifest);
+    convertEnginesRuntimeToDependencies(cloned, 'devEngines', 'devDependencies');
+    convertEnginesRuntimeToDependencies(cloned, 'engines', 'dependencies');
+    return cloned;
 }
 function convertManifestBeforeWrite(manifest) {
-    convertDependenciesToEnginesRuntime(manifest, 'devDependencies', 'devEngines');
-    convertDependenciesToEnginesRuntime(manifest, 'dependencies', 'engines');
-    return manifest;
+    const cloned = cloneManifestForRuntimeConversion(manifest);
+    convertDependenciesToEnginesRuntime(cloned, 'devDependencies', 'devEngines');
+    convertDependenciesToEnginesRuntime(cloned, 'dependencies', 'engines');
+    return cloned;
+}
+function cloneManifestForRuntimeConversion(manifest) {
+    const cloned = { ...manifest };
+    if (manifest.dependencies != null && typeof manifest.dependencies === 'object' && !Array.isArray(manifest.dependencies)) {
+        cloned.dependencies = { ...manifest.dependencies };
+    }
+    if (manifest.devDependencies != null && typeof manifest.devDependencies === 'object' && !Array.isArray(manifest.devDependencies)) {
+        cloned.devDependencies = { ...manifest.devDependencies };
+    }
+    if (manifest.engines != null && typeof manifest.engines === 'object' && !Array.isArray(manifest.engines)) {
+        cloned.engines = { ...manifest.engines };
+    }
+    if (manifest.devEngines != null && typeof manifest.devEngines === 'object' && !Array.isArray(manifest.devEngines)) {
+        cloned.devEngines = { ...manifest.devEngines };
+    }
+    return cloned;
 }
 function convertDependenciesToEnginesRuntime(manifest, dependenciesFieldName, enginesFieldName) {
     const dependencies = readDependenciesField(manifest, dependenciesFieldName);
@@ -229,7 +337,7 @@ function convertDependenciesToEnginesRuntime(manifest, dependenciesFieldName, en
             }
             delete dependencies[runtimeName];
         }
-        else {
+        else if (dep === undefined) {
             removeManagedRuntimeEntry(manifest[enginesFieldName], runtimeName);
         }
     }
@@ -270,7 +378,26 @@ const dependencyKeys = new Set([
     'optionalDependencies',
     'peerDependencies',
 ]);
-function normalize(manifest) {
+/**
+ * The dependency fields the manifest declares as empty objects. A write
+ * keeps these in place; it only drops a field that pnpm itself emptied.
+ */
+function findEmptyDependencyFields(manifest) {
+    const fields = new Set();
+    for (const key of dependencyKeys) {
+        if (isEmptyDependencyObject(manifest[key])) {
+            fields.add(key);
+        }
+    }
+    return fields;
+}
+function isEmptyDependencyObject(value) {
+    return typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0;
+}
+function normalize(manifest, keepEmptyDependencyFields) {
     const result = {};
     for (const key in manifest) {
         if (Object.hasOwn(manifest, key)) {
@@ -292,6 +419,9 @@ function normalize(manifest) {
                     }
                     result[key] = sortedValue;
                 }
+                else if (keepEmptyDependencyFields.has(key)) {
+                    result[key] = {};
+                }
             }
         }
     }

package/lib/readFile.d.ts

@@ -3,7 +3,15 @@ export declare function readJson5File(filePath: string): Promise<{
     data: ProjectManifest;
     text: string;
 }>;
+export declare function readJson5FileSync(filePath: string): {
+    data: ProjectManifest;
+    text: string;
+};
 export declare function readJsonFile(filePath: string): Promise<{
     data: ProjectManifest;
     text: string;
 }>;
+export declare function readJsonFileSync(filePath: string): {
+    data: ProjectManifest;
+    text: string;
+};

package/lib/readFile.js

@@ -16,6 +16,20 @@ export async function readJson5File(filePath) {
         throw err;
     }
 }
+export function readJson5FileSync(filePath) {
+    const text = readFileWithoutBomSync(filePath);
+    try {
+        return {
+            data: JSON5.parse(text),
+            text,
+        };
+    }
+    catch (err) { // eslint-disable-line
+        err.message = `${err.message} in ${filePath}`;
+        err['code'] = 'ERR_PNPM_JSON5_PARSE';
+        throw err;
+    }
+}
 export async function readJsonFile(filePath) {
     const text = await readFileWithoutBom(filePath);
     try {
@@ -29,7 +43,23 @@ export async function readJsonFile(filePath) {
         throw err;
     }
 }
+export function readJsonFileSync(filePath) {
+    const text = readFileWithoutBomSync(filePath);
+    try {
+        return {
+            data: parseJson(text, filePath),
+            text,
+        };
+    }
+    catch (err) { // eslint-disable-line
+        err['code'] = 'ERR_PNPM_JSON_PARSE';
+        throw err;
+    }
+}
 async function readFileWithoutBom(path) {
     return stripBom(await gfs.readFile(path, 'utf8'));
 }
+function readFileWithoutBomSync(path) {
+    return stripBom(gfs.readFileSync(path, 'utf8'));
+}
 //# sourceMappingURL=readFile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/workspace.project-manifest-reader",
-  "version": "1100.0.29",
+  "version": "1100.1.0",
   "description": "Read a project manifest (called package.json in most cases)",
   "keywords": [
     "pnpm",
@@ -27,12 +27,12 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/error": "1100.1.4",
-    "@pnpm/fs.graceful-fs": "1100.2.2",
-    "@pnpm/pkg-manifest.utils": "1100.4.5",
+    "@pnpm/error": "1100.2.0",
+    "@pnpm/fs.graceful-fs": "1100.2.3",
+    "@pnpm/pkg-manifest.utils": "1100.4.6",
     "@pnpm/text.comments-parser": "1100.0.1",
-    "@pnpm/types": "1102.1.0",
-    "@pnpm/workspace.project-manifest-writer": "1100.0.17",
+    "@pnpm/types": "1102.1.1",
+    "@pnpm/workspace.project-manifest-writer": "1100.0.18",
     "detect-indent": "7.0.2",
     "fast-deep-equal": "^3.1.3",
     "is-windows": "^1.0.2",
@@ -48,7 +48,7 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/test-fixtures": "1100.0.1",
-    "@pnpm/workspace.project-manifest-reader": "1100.0.29",
+    "@pnpm/workspace.project-manifest-reader": "1100.1.0",
     "@types/is-windows": "^1.0.2",
     "@types/parse-json": "^7.0.0",
     "tempy": "3.0.0"