@pnpm/types

  • Version 8.0.1
  • Published
  • 10.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 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 homepage

                                    homepage?: string;

                                      property keywords

                                      keywords?: 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;
                                                                              };

                                                                                interface MissingPeerDependencyIssue

                                                                                interface MissingPeerDependencyIssue {}

                                                                                  property optional

                                                                                  optional: boolean;

                                                                                    property parents

                                                                                    parents: ParentPackages;

                                                                                      property wantedRange

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

                                                                                                                          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 BadPeerIssuesByPeerName

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

                                                                                                                                            type DependenciesField

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

                                                                                                                                              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;
                                                                                                                                                                    };
                                                                                                                                                                    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>