karma-typescript

  • Version 5.5.2
  • Published
  • 357 kB
  • 43 dependencies
  • MIT license

Install

npm i karma-typescript
yarn add karma-typescript
pnpm add karma-typescript

Overview

Simplifying running unit tests with coverage for Typescript projects.

Index

Interfaces

interface BundlerOptions

interface BundlerOptions {}

    property acornOptions

    acornOptions?: acorn.Options;

      property addNodeGlobals

      addNodeGlobals?: boolean;

        property constants

        constants?: {
        [key: string]: any;
        };

          property entrypoints

          entrypoints?: RegExp;

            property exclude

            exclude?: string[];

              property ignore

              ignore?: string[];

                property noParse

                noParse?: string[];

                  property resolve

                  resolve?: Resolve;

                    property sourceMap

                    sourceMap?: boolean;

                      property transforms

                      transforms?: Transform[];

                        property validateSyntax

                        validateSyntax?: boolean;

                          interface CompilerOptions

                          interface CompilerOptions extends ts.CompilerOptions {}

                            index signature

                            [key: string]: any;

                              interface CoverageOptions

                              interface CoverageOptions {}

                                property exclude

                                exclude?: RegExp | RegExp[];

                                  property instrumentation

                                  instrumentation?: boolean;

                                    property instrumenterOptions

                                    instrumenterOptions?: any;

                                      property threshold

                                      threshold?: ThresholdOptions;

                                        property watermarks

                                        watermarks?: any;

                                          interface Destination

                                          interface Destination {}

                                            property directory

                                            directory?: string;

                                              property filename

                                              filename?: string;

                                                property subdirectory

                                                subdirectory?: string | (() => void);

                                                  interface Extendable

                                                  interface Extendable {}

                                                    property mode

                                                    mode: 'merge' | 'replace';

                                                      property values

                                                      values: string[];

                                                        interface KarmaTypescriptConfig

                                                        interface KarmaTypescriptConfig {}

                                                          property bundlerOptions

                                                          bundlerOptions?: BundlerOptions;

                                                            property compilerDelay

                                                            compilerDelay?: number;

                                                              property compilerOptions

                                                              compilerOptions?: any;

                                                                property coverageOptions

                                                                coverageOptions?: CoverageOptions;

                                                                  property exclude

                                                                  exclude?: string[] | Extendable;

                                                                    property include

                                                                    include?: string[] | Extendable;

                                                                      property reports

                                                                      reports?: Reports;

                                                                        property stopOnFailure

                                                                        stopOnFailure?: boolean;

                                                                          property transformPath

                                                                          transformPath?: (filepath: string) => string;

                                                                            property tsconfig

                                                                            tsconfig?: string;

                                                                              index signature

                                                                              [key: string]: any;

                                                                                interface Reports

                                                                                interface Reports {}

                                                                                  property "html-spa"

                                                                                  'html-spa'?: string | Destination;

                                                                                    property "json-summary"

                                                                                    'json-summary'?: string | Destination;

                                                                                      property "text-lcov"

                                                                                      'text-lcov'?: string | Destination;

                                                                                        property "text-summary"

                                                                                        'text-summary'?: string | Destination;

                                                                                          property clover

                                                                                          clover?: string | Destination;

                                                                                            property cobertura

                                                                                            cobertura?: string | Destination;

                                                                                              property html

                                                                                              html?: string | Destination;

                                                                                                property json

                                                                                                json?: string | Destination;

                                                                                                  property lcovonly

                                                                                                  lcovonly?: string | Destination;

                                                                                                    property teamcity

                                                                                                    teamcity?: string | Destination;

                                                                                                      property text

                                                                                                      text?: string | Destination;

                                                                                                        index signature

                                                                                                        [key: string]: string | Destination;

                                                                                                          interface Resolve

                                                                                                          interface Resolve {}

                                                                                                            property alias

                                                                                                            alias?: {
                                                                                                            [key: string]: string;
                                                                                                            };

                                                                                                              property directories

                                                                                                              directories?: string[];

                                                                                                                property extensions

                                                                                                                extensions?: string[];

                                                                                                                  interface ThresholdOptions

                                                                                                                  interface ThresholdOptions {}

                                                                                                                    property file

                                                                                                                    file?: {
                                                                                                                    branches?: number;
                                                                                                                    excludes?: string[];
                                                                                                                    functions?: number;
                                                                                                                    lines?: number;
                                                                                                                    overrides?: {
                                                                                                                    [key: string]: {
                                                                                                                    branches?: number;
                                                                                                                    functions?: number;
                                                                                                                    lines?: number;
                                                                                                                    statements: number;
                                                                                                                    };
                                                                                                                    };
                                                                                                                    statements?: number;
                                                                                                                    };

                                                                                                                      property global

                                                                                                                      global?: {
                                                                                                                      branches?: number;
                                                                                                                      excludes?: string[];
                                                                                                                      functions?: number;
                                                                                                                      lines?: number;
                                                                                                                      statements?: number;
                                                                                                                      };

                                                                                                                        interface Transform

                                                                                                                        interface Transform {}

                                                                                                                          property initialize

                                                                                                                          initialize?: TransformInitialize;

                                                                                                                            call signature

                                                                                                                            (context: TransformContext, callback: TransformCallback): void;

                                                                                                                              interface TransformCallback

                                                                                                                              interface TransformCallback {}

                                                                                                                                call signature

                                                                                                                                (error: Error, dirty: boolean, transpile?: boolean): void;

                                                                                                                                  call signature

                                                                                                                                  (error: Error, result: TransformResult): void;

                                                                                                                                    interface TransformContext

                                                                                                                                    interface TransformContext {}

                                                                                                                                      property config

                                                                                                                                      config: Configuration;

                                                                                                                                        property filename

                                                                                                                                        filename: string;

                                                                                                                                          property js

                                                                                                                                          js?: TransformContextJs;

                                                                                                                                            property module

                                                                                                                                            module: string;

                                                                                                                                              property source

                                                                                                                                              source: string;

                                                                                                                                                property ts

                                                                                                                                                ts?: TransformContextTs;

                                                                                                                                                  interface TransformContextJs

                                                                                                                                                  interface TransformContextJs {}

                                                                                                                                                    property ast

                                                                                                                                                    ast: acorn.Node;

                                                                                                                                                      interface TransformContextTs

                                                                                                                                                      interface TransformContextTs {}

                                                                                                                                                        property ast

                                                                                                                                                        ast: ts.SourceFile;

                                                                                                                                                          property transpiled

                                                                                                                                                          transpiled: string;

                                                                                                                                                            property version

                                                                                                                                                            version: string;

                                                                                                                                                              interface TransformInitializeLogOptions

                                                                                                                                                              interface TransformInitializeLogOptions {}

                                                                                                                                                                property appenders

                                                                                                                                                                appenders: {
                                                                                                                                                                [name: string]: log4js.Appender;
                                                                                                                                                                };

                                                                                                                                                                  property level

                                                                                                                                                                  level: string;

                                                                                                                                                                    interface TransformResult

                                                                                                                                                                    interface TransformResult {}

                                                                                                                                                                      property dirty

                                                                                                                                                                      dirty?: boolean;

                                                                                                                                                                        property transformedScript

                                                                                                                                                                        transformedScript?: boolean;

                                                                                                                                                                          property transpile

                                                                                                                                                                          transpile?: boolean;

                                                                                                                                                                            Type Aliases

                                                                                                                                                                            type TransformInitialize

                                                                                                                                                                            type TransformInitialize = (log: TransformInitializeLogOptions) => void;

                                                                                                                                                                              Package Files (3)

                                                                                                                                                                              Dependencies (43)

                                                                                                                                                                              Dev Dependencies (26)

                                                                                                                                                                              Peer Dependencies (2)

                                                                                                                                                                              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/karma-typescript.

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