@pnpm/types

  • Version 8.9.0
  • Published
  • 11.1 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 DEPENDENCIES_FIELDS

const DEPENDENCIES_FIELDS: DependenciesField[];

    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 Dependencies

                                                                            interface Dependencies {}

                                                                              index signature

                                                                              [name: string]: 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;

                                                                                                                                        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 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 & {
                                                                                                                                                                                      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[];
                                                                                                                                                                                      };
                                                                                                                                                                                      };
                                                                                                                                                                                      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)

                                                                                                                                                                                          Peer Dependencies (0)

                                                                                                                                                                                          No peer dependencies.

                                                                                                                                                                                          Badge

                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto 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>