@pnpm/types

@pnpm/types

Version 1101.6.0
Published 1 day ago
52.5 kB
No dependencies
MIT license

Install

npm i @pnpm/types

yarn add @pnpm/types

pnpm add @pnpm/types

Overview

Basic types used by pnpm

Index

Variables

variable DEFAULT_REGISTRY_SCOPE

const DEFAULT_REGISTRY_SCOPE: string;

variable DEPENDENCIES_FIELDS

const DEPENDENCIES_FIELDS: DependenciesField[];

variable DEPENDENCIES_OR_PEER_FIELDS

const DEPENDENCIES_OR_PEER_FIELDS: DependenciesOrPeersField[];

variable RUNTIME_NAMES

const RUNTIME_NAMES: readonly ['node', 'deno', 'bun'];

Functions

function isRuntimeAlias

isRuntimeAlias: (alias: string) => alias is 'node' | 'deno' | 'bun';

Interfaces

interface AllowBuildContext

interface AllowBuildContext {}

property trustPackageIdentity

trustPackageIdentity?: boolean;

interface AuditConfig

interface AuditConfig {}

Deprecated
Use AuditSettings instead. Kept for backward compatibility until the next major version.

property ignoreGhsas

ignoreGhsas?: string[];

interface AuditSettings

interface AuditSettings {}

property ignore

ignore?: string[];

GHSA IDs that pnpm audit should ignore. Supersedes auditConfig.ignoreGhsas.

property level

level?: AuditLevel;

The minimum vulnerability severity pnpm audit reports on. Supersedes the top-level auditLevel setting.

interface BadPeerDependencyIssue

interface BadPeerDependencyIssue extends MissingPeerDependencyIssue {}

property foundVersion

foundVersion: string;

property resolvedFrom

resolvedFrom: ParentPackages;

interface BaseManifest

interface BaseManifest {}

property author

author?: string;

property bin

bin?: PackageBin;

property bugs

bugs?:
    | string
    | {
          url?: string;
          email?: string;
      };

property bundledDependencies

bundledDependencies?: string[] | boolean;

property bundleDependencies

bundleDependencies?: string[] | boolean;

property config

config?: Record<string, unknown>;

property cpu

cpu?: string[];

property dependencies

dependencies?: Dependencies;

property dependenciesMeta

dependenciesMeta?: DependenciesMeta;

property description

description?: string;

property devDependencies

devDependencies?: Dependencies;

property devEngines

devEngines?: DevEngines;

property directories

directories?: {
    bin?: string;
};

property engines

engines?: {
    node?: string;
    npm?: string;
    pnpm?: string;
} & Pick<DevEngines, 'runtime'>;

property exports

exports?: Record<string, string>;

property files

files?: string[];

property funding

funding?: string;

property homepage

homepage?: string;

property imports

imports?: Record<string, unknown>;

property keywords

keywords?: string[];

property libc

libc?: string[];

property license

license?: string;

property main

main?: string;

property module

module?: string;

property name

name?: string;

property optionalDependencies

optionalDependencies?: Dependencies;

property os

os?: string[];

property peerDependencies

peerDependencies?: Dependencies;

property peerDependenciesMeta

peerDependenciesMeta?: PeerDependenciesMeta;

property publishConfig

publishConfig?: PublishConfig;

property readme

readme?: string;

property repository

repository?:
    | string
    | {
          url: string;
      };

property scripts

scripts?: PackageScripts;

property type

type?: string;

property types

types?: string;

property typesVersions

typesVersions?: TypesVersions;

property typings

typings?: string;

property version

version?: string;

interface BasicAuth

interface BasicAuth {}

Parsed value of _auth of each registry in the rc file.

property password

password: string;

property username

username: string;

interface Creds

interface Creds {}

Per-registry authentication credentials.

property authToken

authToken?: string;

The value of _authToken of each registry in the rc file.

property basicAuth

basicAuth?: BasicAuth;

Parsed value of _auth of each registry in the rc file.

property tokenHelper

tokenHelper?: TokenHelper;

Parsed value of tokenHelper of each registry in the rc file.

interface DependenciesMeta

interface DependenciesMeta {}

index signature

[dependencyName: string]: {
    injected?: boolean;
    patch?: string;
};

interface DependencyManifest

interface DependencyManifest extends BaseManifest {}

property name

name: string;

property version

version: string;

interface EngineDependency

interface EngineDependency {}

property name

name: string;

property onFail

onFail?: 'ignore' | 'warn' | 'error' | 'download';

property version

version?: string;

interface FinderContext

interface FinderContext {}

property alias

alias: string;

property name

name: string;

property readManifest

readManifest: () => DependencyManifest;

property version

version: string;

interface MissingPeerDependencyIssue

interface MissingPeerDependencyIssue {}

property optional

optional: boolean;

property parents

parents: ParentPackages;

property wantedRange

wantedRange: string;

interface PackageManifest

interface PackageManifest extends DependencyManifest {}

property deprecated

deprecated?: string;

interface PackageVulnerability

interface PackageVulnerability {}

property severity

severity: VulnerabilitySeverity;

The severity of the vulnerability

property versionRange

versionRange: string;

A semver version range that indicates which versions are vulnerable

interface PackageVulnerabilityAudit

interface PackageVulnerabilityAudit {}

property getVulnerabilities

getVulnerabilities: () => Map<string, PackageVulnerability[]>;

Get all vulnerabilities for all packages.
Returns
A map where the keys are package names and the values are arrays of vulnerabilities for those packages.

property isVulnerable

isVulnerable: (packageName: string, version: string) => boolean;

Check if the given package version is vulnerable.

interface PeerDependenciesMeta

interface PeerDependenciesMeta {}

index signature

[dependencyName: string]: {
    optional?: boolean;
};

interface PeerDependencyIssues

interface PeerDependencyIssues {}

property bad

bad: BadPeerIssuesByPeerName;

property conflicts

conflicts: string[];

property intersections

intersections: Record<string, string>;

property missing

missing: MissingPeerIssuesByPeerName;

interface PeerDependencyRules

interface PeerDependencyRules {}

property allowAny

allowAny?: string[];

property allowedVersions

allowedVersions?: Record<string, string>;

property ignoreMissing

ignoreMissing?: string[];

interface PnpmSettings

interface PnpmSettings {}

property allowBuilds

allowBuilds?: Record<string, boolean | string>;

property allowedDeprecatedVersions

allowedDeprecatedVersions?: AllowedDeprecatedVersions;

property allowUnusedPatches

allowUnusedPatches?: boolean;

property audit

audit?: AuditSettings;

property auditConfig

auditConfig?: AuditConfig;

Deprecated
Use PnpmSettings.audit instead. Kept for backward compatibility until the next major version.

property configDependencies

configDependencies?: ConfigDependencies;

property httpProxy

httpProxy?: string;

property httpsProxy

httpsProxy?: string;

property ignoredOptionalDependencies

ignoredOptionalDependencies?: string[];

property namedRegistries

namedRegistries?: Record<string, string>;

property nodeDownloadMirrors

nodeDownloadMirrors?: Record<string, string>;

property noProxy

noProxy?: string | boolean;

property npmrcAuthFile

npmrcAuthFile?: string;

property overrides

overrides?: Record<string, string>;

property packageExtensions

packageExtensions?: Record<string, PackageExtension>;

property patchedDependencies

patchedDependencies?: Record<string, string>;

property peerDependencyRules

peerDependencyRules?: PeerDependencyRules;

property pnprServer

pnprServer?: string;

property registries

registries?: Registries;

property requiredScripts

requiredScripts?: string[];

property supportedArchitectures

supportedArchitectures?: SupportedArchitectures;

property update

update?: UpdateSettings;

property updateConfig

updateConfig?: {
    changeset?: boolean;
    ignoreDependencies?: string[];
    githubActions?: boolean;
    githubActionsServer?: string;
};

Deprecated
Use PnpmSettings.update instead. Kept for backward compatibility until the next major version.

property versioning

versioning?: VersioningSettings;

interface Project

interface Project {}

property manifest

manifest: ProjectManifest;

property modulesDir

modulesDir?: string;

property rootDir

rootDir: ProjectRootDir;

property rootDirRealPath

rootDirRealPath: ProjectRootDirRealPath;

property writeProjectManifest

writeProjectManifest: (
    manifest: ProjectManifest,
    force?: boolean | undefined
) => Promise<void>;

interface ProjectManifest

interface ProjectManifest extends BaseManifest {}

property packageManager

packageManager?: string;

property private

private?: boolean;

property resolutions

resolutions?: Record<string, string>;

property workspaces

workspaces?: string[];

interface PublishConfig

interface PublishConfig extends Record<string, unknown> {}

property access

access?: 'public' | 'restricted';

property directory

directory?: string;

property executableFiles

executableFiles?: string[];

property linkDirectory

linkDirectory?: boolean;

property registry

registry?: string;

interface Registries

interface Registries {}

property default

default: string;

index signature

[scope: string]: string;

interface RegistryConfig

interface RegistryConfig {}

Per-registry configuration (credentials + TLS).

property tls

tls?: TlsConfig;

index signature

[scope: `@${string}`]: Creds | undefined;

interface SupportedArchitectures

interface SupportedArchitectures {}

property cpu

cpu?: string[];

property libc

libc?: string[];

property os

os?: string[];

interface TlsConfig

interface TlsConfig {}

Per-registry TLS configuration.

property ca

ca?: string;

Certificate authority (PEM).

property cert

cert?: string;

Client certificate (PEM).

property key

key?: string;

Client private key (PEM).

interface TypesVersions

interface TypesVersions {}

index signature

[version: Version]: {
    [pattern: Pattern]: string[];
};

interface UpdateSettings

interface UpdateSettings {}

property changeset

changeset?: boolean;

Generate a changeset for the updated production dependencies by default, as if pnpm update were run with --changeset.

property githubActions

githubActions?: boolean;

Whether pnpm update should also update GitHub Actions dependencies. When explicitly set to false, pnpm outdated and the interactive pnpm update skip GitHub Actions dependencies as well.

property githubActionsServer

githubActionsServer?: string;

The base URL of the GitHub server that hosts the repositories of the GitHub Actions referenced by the workflow files (for example, a GitHub Enterprise Server). When not set, the GITHUB_SERVER_URL environment variable is used, falling back to https://github.com.

property ignoreDeps

ignoreDeps?: string[];

Dependency name patterns that pnpm update and pnpm outdated should skip.

interface VersioningChangelogSettings

interface VersioningChangelogSettings {}

property format

format?: string;

property storage

storage?: VersioningChangelogStorage;

Where release changelogs live. Defaults to registry: no CHANGELOG.md is committed; each release's section is composed at publish time and packed into the published tarball, on top of the previously published version's changelog. repository keeps a committed CHANGELOG.md in every package.

interface VersioningEpic

interface VersioningEpic {}

An epic ties a group of member packages to a lead package, constraining every member's major version to the band derived from the lead's major: while the lead is on major M, members live in M×100 … M×100+99. Members move independently inside the band; when a release plan takes the lead to a new stable major, every member re-bases to the band floor in the same plan.

property lead

lead: string;

The package whose major version defines the band, referenced by name or by ./-prefixed workspace directory (e.g. pnpm).

property packages

packages: string[];

Selectors matching the member packages: name globs, ./-prefixed directory globs, and !-prefixed negations, following pnpm's selector conventions (e.g. ["./pnpm11/**", "!./pnpm11/private/**"]).

interface VersioningSettings

interface VersioningSettings {}

Settings for native workspace release management, declared under the versioning key of pnpm-workspace.yaml.

property changelog

changelog?: VersioningChangelogSettings;

property epics

epics?: VersioningEpic[];

Epics that band member packages' majors to a lead package's major.

property fixed

fixed?: string[][];

Groups of packages that always release together at one shared version.

property ignore

ignore?: string[];

Packages permanently excluded from versioning and dependent propagation.

property lanes

lanes?: Record<string, string>;

Per-package release lanes: maps a package name to the lane it is on (e.g. "@example/cli": "alpha"). A lane is a parallel release track that emits X.Y.Z-tag.N prereleases; every unlisted package is on the reserved default lane, main, and releases stable versions.

property maxBump

maxBump?: VersioningBumpType;

Caps the bump a release from the current checkout may apply. Enforced on the final assembled release plan, after dependent propagation and fixed-group resolution.

Type Aliases

type AllowBuild

type AllowBuild = (
    depPath: DepPath,
    context?: AllowBuildContext
) => boolean | undefined;

type AllowedDeprecatedVersions

type AllowedDeprecatedVersions = Record<string, string>;

type AuditLevel

type AuditLevel = 'info' | 'low' | 'moderate' | 'high' | 'critical';

type BadPeerIssuesByPeerName

type BadPeerIssuesByPeerName = Record<string, BadPeerDependencyIssue[]>;

type BeforePackingHook

type BeforePackingHook = <Pkg extends BaseManifest>(
    pkg: Pkg,
    dir: string
) => Pkg | Promise<Pkg>;

type BundledManifest

type BundledManifest = Pick<
    BaseManifest,
    | 'bin'
    | 'bundledDependencies'
    | 'bundleDependencies'
    | 'cpu'
    | 'dependencies'
    | 'devDependencies'
    | 'directories'
    | 'engines'
    | 'libc'
    | 'name'
    | 'optionalDependencies'
    | 'os'
    | 'peerDependencies'
    | 'peerDependenciesMeta'
    | 'scripts'
    | 'version'
>;

Subset of package.json fields cached in the store index. Used for bin linking, build scripts, runtime selection, and dependency resolution.

type ConfigDependencies

type ConfigDependencies = Record<
    string,
    | VersionWithIntegrity
    | {
          tarball?: string;
          integrity: VersionWithIntegrity;
      }
>;

Old format (inline integrity in pnpm-workspace.yaml): "@my-org/cfg": "1.2.0+sha512-XYZ" or { tarball: "...", integrity: "1.2.0+sha512-XYZ" }
New format (plain specifiers in pnpm-workspace.yaml, integrity in pnpm-lock.yaml): "@my-org/cfg": "^1.2.0"

type ConfigDependencySpecifiers

type ConfigDependencySpecifiers = Record<string, string>;

Clean specifiers for configDependencies in pnpm-workspace.yaml (new format). Integrity info is stored in pnpm-lock.yaml instead.

type Dependencies

type Dependencies = Record<string, string>;

type DependenciesField

type DependenciesField = 'optionalDependencies' | 'dependencies' | 'devDependencies';

type DependenciesOrPeersField

type DependenciesOrPeersField = DependenciesField | 'peerDependencies';

type DepPath

type DepPath = string & {
    __brand: 'DepPath';
};

type DevEngines

type DevEngines = Partial<
    Record<DevEngineKey, EngineDependency | EngineDependency[]>
>;

type Finder

type Finder = (ctx: FinderContext) => boolean | string;

type HoistedDependencies

type HoistedDependencies = Record<
    DepPath | ProjectId,
    Record<string, 'public' | 'private'>
>;

type IgnoredBuilds

type IgnoredBuilds = Set<DepPath>;

type IncludedDependencies

type IncludedDependencies = {
    [dependenciesField in DependenciesField]: boolean;
};

type LogBase

type LogBase =
    | {
          level: 'debug' | 'error';
      }
    | {
          level: 'info' | 'warn';
          prefix: string;
          message: string;
      };

type MissingPeerIssuesByPeerName

type MissingPeerIssuesByPeerName = Record<string, MissingPeerDependencyIssue[]>;

type PackageBin

type PackageBin =
    | string
    | {
          [commandName: string]: string;
      };

type PackageExtension

type PackageExtension = Pick<
    BaseManifest,
    | 'dependencies'
    | 'optionalDependencies'
    | 'peerDependencies'
    | 'peerDependenciesMeta'
>;

type PackageScripts

type PackageScripts = {
    [name: string]: string;
} & {
    prepublish?: string;
    prepare?: string;
    prepublishOnly?: string;
    prepack?: string;
    postpack?: string;
    publish?: string;
    postpublish?: string;
    preinstall?: string;
    install?: string;
    postinstall?: string;
    preuninstall?: string;
    uninstall?: string;
    postuninstall?: string;
    preversion?: string;
    version?: string;
    postversion?: string;
    pretest?: string;
    test?: string;
    posttest?: string;
    prestop?: string;
    stop?: string;
    poststop?: string;
    prestart?: string;
    start?: string;
    poststart?: string;
    prerestart?: string;
    restart?: string;
    postrestart?: string;
    preshrinkwrap?: string;
    shrinkwrap?: string;
    postshrinkwrap?: string;
};

type PackageVersionPolicy

type PackageVersionPolicy = (pkgName: string) => boolean | string[];

type ParentPackages

type ParentPackages = Array<{
    name: string;
    version: string;
}>;

type PeerDependencyIssuesByProjects

type PeerDependencyIssuesByProjects = Record<string, PeerDependencyIssues>;

type PinnedVersion

type PinnedVersion = 'none' | 'patch' | 'minor' | 'major';

type PkgId

type PkgId = string & {
    __brand: 'PkgId';
};

type PkgIdWithPatchHash

type PkgIdWithPatchHash = string & {
    __brand: 'PkgIdWithPatchHash';
};

type PkgResolutionId

type PkgResolutionId = string & {
    __brand: 'PkgResolutionId';
};

type ProjectId

type ProjectId = string & {
    __brand: 'ProjectId';
};

type ProjectRootDir

type ProjectRootDir = string & {
    __brand: 'ProjectRootDir';
};

type ProjectRootDirRealPath

type ProjectRootDirRealPath = string & {
    __brand: 'ProjectRootDirRealPath';
};

type ProjectsGraph

type ProjectsGraph = Record<
    ProjectRootDir,
    {
        dependencies: ProjectRootDir[];
        package: Project;
    }
>;

type ReadPackageHook

type ReadPackageHook = <Pkg extends BaseManifest>(
    pkg: Pkg,
    dir?: string
) => Pkg | Promise<Pkg>;

type RuntimeName

type RuntimeName = (typeof RUNTIME_NAMES)[number];

type TokenHelper

type TokenHelper = [string, ...string[]];

Parsed value of tokenHelper of each registry in the rc file.

type TrustPolicy

type TrustPolicy = 'no-downgrade' | 'off';

type VersioningBumpType

type VersioningBumpType = 'patch' | 'minor' | 'major';

type VersioningChangelogStorage

type VersioningChangelogStorage = 'registry' | 'repository';

type VulnerabilitySeverity

type VulnerabilitySeverity = 'info' | 'low' | 'moderate' | 'high' | 'critical';

Package Files (8)

Dependencies (0)

No dependencies.

Dev Dependencies (1)

@pnpm/types

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@pnpm/types.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@pnpm/types)

HTML

<a href="https://www.jsdocs.io/package/@pnpm/types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 day ago.
Package analyzed in 3397 ms.
Missing or incorrect documentation? Open an issue for this package.