@pnpm/deps.graph-hasher 1002.0.8

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,17 @@
+# @pnpm/calc-dep-state
+
+> Calculates the state of a dependency
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/calc-dep-state.svg)](https://www.npmjs.com/package/@pnpm/calc-dep-state)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/calc-dep-state
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,42 @@
+import type { LockfileObject, LockfileResolution, PackageSnapshot } from '@pnpm/lockfile.types';
+import type { AllowBuild, DepPath, PkgIdWithPatchHash } from '@pnpm/types';
+export type DepsGraph<T extends string> = Record<T, DepsGraphNode<T>>;
+export interface DepsGraphNode<T extends string> {
+    children: {
+        [alias: string]: T;
+    };
+    pkgIdWithPatchHash?: PkgIdWithPatchHash;
+    resolution?: LockfileResolution;
+    fullPkgId?: string;
+}
+export interface DepsStateCache {
+    [depPath: string]: string;
+}
+export declare function calcDepState<T extends string>(depsGraph: DepsGraph<T>, cache: DepsStateCache, depPath: string, opts: {
+    patchFileHash?: string;
+    includeDepGraphHash: boolean;
+}): string;
+export interface PkgMeta {
+    depPath: DepPath;
+    name: string;
+    version: string;
+}
+export type PkgMetaIterator<T extends PkgMeta> = IterableIterator<T>;
+export interface HashedDepPath<T extends PkgMeta> {
+    pkgMeta: T;
+    hash: string;
+}
+export declare function iterateHashedGraphNodes<T extends PkgMeta>(graph: DepsGraph<DepPath>, pkgMetaIterator: PkgMetaIterator<T>, allowBuild?: AllowBuild): IterableIterator<HashedDepPath<T>>;
+export declare function calcGraphNodeHash<T extends PkgMeta>({ graph, cache, builtDepPaths, buildRequiredCache }: {
+    graph: DepsGraph<DepPath>;
+    cache: DepsStateCache;
+    builtDepPaths?: Set<DepPath>;
+    buildRequiredCache?: Record<string, boolean>;
+}, pkgMeta: T): string;
+export declare function calcLeafGlobalVirtualStorePath(fullPkgId: string, name: string, version: string): string;
+export interface PkgMetaAndSnapshot extends PkgMeta {
+    pkgSnapshot: PackageSnapshot;
+    pkgIdWithPatchHash: PkgIdWithPatchHash;
+}
+export declare function iteratePkgMeta(lockfile: LockfileObject, graph: DepsGraph<DepPath>): PkgMetaIterator<PkgMetaAndSnapshot>;
+export declare function lockfileToDepGraph(lockfile: LockfileObject): DepsGraph<DepPath>;

package/lib/index.js

@@ -0,0 +1,181 @@
+import { ENGINE_NAME } from '@pnpm/constants';
+import { hashObject, hashObjectWithoutSorting } from '@pnpm/crypto.object-hasher';
+import { getPkgIdWithPatchHash, refToRelative } from '@pnpm/deps.path';
+import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
+export function calcDepState(depsGraph, cache, depPath, opts) {
+    let result = ENGINE_NAME;
+    if (opts.includeDepGraphHash) {
+        const depGraphHash = calcDepGraphHash(depsGraph, cache, new Set(), depPath);
+        result += `;deps=${depGraphHash}`;
+    }
+    if (opts.patchFileHash) {
+        result += `;patch=${opts.patchFileHash}`;
+    }
+    return result;
+}
+function calcDepGraphHash(depsGraph, cache, parents, depPath) {
+    if (cache[depPath])
+        return cache[depPath];
+    const node = depsGraph[depPath];
+    if (!node)
+        return '';
+    if (!node.fullPkgId) {
+        if (!node.pkgIdWithPatchHash) {
+            throw new Error(`pkgIdWithPatchHash is not defined for ${depPath} in depsGraph`);
+        }
+        if (!node.resolution) {
+            throw new Error(`resolution is not defined for ${depPath} in depsGraph`);
+        }
+        node.fullPkgId = createFullPkgId(node.pkgIdWithPatchHash, node.resolution);
+    }
+    const deps = {};
+    if (Object.keys(node.children).length && !parents.has(node.fullPkgId)) {
+        const nextParents = new Set([...Array.from(parents), node.fullPkgId]);
+        const _calcDepGraphHash = calcDepGraphHash.bind(null, depsGraph, cache, nextParents);
+        for (const alias in node.children) {
+            if (Object.hasOwn(node.children, alias)) {
+                const childId = node.children[alias];
+                deps[alias] = _calcDepGraphHash(childId);
+            }
+        }
+    }
+    cache[depPath] = hashObject({
+        id: node.fullPkgId,
+        deps,
+    });
+    return cache[depPath];
+}
+export function* iterateHashedGraphNodes(graph, pkgMetaIterator, allowBuild) {
+    let builtDepPaths;
+    let entries;
+    if (allowBuild != null) {
+        const pkgMetaList = Array.from(pkgMetaIterator);
+        builtDepPaths = computeBuiltDepPaths(pkgMetaList, allowBuild);
+        entries = pkgMetaList;
+    }
+    else {
+        entries = pkgMetaIterator;
+    }
+    const _calcGraphNodeHash = calcGraphNodeHash.bind(null, {
+        graph,
+        cache: {},
+        builtDepPaths,
+        buildRequiredCache: builtDepPaths !== undefined ? {} : undefined,
+    });
+    for (const pkgMeta of entries) {
+        yield {
+            hash: _calcGraphNodeHash(pkgMeta),
+            pkgMeta,
+        };
+    }
+}
+export function calcGraphNodeHash({ graph, cache, builtDepPaths, buildRequiredCache }, pkgMeta) {
+    const { name, version, depPath } = pkgMeta;
+    // When builtDepPaths is provided (derived from the allowBuilds config),
+    // we only include the engine name for packages that are allowed to build
+    // or transitively depend on a package that is allowed to build.
+    // This makes GVS hashes engine-agnostic for pure-JS packages,
+    // so they survive Node.js upgrades and architecture changes.
+    const includeEngine = builtDepPaths === undefined ||
+        transitivelyRequiresBuild(graph, builtDepPaths, buildRequiredCache ??= {}, depPath, new Set());
+    const engine = includeEngine ? ENGINE_NAME : null;
+    const deps = calcDepGraphHash(graph, cache, new Set(), depPath);
+    const hexDigest = hashObjectWithoutSorting({ engine, deps }, { encoding: 'hex' });
+    return formatGlobalVirtualStorePath(name, version, hexDigest);
+}
+export function calcLeafGlobalVirtualStorePath(fullPkgId, name, version) {
+    const depsHash = hashObject({ id: fullPkgId, deps: {} });
+    const hexDigest = hashObjectWithoutSorting({ engine: null, deps: depsHash }, { encoding: 'hex' });
+    return formatGlobalVirtualStorePath(name, version, hexDigest);
+}
+// Use @/ prefix for unscoped packages to maintain uniform 4-level directory depth
+// Scoped: @scope/pkg/version/hash
+// Unscoped: @/pkg/version/hash
+function formatGlobalVirtualStorePath(name, version, hexDigest) {
+    const prefix = name.startsWith('@') ? '' : '@/';
+    return `${prefix}${name}/${version}/${hexDigest}`;
+}
+export function* iteratePkgMeta(lockfile, graph) {
+    if (lockfile.packages == null) {
+        return;
+    }
+    for (const depPath in lockfile.packages) {
+        if (!Object.hasOwn(lockfile.packages, depPath)) {
+            continue;
+        }
+        const pkgSnapshot = lockfile.packages[depPath];
+        const { name, version } = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
+        yield {
+            name,
+            version,
+            depPath: depPath,
+            pkgIdWithPatchHash: graph[depPath]?.pkgIdWithPatchHash ?? getPkgIdWithPatchHash(depPath),
+            pkgSnapshot,
+        };
+    }
+}
+export function lockfileToDepGraph(lockfile) {
+    const graph = {};
+    if (lockfile.packages != null) {
+        for (const [depPath, pkgSnapshot] of Object.entries(lockfile.packages)) {
+            const children = lockfileDepsToGraphChildren({
+                ...pkgSnapshot.dependencies,
+                ...pkgSnapshot.optionalDependencies,
+            });
+            graph[depPath] = {
+                children,
+                fullPkgId: createFullPkgId(getPkgIdWithPatchHash(depPath), pkgSnapshot.resolution),
+            };
+        }
+    }
+    return graph;
+}
+function computeBuiltDepPaths(entries, allowBuild) {
+    const builtDepPaths = new Set();
+    for (const { depPath, name, version } of entries) {
+        if (allowBuild(name, version) === true) {
+            builtDepPaths.add(depPath);
+        }
+    }
+    return builtDepPaths;
+}
+function transitivelyRequiresBuild(graph, builtDepPaths, cache, depPath, parents) {
+    if (depPath in cache)
+        return cache[depPath];
+    if (builtDepPaths.has(depPath)) {
+        cache[depPath] = true;
+        return true;
+    }
+    const node = graph[depPath];
+    if (!node) {
+        cache[depPath] = false;
+        return false;
+    }
+    if (parents.has(depPath)) {
+        return false;
+    }
+    const nextParents = new Set([...parents, depPath]);
+    for (const childDepPath of Object.values(node.children)) {
+        if (transitivelyRequiresBuild(graph, builtDepPaths, cache, childDepPath, nextParents)) {
+            cache[depPath] = true;
+            return true;
+        }
+    }
+    cache[depPath] = false;
+    return false;
+}
+function lockfileDepsToGraphChildren(deps) {
+    const children = {};
+    for (const [alias, reference] of Object.entries(deps)) {
+        const depPath = refToRelative(reference, alias);
+        if (depPath) {
+            children[alias] = depPath;
+        }
+    }
+    return children;
+}
+function createFullPkgId(pkgIdWithPatchHash, resolution) {
+    const res = 'integrity' in resolution ? String(resolution.integrity) : hashObject(resolution);
+    return `${pkgIdWithPatchHash}:${res}`;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@pnpm/deps.graph-hasher",
+  "version": "1002.0.8",
+  "description": "Calculates the state of a dependency",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/deps/graph-hasher",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/deps/graph-hasher#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": {
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/crypto.object-hasher": "1000.1.0",
+    "@pnpm/deps.path": "1001.1.3",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/lockfile.utils": "1003.0.3",
+    "@pnpm/lockfile.types": "1002.0.2"
+  },
+  "devDependencies": {
+    "@pnpm/deps.graph-hasher": "1002.0.8"
+  },
+  "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"
+  }
+}