@pnpm/pkg-manifest.utils 1001.0.6

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,14 @@
+# @pnpm/manifest-utils
+
+> Utils for dealing with package manifest
+
+## Installation
+
+```
+pnpm i @pnpm/manifest-utils
+
+```
+
+## License
+
+[MIT](LICENSE)

package/lib/convertEnginesRuntimeToDependencies.d.ts

@@ -0,0 +1,2 @@
+import type { DependenciesField, ProjectManifest } from '@pnpm/types';
+export declare function convertEnginesRuntimeToDependencies(manifest: ProjectManifest, enginesFieldName: 'devEngines' | 'engines', dependenciesFieldName: DependenciesField): void;

package/lib/convertEnginesRuntimeToDependencies.js

@@ -0,0 +1,22 @@
+import { globalWarn } from '@pnpm/logger';
+export function convertEnginesRuntimeToDependencies(manifest, enginesFieldName, dependenciesFieldName) {
+    for (const runtimeName of ['node', 'deno', 'bun']) {
+        const enginesFieldRuntime = manifest[enginesFieldName]?.runtime;
+        if (enginesFieldRuntime == null || manifest[dependenciesFieldName]?.[runtimeName]) {
+            continue;
+        }
+        const runtimes = Array.isArray(enginesFieldRuntime) ? enginesFieldRuntime : [enginesFieldRuntime];
+        const runtime = runtimes.find((runtime) => runtime.name === runtimeName);
+        if (runtime?.onFail !== 'download') {
+            continue;
+        }
+        if ('webcontainer' in process.versions) {
+            globalWarn(`Installation of ${runtimeName} versions is not supported in WebContainer`);
+        }
+        else {
+            manifest[dependenciesFieldName] ??= {};
+            manifest[dependenciesFieldName][runtimeName] = `runtime:${runtime.version}`;
+        }
+    }
+}
+//# sourceMappingURL=convertEnginesRuntimeToDependencies.js.map

package/lib/filterDependenciesByType.d.ts

@@ -0,0 +1,2 @@
+import type { Dependencies, IncludedDependencies, ProjectManifest } from '@pnpm/types';
+export declare function filterDependenciesByType(manifest: ProjectManifest, include: IncludedDependencies): Dependencies;

package/lib/filterDependenciesByType.js

@@ -0,0 +1,8 @@
+export function filterDependenciesByType(manifest, include) {
+    return {
+        ...(include.dependencies ? manifest.dependencies : {}),
+        ...(include.devDependencies ? manifest.devDependencies : {}),
+        ...(include.optionalDependencies ? manifest.optionalDependencies : {}),
+    };
+}
+//# sourceMappingURL=filterDependenciesByType.js.map

package/lib/getAllDependenciesFromManifest.d.ts

@@ -0,0 +1,2 @@
+import type { Dependencies, DependenciesField, ProjectManifest } from '@pnpm/types';
+export declare function getAllDependenciesFromManifest(pkg: Pick<ProjectManifest, DependenciesField>): Dependencies;

package/lib/getAllDependenciesFromManifest.js

@@ -0,0 +1,8 @@
+export function getAllDependenciesFromManifest(pkg) {
+    return {
+        ...pkg.devDependencies,
+        ...pkg.dependencies,
+        ...pkg.optionalDependencies,
+    };
+}
+//# sourceMappingURL=getAllDependenciesFromManifest.js.map

package/lib/getAllUniqueSpecs.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyManifest } from '@pnpm/types';
+export declare function getAllUniqueSpecs(manifests: DependencyManifest[]): Record<string, string>;

package/lib/getAllUniqueSpecs.js

@@ -0,0 +1,20 @@
+import { getAllDependenciesFromManifest } from './getAllDependenciesFromManifest.js';
+export function getAllUniqueSpecs(manifests) {
+    const allSpecs = {};
+    const ignored = new Set();
+    for (const manifest of manifests) {
+        const specs = getAllDependenciesFromManifest(manifest);
+        for (const [name, spec] of Object.entries(specs)) {
+            if (ignored.has(name))
+                continue;
+            if (allSpecs[name] != null && allSpecs[name] !== spec || spec.includes(':')) {
+                ignored.add(name);
+                delete allSpecs[name];
+                continue;
+            }
+            allSpecs[name] = spec;
+        }
+    }
+    return allSpecs;
+}
+//# sourceMappingURL=getAllUniqueSpecs.js.map

package/lib/getDependencyTypeFromManifest.d.ts

@@ -0,0 +1,2 @@
+import type { DependenciesOrPeersField, ProjectManifest } from '@pnpm/types';
+export declare function getDependencyTypeFromManifest(manifest: Pick<ProjectManifest, DependenciesOrPeersField>, depName: string): DependenciesOrPeersField | null;

package/lib/getDependencyTypeFromManifest.js

@@ -0,0 +1,12 @@
+export function getDependencyTypeFromManifest(manifest, depName) {
+    if (manifest.optionalDependencies?.[depName])
+        return 'optionalDependencies';
+    if (manifest.dependencies?.[depName])
+        return 'dependencies';
+    if (manifest.devDependencies?.[depName])
+        return 'devDependencies';
+    if (manifest.peerDependencies?.[depName])
+        return 'peerDependencies';
+    return null;
+}
+//# sourceMappingURL=getDependencyTypeFromManifest.js.map

package/lib/getSpecFromPackageManifest.d.ts

@@ -0,0 +1,2 @@
+import type { DependenciesOrPeersField, ProjectManifest } from '@pnpm/types';
+export declare function getSpecFromPackageManifest(manifest: Pick<ProjectManifest, DependenciesOrPeersField>, depName: string): string;

package/lib/getSpecFromPackageManifest.js

@@ -0,0 +1,8 @@
+export function getSpecFromPackageManifest(manifest, depName) {
+    return manifest.optionalDependencies?.[depName] ??
+        manifest.dependencies?.[depName] ??
+        manifest.devDependencies?.[depName] ??
+        manifest.peerDependencies?.[depName] ??
+        '';
+}
+//# sourceMappingURL=getSpecFromPackageManifest.js.map

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import type { Dependencies, IncludedDependencies, ProjectManifest } from '@pnpm/types';
+import { getAllUniqueSpecs } from './getAllUniqueSpecs.js';
+import { getSpecFromPackageManifest } from './getSpecFromPackageManifest.js';
+export * from './convertEnginesRuntimeToDependencies.js';
+export * from './getDependencyTypeFromManifest.js';
+export * from './updateProjectManifestObject.js';
+export { getAllUniqueSpecs, getSpecFromPackageManifest };
+export declare function filterDependenciesByType(manifest: ProjectManifest, include: IncludedDependencies): Dependencies;
+export declare function getAllDependenciesFromManifest(manifest: Pick<ProjectManifest, 'devDependencies' | 'dependencies' | 'optionalDependencies'>): Dependencies;

package/lib/index.js

@@ -0,0 +1,21 @@
+import { getAllUniqueSpecs } from './getAllUniqueSpecs.js';
+import { getSpecFromPackageManifest } from './getSpecFromPackageManifest.js';
+export * from './convertEnginesRuntimeToDependencies.js';
+export * from './getDependencyTypeFromManifest.js';
+export * from './updateProjectManifestObject.js';
+export { getAllUniqueSpecs, getSpecFromPackageManifest };
+export function filterDependenciesByType(manifest, include) {
+    return {
+        ...(include.devDependencies ? manifest.devDependencies : {}),
+        ...(include.dependencies ? manifest.dependencies : {}),
+        ...(include.optionalDependencies ? manifest.optionalDependencies : {}),
+    };
+}
+export function getAllDependenciesFromManifest(manifest) {
+    return {
+        ...manifest.devDependencies,
+        ...manifest.dependencies,
+        ...manifest.optionalDependencies,
+    };
+}
+//# sourceMappingURL=index.js.map

package/lib/updateProjectManifestObject.d.ts

@@ -0,0 +1,11 @@
+import { type DependenciesField, type DependenciesOrPeersField, type PinnedVersion, type ProjectManifest } from '@pnpm/types';
+export interface PackageSpecObject {
+    alias: string;
+    peer?: boolean;
+    bareSpecifier?: string;
+    resolvedVersion?: string;
+    pinnedVersion?: PinnedVersion;
+    saveType?: DependenciesField;
+}
+export declare function updateProjectManifestObject(prefix: string, packageManifest: ProjectManifest, packageSpecs: PackageSpecObject[]): Promise<ProjectManifest>;
+export declare function guessDependencyType(alias: string, manifest: ProjectManifest): DependenciesOrPeersField | undefined;

package/lib/updateProjectManifestObject.js

@@ -0,0 +1,69 @@
+import { packageManifestLogger } from '@pnpm/core-loggers';
+import { isValidPeerRange } from '@pnpm/deps.peer-range';
+import { DEPENDENCIES_FIELDS, DEPENDENCIES_OR_PEER_FIELDS, } from '@pnpm/types';
+import semver from 'semver';
+function getPeerSpecifier(spec, resolvedVersion, pinnedVersion) {
+    if (isValidPeerRange(spec))
+        return spec;
+    const rangeFromResolved = resolvedVersion ? createVersionSpecFromResolvedVersion(resolvedVersion, pinnedVersion) : null;
+    return rangeFromResolved ?? '*';
+}
+function createVersionSpecFromResolvedVersion(resolvedVersion, pinnedVersion) {
+    const parsed = semver.parse(resolvedVersion);
+    if (!parsed)
+        return null;
+    if (parsed.prerelease.length)
+        return resolvedVersion;
+    switch (pinnedVersion ?? 'major') {
+        case 'none':
+        case 'major':
+            return `^${resolvedVersion}`;
+        case 'minor':
+            return `~${resolvedVersion}`;
+        case 'patch':
+            return resolvedVersion;
+        default:
+            return `^${resolvedVersion}`;
+    }
+}
+export async function updateProjectManifestObject(prefix, packageManifest, packageSpecs) {
+    for (const packageSpec of packageSpecs) {
+        if (packageSpec.saveType) {
+            const spec = packageSpec.bareSpecifier ?? findSpec(packageSpec.alias, packageManifest);
+            if (spec) {
+                packageManifest[packageSpec.saveType] = packageManifest[packageSpec.saveType] ?? {};
+                packageManifest[packageSpec.saveType][packageSpec.alias] = spec;
+                for (const deptype of DEPENDENCIES_FIELDS) {
+                    if (deptype !== packageSpec.saveType) {
+                        delete packageManifest[deptype]?.[packageSpec.alias];
+                    }
+                }
+                if (packageSpec.peer === true) {
+                    packageManifest.peerDependencies = packageManifest.peerDependencies ?? {};
+                    packageManifest.peerDependencies[packageSpec.alias] = getPeerSpecifier(spec, packageSpec.resolvedVersion, packageSpec.pinnedVersion);
+                }
+            }
+        }
+        else if (packageSpec.bareSpecifier) {
+            const usedDepType = guessDependencyType(packageSpec.alias, packageManifest) ?? 'dependencies';
+            if (usedDepType !== 'peerDependencies') {
+                packageManifest[usedDepType] = packageManifest[usedDepType] ?? {};
+                packageManifest[usedDepType][packageSpec.alias] = packageSpec.bareSpecifier;
+            }
+        }
+    }
+    packageManifestLogger.debug({
+        prefix,
+        updated: packageManifest,
+    });
+    return packageManifest;
+}
+function findSpec(alias, manifest) {
+    const foundDepType = guessDependencyType(alias, manifest);
+    return foundDepType && manifest[foundDepType][alias];
+}
+export function guessDependencyType(alias, manifest) {
+    return DEPENDENCIES_OR_PEER_FIELDS
+        .find((depField) => manifest[depField]?.[alias] === '' || Boolean(manifest[depField]?.[alias]));
+}
+//# sourceMappingURL=updateProjectManifestObject.js.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@pnpm/pkg-manifest.utils",
+  "version": "1001.0.6",
+  "description": "Utils for dealing with package manifest",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/pkg-manifest/utils",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/pkg-manifest/utils#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": {
+    "semver": "^7.7.2",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/deps.peer-range": "1000.0.0",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/error": "1000.0.5"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@types/semver": "7.7.1",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/pkg-manifest.utils": "1001.0.6"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}