@pnpm/types

@pnpm/types

Version 9.2.0
Published 2 months ago
11.4 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

DEPENDENCIES_FIELDS
DEPENDENCIES_OR_PEER_FIELDS

Type Aliases

AllowedDeprecatedVersions
BadPeerIssuesByPeerName
Dependencies
DependenciesField
DependenciesOrPeersField
DependencyManifest
HoistedDependencies
IncludedDependencies
LogBase
MissingPeerIssuesByPeerName
PackageBin
PackageExtension
PackageManifest
PackageScripts
ParentPackages
PeerDependencyIssuesByProjects
ProjectManifest
ProjectsGraph

Variables

variable DEPENDENCIES_FIELDS

const DEPENDENCIES_FIELDS: DependenciesField[];

variable DEPENDENCIES_OR_PEER_FIELDS

const DEPENDENCIES_OR_PEER_FIELDS: DependenciesOrPeersField[];

Interfaces

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 bundledDependencies

bundledDependencies?: string[];

property bundleDependencies

bundleDependencies?: string[];

property config

config?: object;

property cpu

cpu?: string[];

property dependencies

dependencies?: Dependencies;

property dependenciesMeta

dependenciesMeta?: DependenciesMeta;

property description

description?: string;

property devDependencies

devDependencies?: Dependencies;

property directories

directories?: {
    bin?: string;
};

property engines

engines?: {
    node?: string;
    npm?: string;
    pnpm?: string;
};

property files

files?: string[];

property homepage

homepage?: string;

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 types

types?: string;

property typesVersions

typesVersions?: TypesVersions;

property typings

typings?: string;

property version

version?: string;

interface DependenciesMeta

interface DependenciesMeta {}

index signature

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

interface MissingPeerDependencyIssue

interface MissingPeerDependencyIssue {}

property optional

optional: boolean;

property parents

parents: ParentPackages;

property wantedRange

wantedRange: string;

interface PatchFile

interface PatchFile {}

property hash

hash: string;

property path

path: string;

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 Project

interface Project {}

property dir

dir: string;

property manifest

manifest: ProjectManifest;

property writeProjectManifest

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

interface PublishConfig

interface PublishConfig extends Record<string, unknown> {}

property directory

directory?: string;

property executableFiles

executableFiles?: string[];

property linkDirectory

linkDirectory?: boolean;

property registry

registry?: string;

interface ReadPackageHook

interface ReadPackageHook {}

call signature

(pkg: PackageManifest, dir?: string): PackageManifest | Promise<PackageManifest>;

call signature

(pkg: ProjectManifest, dir?: string): ProjectManifest | Promise<ProjectManifest>;

interface Registries

interface Registries {}

property default

default: string;

index signature

[scope: string]: string;

interface TypesVersions

interface TypesVersions {}

index signature

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

Type Aliases

type AllowedDeprecatedVersions

type AllowedDeprecatedVersions = Record<string, string>;

type BadPeerIssuesByPeerName

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

type Dependencies

type Dependencies = Record<string, string>;

type DependenciesField

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

type DependenciesOrPeersField

type DependenciesOrPeersField = DependenciesField | 'peerDependencies';

type DependencyManifest

type DependencyManifest = BaseManifest &
    Required<Pick<BaseManifest, 'name' | 'version'>>;

type HoistedDependencies

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

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 PackageManifest

type PackageManifest = DependencyManifest & {
    deprecated?: string;
};

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 ParentPackages

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

type PeerDependencyIssuesByProjects

type PeerDependencyIssuesByProjects = Record<string, PeerDependencyIssues>;

type ProjectManifest

type ProjectManifest = BaseManifest & {
    workspaces?: string[];
    pnpm?: {
        neverBuiltDependencies?: string[];
        onlyBuiltDependencies?: string[];
        overrides?: Record<string, string>;
        packageExtensions?: Record<string, PackageExtension>;
        peerDependencyRules?: PeerDependencyRules;
        allowedDeprecatedVersions?: AllowedDeprecatedVersions;
        allowNonAppliedPatches?: boolean;
        patchedDependencies?: Record<string, string>;
        updateConfig?: {
            ignoreDependencies?: string[];
        };
        auditConfig?: {
            ignoreCves?: string[];
        };
        requiredScripts?: string[];
    };
    private?: boolean;
    resolutions?: Record<string, string>;
};

type ProjectsGraph

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

Package Files (6)

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 2 months ago.
Package analyzed in 4067 ms.
Missing or incorrect documentation? Open an issue for this package.