@types/istanbul-lib-coverage

  • Version 2.0.3
  • Published
  • 5.91 kB
  • No dependencies
  • MIT license

Install

npm i @types/istanbul-lib-coverage
yarn add @types/istanbul-lib-coverage
pnpm add @types/istanbul-lib-coverage

Overview

TypeScript definitions for istanbul-lib-coverage

Index

Variables

variable classes

const classes: { FileCoverage: FileCoverage };

    Functions

    function createCoverageMap

    createCoverageMap: (data?: CoverageMap | CoverageMapData) => CoverageMap;

      function createCoverageSummary

      createCoverageSummary: (
      obj?: CoverageSummary | CoverageSummaryData
      ) => CoverageSummary;

        function createFileCoverage

        createFileCoverage: (
        pathOrObject: string | FileCoverage | FileCoverageData
        ) => FileCoverage;

          Classes

          class CoverageMap

          class CoverageMap {}

            constructor

            constructor(data: CoverageMap | CoverageMapData);

              property data

              data: CoverageMapData;

                method addFileCoverage

                addFileCoverage: (
                pathOrObject: string | FileCoverage | FileCoverageData
                ) => void;

                  method fileCoverageFor

                  fileCoverageFor: (filename: string) => FileCoverage;

                    method files

                    files: () => string[];

                      method filter

                      filter: (callback: (key: string) => boolean) => void;

                        method getCoverageSummary

                        getCoverageSummary: () => CoverageSummary;

                          method merge

                          merge: (data: CoverageMapData | CoverageMap) => void;

                            method toJSON

                            toJSON: () => CoverageMapData;

                              class CoverageSummary

                              class CoverageSummary {}

                                constructor

                                constructor(data: CoverageSummary | CoverageSummaryData);

                                  property branches

                                  branches: Totals;

                                    property data

                                    data: CoverageSummaryData;

                                      property functions

                                      functions: Totals;

                                        property lines

                                        lines: Totals;

                                          property statements

                                          statements: Totals;

                                            method isEmpty

                                            isEmpty: () => boolean;

                                              method merge

                                              merge: (obj: CoverageSummary) => CoverageSummary;

                                                method toJSON

                                                toJSON: () => CoverageSummaryData;

                                                  class FileCoverage

                                                  class FileCoverage implements FileCoverageData {}

                                                    constructor

                                                    constructor(data: string | FileCoverage | FileCoverageData);

                                                      property b

                                                      b: { [key: string]: number[] };

                                                        property branchMap

                                                        branchMap: { [key: string]: BranchMapping };

                                                          property data

                                                          data: FileCoverageData;

                                                            property f

                                                            f: { [key: string]: number };

                                                              property fnMap

                                                              fnMap: { [key: string]: FunctionMapping };

                                                                property path

                                                                path: string;

                                                                  property s

                                                                  s: { [key: string]: number };

                                                                    property statementMap

                                                                    statementMap: { [key: string]: Range };

                                                                      method computeBranchTotals

                                                                      computeBranchTotals: () => Totals;

                                                                        method computeSimpleTotals

                                                                        computeSimpleTotals: () => Totals;

                                                                          method getBranchCoverageByLine

                                                                          getBranchCoverageByLine: () => { [line: number]: Coverage };

                                                                            method getLineCoverage

                                                                            getLineCoverage: () => { [line: number]: number };

                                                                              method getUncoveredLines

                                                                              getUncoveredLines: () => number[];

                                                                                method merge

                                                                                merge: (other: FileCoverageData) => void;

                                                                                  method resetHits

                                                                                  resetHits: () => void;

                                                                                    method toJSON

                                                                                    toJSON: () => object;

                                                                                      method toSummary

                                                                                      toSummary: () => CoverageSummary;

                                                                                        Interfaces

                                                                                        interface BranchMapping

                                                                                        interface BranchMapping {}

                                                                                          property line

                                                                                          line: number;

                                                                                            property loc

                                                                                            loc: Range;

                                                                                              property locations

                                                                                              locations: Range[];

                                                                                                property type

                                                                                                type: string;

                                                                                                  interface Coverage

                                                                                                  interface Coverage {}

                                                                                                    property coverage

                                                                                                    coverage: number;

                                                                                                      property covered

                                                                                                      covered: number;

                                                                                                        property total

                                                                                                        total: number;

                                                                                                          interface CoverageMapData

                                                                                                          interface CoverageMapData {}

                                                                                                            index signature

                                                                                                            [key: string]: FileCoverage | FileCoverageData;

                                                                                                              interface CoverageSummaryData

                                                                                                              interface CoverageSummaryData {}

                                                                                                                property branches

                                                                                                                branches: Totals;

                                                                                                                  property functions

                                                                                                                  functions: Totals;

                                                                                                                    property lines

                                                                                                                    lines: Totals;

                                                                                                                      property statements

                                                                                                                      statements: Totals;

                                                                                                                        interface FileCoverageData

                                                                                                                        interface FileCoverageData {}

                                                                                                                          property b

                                                                                                                          b: { [key: string]: number[] };

                                                                                                                            property branchMap

                                                                                                                            branchMap: { [key: string]: BranchMapping };

                                                                                                                              property f

                                                                                                                              f: { [key: string]: number };

                                                                                                                                property fnMap

                                                                                                                                fnMap: { [key: string]: FunctionMapping };

                                                                                                                                  property path

                                                                                                                                  path: string;

                                                                                                                                    property s

                                                                                                                                    s: { [key: string]: number };

                                                                                                                                      property statementMap

                                                                                                                                      statementMap: { [key: string]: Range };

                                                                                                                                        interface FunctionMapping

                                                                                                                                        interface FunctionMapping {}

                                                                                                                                          property decl

                                                                                                                                          decl: Range;

                                                                                                                                            property line

                                                                                                                                            line: number;

                                                                                                                                              property loc

                                                                                                                                              loc: Range;

                                                                                                                                                property name

                                                                                                                                                name: string;

                                                                                                                                                  interface Location

                                                                                                                                                  interface Location {}

                                                                                                                                                    property column

                                                                                                                                                    column: number;

                                                                                                                                                      property line

                                                                                                                                                      line: number;

                                                                                                                                                        interface Range

                                                                                                                                                        interface Range {}

                                                                                                                                                          property end

                                                                                                                                                          end: Location;

                                                                                                                                                            property start

                                                                                                                                                            start: Location;

                                                                                                                                                              interface Totals

                                                                                                                                                              interface Totals {}

                                                                                                                                                                property covered

                                                                                                                                                                covered: number;

                                                                                                                                                                  property pct

                                                                                                                                                                  pct: number;

                                                                                                                                                                    property skipped

                                                                                                                                                                    skipped: number;

                                                                                                                                                                      property total

                                                                                                                                                                      total: number;

                                                                                                                                                                        Package Files (1)

                                                                                                                                                                        Dependencies (0)

                                                                                                                                                                        No dependencies.

                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                        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/@types/istanbul-lib-coverage.

                                                                                                                                                                        • Markdown
                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/istanbul-lib-coverage)
                                                                                                                                                                        • HTML
                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@types/istanbul-lib-coverage"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>