@pnpm/hooks.pnpmfile 1002.1.3

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,15 @@
+# @pnpm/pnpmfile
+
+> Reading a .pnpmfile.cjs
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/pnpmfile.svg)](https://www.npmjs.com/package/@pnpm/pnpmfile)
+
+## Installation
+
+```sh
+pnpm add @pnpm/pnpmfile
+```
+
+## License
+
+MIT

package/lib/Hooks.d.ts

@@ -0,0 +1,16 @@
+import type { Log } from '@pnpm/core-loggers';
+import type { PreResolutionHook } from '@pnpm/hooks.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { ImportIndexedPackageAsync } from '@pnpm/store.controller-types';
+export interface HookContext {
+    log: (message: string) => void;
+}
+export interface Hooks {
+    readPackage?: (pkg: any, context: HookContext) => any;
+    beforePacking?: (pkg: any, dir: string, context: HookContext) => any;
+    preResolution?: PreResolutionHook;
+    afterAllResolved?: (lockfile: LockfileObject, context: HookContext) => LockfileObject | Promise<LockfileObject>;
+    filterLog?: (log: Log) => boolean;
+    importPackage?: ImportIndexedPackageAsync;
+    updateConfig?: (config: any) => any;
+}

package/lib/Hooks.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Hooks.js.map

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import type { CookedHooks } from './requireHooks.js';
+export type { HookContext } from './Hooks.js';
+export { requireHooks } from './requireHooks.js';
+export { BadReadPackageHookError } from './requirePnpmfile.js';
+export type Hooks = CookedHooks;

package/lib/index.js

@@ -0,0 +1,3 @@
+export { requireHooks } from './requireHooks.js';
+export { BadReadPackageHookError } from './requirePnpmfile.js';
+//# sourceMappingURL=index.js.map

package/lib/requireHooks.d.ts

@@ -0,0 +1,30 @@
+import type { CustomFetcher, CustomResolver, PreResolutionHookContext } from '@pnpm/hooks.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { ImportIndexedPackageAsync } from '@pnpm/store.controller-types';
+import type { BeforePackingHook, ReadPackageHook } from '@pnpm/types';
+import type { Hooks } from './Hooks.js';
+import { type Finders } from './requirePnpmfile.js';
+type Cook<T extends (...args: any[]) => any> = (arg: Parameters<T>[0], ...otherArgs: any[]) => ReturnType<T>;
+export interface CookedHooks {
+    readPackage?: ReadPackageHook[];
+    beforePacking?: BeforePackingHook[];
+    preResolution?: Array<(ctx: PreResolutionHookContext) => Promise<void>>;
+    afterAllResolved?: Array<(lockfile: LockfileObject) => LockfileObject | Promise<LockfileObject>>;
+    filterLog?: Array<Cook<Required<Hooks>['filterLog']>>;
+    updateConfig?: Array<Cook<Required<Hooks>['updateConfig']>>;
+    importPackage?: ImportIndexedPackageAsync;
+    customResolvers?: CustomResolver[];
+    customFetchers?: CustomFetcher[];
+    calculatePnpmfileChecksum?: () => Promise<string>;
+}
+export interface RequireHooksResult {
+    hooks: CookedHooks;
+    finders: Finders;
+    resolvedPnpmfilePaths: string[];
+}
+export declare function requireHooks(prefix: string, opts: {
+    globalPnpmfile?: string;
+    pnpmfiles?: string[];
+    tryLoadDefaultPnpmfile?: boolean;
+}): Promise<RequireHooksResult>;
+export {};

package/lib/requireHooks.js

@@ -0,0 +1,189 @@
+import { hookLogger } from '@pnpm/core-loggers';
+import { createHashFromMultipleFiles } from '@pnpm/crypto.hash';
+import { PnpmError } from '@pnpm/error';
+import { pathAbsolute } from 'path-absolute';
+import { requirePnpmfile } from './requirePnpmfile.js';
+export async function requireHooks(prefix, opts) {
+    const pnpmfiles = [];
+    if (opts.globalPnpmfile) {
+        pnpmfiles.push({
+            path: opts.globalPnpmfile,
+            includeInChecksum: false,
+        });
+    }
+    const entries = [];
+    const loadedFiles = [];
+    if (opts.tryLoadDefaultPnpmfile) {
+        // Prefer .pnpmfile.mjs over .pnpmfile.cjs. Only load one.
+        const mjsPath = pathAbsolute('.pnpmfile.mjs', prefix);
+        const mjsResult = await requirePnpmfile(mjsPath, prefix);
+        if (mjsResult != null) {
+            loadedFiles.push(mjsPath);
+            entries.push({
+                file: mjsPath,
+                includeInChecksum: true,
+                hooks: mjsResult.pnpmfileModule?.hooks,
+                finders: mjsResult.pnpmfileModule?.finders,
+                resolvers: mjsResult.pnpmfileModule?.resolvers,
+                fetchers: mjsResult.pnpmfileModule?.fetchers,
+            });
+        }
+        else {
+            pnpmfiles.push({
+                path: '.pnpmfile.cjs',
+                includeInChecksum: true,
+                optional: true,
+            });
+        }
+    }
+    if (opts.pnpmfiles) {
+        for (const pnpmfile of opts.pnpmfiles) {
+            pnpmfiles.push({
+                path: pnpmfile,
+                includeInChecksum: true,
+            });
+        }
+    }
+    await Promise.all(pnpmfiles.map(async ({ path, includeInChecksum, optional }) => {
+        const file = pathAbsolute(path, prefix);
+        if (!loadedFiles.includes(file)) {
+            loadedFiles.push(file);
+            const requirePnpmfileResult = await requirePnpmfile(file, prefix);
+            if (requirePnpmfileResult != null) {
+                entries.push({
+                    file,
+                    includeInChecksum,
+                    hooks: requirePnpmfileResult.pnpmfileModule?.hooks,
+                    finders: requirePnpmfileResult.pnpmfileModule?.finders,
+                    resolvers: requirePnpmfileResult.pnpmfileModule?.resolvers,
+                    fetchers: requirePnpmfileResult.pnpmfileModule?.fetchers,
+                });
+            }
+            else if (!optional) {
+                throw new PnpmError('PNPMFILE_NOT_FOUND', `pnpmfile at "${file}" is not found`);
+            }
+        }
+    }));
+    const mergedFinders = {};
+    const cookedHooks = {
+        readPackage: [],
+        beforePacking: [],
+        preResolution: [],
+        afterAllResolved: [],
+        filterLog: [],
+        updateConfig: [],
+    };
+    // calculate combined checksum for all included files
+    if (entries.some((entry) => entry.hooks != null)) {
+        cookedHooks.calculatePnpmfileChecksum = async () => {
+            const filesToIncludeInHash = [];
+            for (const { includeInChecksum, file } of entries) {
+                if (includeInChecksum) {
+                    filesToIncludeInHash.push(file);
+                }
+            }
+            filesToIncludeInHash.sort();
+            return createHashFromMultipleFiles(filesToIncludeInHash);
+        };
+    }
+    let importProvider;
+    const finderProviders = {};
+    // process hooks in order
+    for (const { hooks, file, finders } of entries) {
+        if (finders != null) {
+            for (const [finderName, finder] of Object.entries(finders)) {
+                if (mergedFinders[finderName] != null) {
+                    const firstDefinedIn = finderProviders[finderName];
+                    throw new PnpmError('DUPLICATE_FINDER', `Finder "${finderName}" defined in both ${firstDefinedIn} and ${file}`);
+                }
+                mergedFinders[finderName] = finder;
+                finderProviders[finderName] = file;
+            }
+        }
+        const fileHooks = hooks ?? {};
+        // readPackage
+        if (fileHooks.readPackage) {
+            const fn = fileHooks.readPackage;
+            const context = createReadPackageHookContext(file, prefix, 'readPackage');
+            cookedHooks.readPackage.push((pkg, _dir) => fn(pkg, context));
+        }
+        // beforePacking
+        if (fileHooks.beforePacking) {
+            const fn = fileHooks.beforePacking;
+            const context = createReadPackageHookContext(file, prefix, 'beforePacking');
+            cookedHooks.beforePacking.push((pkg, dir) => fn(pkg, dir, context));
+        }
+        // afterAllResolved
+        if (fileHooks.afterAllResolved) {
+            const fn = fileHooks.afterAllResolved;
+            const context = createReadPackageHookContext(file, prefix, 'afterAllResolved');
+            cookedHooks.afterAllResolved.push((lockfile) => fn(lockfile, context));
+        }
+        // filterLog
+        if (fileHooks.filterLog) {
+            cookedHooks.filterLog.push(fileHooks.filterLog);
+        }
+        // updateConfig
+        if (fileHooks.updateConfig) {
+            const updateConfig = fileHooks.updateConfig;
+            cookedHooks.updateConfig.push((config) => {
+                const updated = updateConfig(config);
+                if (updated == null) {
+                    throw new PnpmError('CONFIG_IS_UNDEFINED', 'The updateConfig hook returned undefined');
+                }
+                return updated;
+            });
+        }
+        // preResolution
+        if (fileHooks.preResolution) {
+            const preRes = fileHooks.preResolution;
+            cookedHooks.preResolution.push((ctx) => preRes(ctx, createPreResolutionHookLogger(prefix)));
+        }
+        // importPackage: only one allowed
+        if (fileHooks.importPackage) {
+            if (importProvider) {
+                throw new PnpmError('MULTIPLE_IMPORT_PACKAGE', `importPackage hook defined in both ${importProvider} and ${file}`);
+            }
+            importProvider = file;
+            cookedHooks.importPackage = fileHooks.importPackage;
+        }
+    }
+    // Process top-level resolvers and fetchers exports
+    for (const { resolvers, fetchers } of entries) {
+        // Custom resolvers: merge all
+        if (resolvers) {
+            cookedHooks.customResolvers = cookedHooks.customResolvers ?? [];
+            cookedHooks.customResolvers.push(...resolvers);
+        }
+        // Custom fetchers: merge all
+        if (fetchers) {
+            cookedHooks.customFetchers = cookedHooks.customFetchers ?? [];
+            cookedHooks.customFetchers.push(...fetchers);
+        }
+    }
+    return {
+        hooks: cookedHooks,
+        finders: mergedFinders,
+        resolvedPnpmfilePaths: entries.map(({ file }) => file),
+    };
+}
+function createReadPackageHookContext(calledFrom, prefix, hook) {
+    return {
+        log: (message) => {
+            hookLogger.debug({ from: calledFrom, hook, message, prefix });
+        },
+    };
+}
+function createPreResolutionHookLogger(prefix) {
+    const hook = 'preResolution';
+    const from = 'pnpmfile';
+    return {
+        info: (message) => {
+            hookLogger.info({ message, prefix, hook, from }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        },
+        warn: (message) => {
+            hookLogger.warn({ message, prefix, hook, from }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        },
+    };
+}
+//# sourceMappingURL=requireHooks.js.map

package/lib/requirePnpmfile.d.ts

@@ -0,0 +1,18 @@
+import { PnpmError } from '@pnpm/error';
+import type { CustomFetcher, CustomResolver } from '@pnpm/hooks.types';
+import type { Finder } from '@pnpm/types';
+import type { Hooks } from './Hooks.js';
+export declare class BadReadPackageHookError extends PnpmError {
+    readonly pnpmfile: string;
+    constructor(pnpmfile: string, message: string);
+}
+export type Finders = Record<string, Finder>;
+export interface Pnpmfile {
+    hooks?: Hooks;
+    finders?: Finders;
+    resolvers?: CustomResolver[];
+    fetchers?: CustomFetcher[];
+}
+export declare function requirePnpmfile(pnpmFilePath: string, prefix: string): Promise<{
+    pnpmfileModule: Pnpmfile | undefined;
+} | undefined>;

package/lib/requirePnpmfile.js

@@ -0,0 +1,94 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import { logger } from '@pnpm/logger';
+import chalk from 'chalk';
+const require = createRequire(import.meta.url);
+export class BadReadPackageHookError extends PnpmError {
+    pnpmfile;
+    constructor(pnpmfile, message) {
+        super('BAD_READ_PACKAGE_HOOK_RESULT', `${message} Hook imported via ${pnpmfile}`);
+        this.pnpmfile = pnpmfile;
+    }
+}
+class PnpmFileFailError extends PnpmError {
+    pnpmfile;
+    originalError;
+    constructor(pnpmfile, originalError) {
+        super('PNPMFILE_FAIL', `Error during pnpmfile execution. pnpmfile: "${pnpmfile}". Error: "${originalError.message}".`);
+        this.pnpmfile = pnpmfile;
+        this.originalError = originalError;
+    }
+}
+export async function requirePnpmfile(pnpmFilePath, prefix) {
+    try {
+        let pnpmfile;
+        // Check if it's an ESM module (ends with .mjs)
+        if (pnpmFilePath.endsWith('.mjs')) {
+            const url = pathToFileURL(path.resolve(pnpmFilePath)).href;
+            pnpmfile = await import(url);
+        }
+        else {
+            // Use require for CommonJS modules
+            pnpmfile = require(pnpmFilePath);
+        }
+        if (typeof pnpmfile === 'undefined') {
+            logger.warn({
+                message: `Ignoring the pnpmfile at "${pnpmFilePath}". It exports "undefined".`,
+                prefix,
+            });
+            return { pnpmfileModule: undefined };
+        }
+        if (pnpmfile?.hooks?.readPackage && typeof pnpmfile.hooks.readPackage !== 'function') {
+            throw new TypeError('hooks.readPackage should be a function');
+        }
+        if (pnpmfile?.hooks?.readPackage) {
+            const readPackage = pnpmfile.hooks.readPackage; // eslint-disable-line
+            pnpmfile.hooks.readPackage = async function (pkg, ...args) {
+                pkg.dependencies = pkg.dependencies ?? {};
+                pkg.devDependencies = pkg.devDependencies ?? {};
+                pkg.optionalDependencies = pkg.optionalDependencies ?? {};
+                pkg.peerDependencies = pkg.peerDependencies ?? {};
+                const newPkg = await readPackage(pkg, ...args);
+                if (!newPkg) {
+                    throw new BadReadPackageHookError(pnpmFilePath, 'readPackage hook did not return a package manifest object.');
+                }
+                const dependencies = ['dependencies', 'optionalDependencies', 'peerDependencies'];
+                for (const dep of dependencies) {
+                    if (newPkg[dep] && typeof newPkg[dep] !== 'object') {
+                        throw new BadReadPackageHookError(pnpmFilePath, `readPackage hook returned package manifest object's property '${dep}' must be an object.`);
+                    }
+                }
+                return newPkg;
+            };
+            if (pnpmfile?.hooks?.beforePacking && typeof pnpmfile.hooks.beforePacking !== 'function') {
+                throw new TypeError('hooks.beforePacking should be a function');
+            }
+        }
+        return { pnpmfileModule: pnpmfile };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            console.error(chalk.red(`A syntax error in the "${pnpmFilePath}"\n`));
+            console.error(err);
+            process.exit(1);
+        }
+        assert(util.types.isNativeError(err));
+        if (!('code' in err && (err.code === 'MODULE_NOT_FOUND' || err.code === 'ERR_MODULE_NOT_FOUND')) ||
+            pnpmFileExistsSync(pnpmFilePath)) {
+            throw new PnpmFileFailError(pnpmFilePath, err);
+        }
+        return undefined;
+    }
+}
+function pnpmFileExistsSync(pnpmFilePath) {
+    const pnpmFileRealName = pnpmFilePath.endsWith('.cjs') || pnpmFilePath.endsWith('.mjs')
+        ? pnpmFilePath
+        : `${pnpmFilePath}.cjs`;
+    return fs.existsSync(pnpmFileRealName);
+}
+//# sourceMappingURL=requirePnpmfile.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@pnpm/hooks.pnpmfile",
+  "version": "1002.1.3",
+  "description": "Reading a .pnpmfile.cjs",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/hooks/pnpmfile",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/hooks/pnpmfile#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": {
+    "chalk": "^5.6.0",
+    "path-absolute": "^2.0.0",
+    "@pnpm/crypto.hash": "1000.2.1",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/hooks.types": "1001.0.12",
+    "@pnpm/lockfile.types": "1002.0.2",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/store.controller-types": "1004.1.0",
+    "@pnpm/core-loggers": "1001.0.4"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@pnpm/fetching.fetcher-base": "1001.0.2",
+    "@pnpm/hooks.pnpmfile": "1002.1.3",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/test-fixtures": "1000.0.0"
+  },
+  "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"
+  }
+}