@pnpm/workspace.project-manifest-reader 1001.1.4

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @pnpm/read-project-manifest
+
+> Read a project manifest (called package.json in most cases)
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/read-project-manifest.svg)](https://www.npmjs.com/package/@pnpm/read-project-manifest)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/read-project-manifest
+```
+
+## Usage
+
+```ts
+import { readProjectManifest } from '@pnpm/read-project-manifest'
+
+const { manifest, fileName } = await readProjectManifest(process.cwd())
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+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 readProjectManifest(projectDir: string): Promise<{
+    fileName: string;
+    manifest: ProjectManifest;
+    writeProjectManifest: WriteProjectManifest;
+}>;
+export declare function readProjectManifestOnly(projectDir: string): Promise<ProjectManifest>;
+export declare function tryReadProjectManifest(projectDir: string): Promise<{
+    fileName: string;
+    manifest: ProjectManifest | null;
+    writeProjectManifest: WriteProjectManifest;
+}>;
+interface ReadExactProjectManifestResult {
+    manifest: ProjectManifest;
+    writeProjectManifest: WriteProjectManifest;
+}
+export declare function readExactProjectManifest(manifestPath: string): Promise<ReadExactProjectManifestResult>;
+export {};

package/lib/index.js

@@ -0,0 +1,261 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { PnpmError } from '@pnpm/error';
+import { convertEnginesRuntimeToDependencies } from '@pnpm/pkg-manifest.utils';
+import { extractComments } from '@pnpm/text.comments-parser';
+import { writeProjectManifest } from '@pnpm/workspace.project-manifest-writer';
+import detectIndent from 'detect-indent';
+import equal from 'fast-deep-equal';
+import isWindows from 'is-windows';
+import { readYamlFile } from 'read-yaml-file';
+import { readJson5File, readJsonFile, } from './readFile.js';
+export async function safeReadProjectManifestOnly(projectDir) {
+    try {
+        return await readProjectManifestOnly(projectDir);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code === 'ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND') {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function readProjectManifest(projectDir) {
+    const result = await tryReadProjectManifest(projectDir);
+    if (result.manifest !== null) {
+        return result;
+    }
+    throw new PnpmError('NO_IMPORTER_MANIFEST_FOUND', `No package.json (or package.yaml, or package.json5) was found in "${projectDir}".`);
+}
+export async function readProjectManifestOnly(projectDir) {
+    const { manifest } = await readProjectManifest(projectDir);
+    return manifest;
+}
+export async function tryReadProjectManifest(projectDir) {
+    try {
+        const manifestPath = path.join(projectDir, 'package.json');
+        const { data, text } = await readJsonFile(manifestPath);
+        return {
+            fileName: 'package.json',
+            manifest: convertManifestAfterRead(data),
+            writeProjectManifest: createManifestWriter({
+                ...detectFileFormatting(text),
+                initialManifest: data,
+                manifestPath,
+            }),
+        };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    try {
+        const manifestPath = path.join(projectDir, 'package.json5');
+        const { data, text } = await readJson5File(manifestPath);
+        return {
+            fileName: 'package.json5',
+            manifest: convertManifestAfterRead(data),
+            writeProjectManifest: createManifestWriter({
+                ...detectFileFormattingAndComments(text),
+                initialManifest: data,
+                manifestPath,
+            }),
+        };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    try {
+        const manifestPath = path.join(projectDir, 'package.yaml');
+        const manifest = await readPackageYaml(manifestPath);
+        return {
+            fileName: 'package.yaml',
+            manifest: convertManifestAfterRead(manifest),
+            writeProjectManifest: createManifestWriter({ initialManifest: manifest, manifestPath }),
+        };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    if (isWindows()) {
+        // ENOTDIR isn't used on Windows, but pnpm expects it.
+        let s;
+        try {
+            s = await fs.stat(projectDir);
+        }
+        catch (err) { // eslint-disable-line
+            // Ignore
+        }
+        if ((s != null) && !s.isDirectory()) {
+            const err = new Error(`"${projectDir}" is not a directory`);
+            // @ts-expect-error
+            err['code'] = 'ENOTDIR';
+            throw err;
+        }
+    }
+    const filePath = path.join(projectDir, 'package.json');
+    return {
+        fileName: 'package.json',
+        manifest: null,
+        writeProjectManifest: async (manifest) => writeProjectManifest(filePath, manifest),
+    };
+}
+function detectFileFormattingAndComments(text) {
+    const { comments, text: newText, hasFinalNewline } = extractComments(text);
+    return {
+        comments,
+        indent: detectIndent(newText).indent,
+        insertFinalNewline: hasFinalNewline,
+    };
+}
+function detectFileFormatting(text) {
+    return {
+        indent: detectIndent(text).indent,
+        insertFinalNewline: text.endsWith('\n'),
+    };
+}
+export async function readExactProjectManifest(manifestPath) {
+    const base = path.basename(manifestPath).toLowerCase();
+    switch (base) {
+        case 'package.json': {
+            const { data, text } = await readJsonFile(manifestPath);
+            return {
+                manifest: convertManifestAfterRead(data),
+                writeProjectManifest: createManifestWriter({
+                    ...detectFileFormatting(text),
+                    initialManifest: data,
+                    manifestPath,
+                }),
+            };
+        }
+        case 'package.json5': {
+            const { data, text } = await readJson5File(manifestPath);
+            return {
+                manifest: convertManifestAfterRead(data),
+                writeProjectManifest: createManifestWriter({
+                    ...detectFileFormattingAndComments(text),
+                    initialManifest: data,
+                    manifestPath,
+                }),
+            };
+        }
+        case 'package.yaml': {
+            const manifest = await readPackageYaml(manifestPath);
+            return {
+                manifest: convertManifestAfterRead(manifest),
+                writeProjectManifest: createManifestWriter({ initialManifest: manifest, manifestPath }),
+            };
+        }
+    }
+    throw new Error(`Not supported manifest name "${base}"`);
+}
+async function readPackageYaml(filePath) {
+    try {
+        return await readYamlFile(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);
+    return async (updatedManifest, force) => {
+        updatedManifest = convertManifestBeforeWrite(normalize(updatedManifest));
+        if (force === true || !equal(initialManifest, updatedManifest)) {
+            await writeProjectManifest(opts.manifestPath, updatedManifest, {
+                comments: opts.comments,
+                indent: opts.indent,
+                insertFinalNewline: opts.insertFinalNewline,
+            });
+            initialManifest = normalize(updatedManifest);
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(undefined);
+    };
+}
+function convertManifestAfterRead(manifest) {
+    convertEnginesRuntimeToDependencies(manifest, 'devEngines', 'devDependencies');
+    convertEnginesRuntimeToDependencies(manifest, 'engines', 'dependencies');
+    return manifest;
+}
+function convertManifestBeforeWrite(manifest) {
+    convertDependenciesToEnginesRuntime(manifest, 'devDependencies', 'devEngines');
+    convertDependenciesToEnginesRuntime(manifest, 'dependencies', 'engines');
+    return manifest;
+}
+function convertDependenciesToEnginesRuntime(manifest, dependenciesFieldName, enginesFieldName) {
+    for (const runtimeName of ['node', 'deno', 'bun']) {
+        const dep = manifest[dependenciesFieldName]?.[runtimeName];
+        if (typeof dep === 'string' && dep.startsWith('runtime:')) {
+            const version = dep.replace(/^runtime:/, '');
+            manifest[enginesFieldName] ??= {};
+            const runtimeEntry = {
+                name: runtimeName,
+                version,
+                onFail: 'download',
+            };
+            const enginesField = manifest[enginesFieldName];
+            if (!enginesField.runtime) {
+                enginesField.runtime = runtimeEntry;
+            }
+            else if (Array.isArray(enginesField.runtime)) {
+                const existing = enginesField.runtime.find(({ name }) => name === runtimeName);
+                if (existing) {
+                    Object.assign(existing, runtimeEntry);
+                }
+                else {
+                    enginesField.runtime.push(runtimeEntry);
+                }
+            }
+            else if (enginesField.runtime.name === runtimeName) {
+                Object.assign(enginesField.runtime, runtimeEntry);
+            }
+            else {
+                enginesField.runtime = [
+                    enginesField.runtime,
+                    runtimeEntry,
+                ];
+            }
+            if (manifest[dependenciesFieldName]) {
+                delete manifest[dependenciesFieldName][runtimeName];
+            }
+        }
+    }
+}
+const dependencyKeys = new Set([
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies',
+]);
+function normalize(manifest) {
+    const result = {};
+    for (const key in manifest) {
+        if (Object.hasOwn(manifest, key)) {
+            const value = manifest[key];
+            if (typeof value !== 'object' || !dependencyKeys.has(key)) {
+                result[key] = structuredClone(value);
+            }
+            else {
+                const keys = Object.keys(value);
+                if (keys.length !== 0) {
+                    keys.sort();
+                    const sortedValue = {};
+                    for (const k of keys) {
+                        // @ts-expect-error this is fine
+                        sortedValue[k] = value[k];
+                    }
+                    result[key] = sortedValue;
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=index.js.map

package/lib/readFile.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectManifest } from '@pnpm/types';
+export declare function readJson5File(filePath: string): Promise<{
+    data: ProjectManifest;
+    text: string;
+}>;
+export declare function readJsonFile(filePath: string): Promise<{
+    data: ProjectManifest;
+    text: string;
+}>;

package/lib/readFile.js

@@ -0,0 +1,35 @@
+import gfs from '@pnpm/fs.graceful-fs';
+import JSON5 from 'json5';
+import parseJson from 'parse-json';
+import stripBom from 'strip-bom';
+export async function readJson5File(filePath) {
+    const text = await readFileWithoutBom(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 {
+        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'));
+}
+//# sourceMappingURL=readFile.js.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@pnpm/workspace.project-manifest-reader",
+  "version": "1001.1.4",
+  "description": "Read a project manifest (called package.json in most cases)",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/workspace/project-manifest-reader",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/workspace/project-manifest-reader#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "detect-indent": "7.0.1",
+    "fast-deep-equal": "^3.1.3",
+    "is-windows": "^1.0.2",
+    "json5": "^2.2.3",
+    "parse-json": "^8.3.0",
+    "read-yaml-file": "^3.0.0",
+    "strip-bom": "^5.0.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/pkg-manifest.utils": "1001.0.6",
+    "@pnpm/fs.graceful-fs": "1000.0.1",
+    "@pnpm/text.comments-parser": "1000.0.0",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.project-manifest-writer": "1000.0.11"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@types/is-windows": "^1.0.2",
+    "@types/parse-json": "^4.0.2",
+    "tempy": "3.0.0",
+    "@pnpm/test-fixtures": "1000.0.0",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}