@pnpm/resolving.npm-resolver 1004.4.1

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,65 @@
+# @pnpm/npm-resolver
+
+> Resolver for npm-hosted packages
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/npm-resolver.svg)](https://www.npmjs.com/package/@pnpm/npm-resolver)
+<!--/@-->
+
+## Installation
+
+```
+pnpm add @pnpm/npm-resolver
+```
+
+## Usage
+
+<!--@example('./example.js')-->
+```js
+'use strict'
+const createResolveFromNpm = require('@pnpm/npm-resolver').default
+
+const resolveFromNpm = createResolveFromNpm({
+  store: '.store',
+  offline: false,
+  rawConfig: {
+    registry: 'https://registry.npmjs.org/',
+  },
+})
+
+resolveFromNpm({alias: 'is-positive', bareSpecifier: '1.0.0'}, {
+  registry: 'https://registry.npmjs.org/',
+})
+.then(resolveResult => console.log(JSON.stringify(resolveResult, null, 2)))
+//> {
+//    "id": "registry.npmjs.org/is-positive/1.0.0",
+//    "latest": "3.1.0",
+//    "package": {
+//      "name": "is-positive",
+//      "version": "1.0.0",
+//      "devDependencies": {
+//        "ava": "^0.0.4"
+//      },
+//      "_hasShrinkwrap": false,
+//      "directories": {},
+//      "dist": {
+//        "shasum": "88009856b64a2f1eb7d8bb0179418424ae0452cb",
+//        "tarball": "https://registry.npmjs.org/is-positive/-/is-positive-1.0.0.tgz"
+//      },
+//      "engines": {
+//        "node": ">=0.10.0"
+//      }
+//    },
+//    "resolution": {
+//      "integrity": "sha1-iACYVrZKLx632LsBeUGEJK4EUss=",
+//      "registry": "https://registry.npmjs.org/",
+//      "tarball": "https://registry.npmjs.org/is-positive/-/is-positive-1.0.0.tgz"
+//    },
+//    "resolvedVia": "npm-registry"
+//  }
+```
+<!--/@-->
+
+## License
+
+MIT

package/lib/fetch.d.ts

@@ -0,0 +1,23 @@
+import { FetchError, type FetchErrorRequest, type FetchErrorResponse } from '@pnpm/error';
+import type { FetchFromRegistry, RetryTimeoutOptions } from '@pnpm/fetching.types';
+import type { PackageMeta } from '@pnpm/resolving.registry.types';
+export interface FetchMetadataResult {
+    meta: PackageMeta;
+    jsonText: string;
+}
+export declare class RegistryResponseError extends FetchError {
+    readonly pkgName: string;
+    constructor(request: FetchErrorRequest, response: FetchErrorResponse, pkgName: string);
+}
+export interface FetchMetadataFromFromRegistryOptions {
+    fetch: FetchFromRegistry;
+    retry: RetryTimeoutOptions;
+    timeout: number;
+    fetchWarnTimeoutMs: number;
+}
+export interface FetchMetadataOptions {
+    registry: string;
+    authHeaderValue?: string;
+    fullMetadata?: boolean;
+}
+export declare function fetchMetadataFromFromRegistry(fetchOpts: FetchMetadataFromFromRegistryOptions, pkgName: string, { authHeaderValue, fullMetadata, registry }: FetchMetadataOptions): Promise<FetchMetadataResult>;

package/lib/fetch.js

@@ -0,0 +1,92 @@
+import url from 'node:url';
+import { requestRetryLogger } from '@pnpm/core-loggers';
+import { FetchError, PnpmError, } from '@pnpm/error';
+import { globalWarn } from '@pnpm/logger';
+import * as retry from '@zkochan/retry';
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/use-ignore-case
+const semverRegex = /(.*)(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+export class RegistryResponseError extends FetchError {
+    pkgName;
+    constructor(request, response, pkgName) {
+        let hint;
+        if (response.status === 404) {
+            hint = `${pkgName} is not in the npm registry, or you have no permission to fetch it.`;
+            const matched = pkgName.match(semverRegex);
+            if (matched != null) {
+                hint += ` Did you mean ${matched[1]}?`;
+            }
+        }
+        super(request, response, hint);
+        this.pkgName = pkgName;
+    }
+}
+export async function fetchMetadataFromFromRegistry(fetchOpts, pkgName, { authHeaderValue, fullMetadata, registry, }) {
+    const uri = toUri(pkgName, registry);
+    const op = retry.operation(fetchOpts.retry);
+    return new Promise((resolve, reject) => {
+        op.attempt(async (attempt) => {
+            let response;
+            const startTime = Date.now();
+            try {
+                response = await fetchOpts.fetch(uri, {
+                    authHeaderValue,
+                    compress: true,
+                    fullMetadata,
+                    retry: fetchOpts.retry,
+                    timeout: fetchOpts.timeout,
+                });
+            }
+            catch (error) { // eslint-disable-line
+                reject(new PnpmError('META_FETCH_FAIL', `GET ${uri}: ${error.message}`, { attempts: attempt }));
+                return;
+            }
+            if (response.status >= 400) {
+                const request = {
+                    authHeaderValue,
+                    url: uri,
+                };
+                reject(new RegistryResponseError(request, response, pkgName));
+                return;
+            }
+            // Here we only retry broken JSON responses.
+            // Other HTTP issues are retried by the @pnpm/network.fetch library
+            try {
+                const jsonText = await response.text();
+                const meta = JSON.parse(jsonText);
+                // Check if request took longer than expected
+                const elapsedMs = Date.now() - startTime;
+                if (elapsedMs > fetchOpts.fetchWarnTimeoutMs) {
+                    globalWarn(`Request took ${elapsedMs}ms: ${uri}`);
+                }
+                resolve({ meta, jsonText });
+            }
+            catch (error) { // eslint-disable-line
+                const timeout = op.retry(new PnpmError('BROKEN_METADATA_JSON', error.message));
+                if (timeout === false) {
+                    reject(op.mainError());
+                    return;
+                }
+                requestRetryLogger.debug({
+                    attempt,
+                    error,
+                    maxRetries: fetchOpts.retry.retries,
+                    method: 'GET',
+                    timeout,
+                    url: uri,
+                });
+            }
+        });
+    });
+}
+function toUri(pkgName, registry) {
+    let encodedName;
+    if (pkgName[0] === '@') {
+        encodedName = `@${encodeURIComponent(pkgName.slice(1))}`;
+    }
+    else {
+        encodedName = encodeURIComponent(pkgName);
+    }
+    return new url.URL(encodedName, registry.endsWith('/') ? registry : `${registry}/`).toString();
+}
+//# sourceMappingURL=fetch.js.map

package/lib/index.d.ts

@@ -0,0 +1,99 @@
+import { PnpmError } from '@pnpm/error';
+import type { FetchFromRegistry, GetAuthHeader, RetryTimeoutOptions } from '@pnpm/fetching.types';
+import type { PackageMeta } from '@pnpm/resolving.registry.types';
+import type { DirectoryResolution, PkgResolutionId, PreferredVersions, ResolveResult, TarballResolution, WantedDependency, WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { DependencyManifest, PackageVersionPolicy, PinnedVersion, Registries, TrustPolicy } from '@pnpm/types';
+import { RegistryResponseError } from './fetch.js';
+import { parseBareSpecifier, type RegistryPackageSpec } from './parseBareSpecifier.js';
+import { type PackageMetaCache, pickPackage, type PickPackageOptions } from './pickPackage.js';
+import { workspacePrefToNpm } from './workspacePrefToNpm.js';
+export interface NoMatchingVersionErrorOptions {
+    wantedDependency: WantedDependency;
+    packageMeta: PackageMeta;
+    registry: string;
+    immatureVersion?: string;
+    publishedBy?: Date;
+}
+export declare class NoMatchingVersionError extends PnpmError {
+    readonly packageMeta: PackageMeta;
+    readonly immatureVersion?: string;
+    constructor(opts: NoMatchingVersionErrorOptions);
+}
+export { type PackageMeta, type PackageMetaCache, parseBareSpecifier, type RegistryPackageSpec, RegistryResponseError, workspacePrefToNpm, };
+export { whichVersionIsPinned } from './whichVersionIsPinned.js';
+export interface ResolverFactoryOptions {
+    cacheDir: string;
+    storeDir?: string;
+    fullMetadata?: boolean;
+    filterMetadata?: boolean;
+    offline?: boolean;
+    preferOffline?: boolean;
+    retry?: RetryTimeoutOptions;
+    timeout?: number;
+    registries: Registries;
+    saveWorkspaceProtocol?: boolean | 'rolling';
+    preserveAbsolutePaths?: boolean;
+    strictPublishedByCheck?: boolean;
+    fetchWarnTimeoutMs?: number;
+}
+export interface NpmResolveResult extends ResolveResult {
+    latest?: string;
+    manifest: DependencyManifest;
+    resolution: TarballResolution;
+    resolvedVia: 'npm-registry';
+}
+export interface JsrResolveResult extends ResolveResult {
+    alias: string;
+    manifest: DependencyManifest;
+    resolution: TarballResolution;
+    resolvedVia: 'jsr-registry';
+}
+export interface WorkspaceResolveResult extends ResolveResult {
+    manifest: DependencyManifest;
+    resolution: DirectoryResolution;
+    resolvedVia: 'workspace';
+}
+export type NpmResolver = (wantedDependency: WantedDependency & {
+    optional?: boolean;
+}, opts: ResolveFromNpmOptions) => Promise<NpmResolveResult | JsrResolveResult | WorkspaceResolveResult | null>;
+export declare function createNpmResolver(fetchFromRegistry: FetchFromRegistry, getAuthHeader: GetAuthHeader, opts: ResolverFactoryOptions): {
+    resolveFromNpm: NpmResolver;
+    resolveFromJsr: NpmResolver;
+    clearCache: () => void;
+};
+export interface ResolveFromNpmContext {
+    pickPackage: (spec: RegistryPackageSpec, opts: PickPackageOptions) => ReturnType<typeof pickPackage>;
+    getAuthHeaderValueByURI: (registry: string) => string | undefined;
+    registries: Registries;
+    saveWorkspaceProtocol?: boolean | 'rolling';
+    peekManifestFromStore?: (opts: {
+        id: PkgResolutionId;
+        integrity: string;
+        name?: string;
+        version?: string;
+    }) => Promise<DependencyManifest | undefined>;
+}
+export type ResolveFromNpmOptions = {
+    alwaysTryWorkspacePackages?: boolean;
+    defaultTag?: string;
+    publishedBy?: Date;
+    publishedByExclude?: PackageVersionPolicy;
+    pickLowestVersion?: boolean;
+    trustPolicy?: TrustPolicy;
+    trustPolicyExclude?: PackageVersionPolicy;
+    trustPolicyIgnoreAfter?: number;
+    dryRun?: boolean;
+    lockfileDir?: string;
+    preferredVersions?: PreferredVersions;
+    preferWorkspacePackages?: boolean;
+    update?: false | 'compatible' | 'latest';
+    injectWorkspacePackages?: boolean;
+    calcSpecifier?: boolean;
+    pinnedVersion?: PinnedVersion;
+} & ({
+    projectDir?: string;
+    workspacePackages?: undefined;
+} | {
+    projectDir: string;
+    workspacePackages: WorkspacePackages;
+});