Logo for jsDocs.io

jest-watcher

  • Version 30.2.0
  • Published
  • 28.6 kB
  • 8 dependencies
  • MIT license

Install

npm i jest-watcher
yarn add jest-watcher
pnpm add jest-watcher

Overview

Delightful JavaScript Testing.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable KEYS

const KEYS: {
    ARROW_DOWN: string;
    ARROW_LEFT: string;
    ARROW_RIGHT: string;
    ARROW_UP: string;
    BACKSPACE: string;
    CONTROL_C: string;
    CONTROL_D: string;
    CONTROL_U: string;
    ENTER: string;
    ESCAPE: string;
};

    Functions

    function printPatternCaret

    printPatternCaret: (pattern: string, pipe: NodeJS.WritableStream) => void;

      function printRestoredPatternCaret

      printRestoredPatternCaret: (
          pattern: string,
          currentUsageRows: number,
          pipe: NodeJS.WritableStream
      ) => void;

        Classes

        class BaseWatchPlugin

        abstract class BaseWatchPlugin implements WatchPlugin {}

          constructor

          constructor({ stdin, stdout }: { stdin: ReadStream; stdout: WriteStream });

            method apply

            apply: (_hooks: JestHookSubscriber) => void;

              method getUsageInfo

              getUsageInfo: (_globalConfig: Config.GlobalConfig) => UsageData | null;

                method onKey

                onKey: (_key: string) => void;

                  method run

                  run: (
                      _globalConfig: Config.GlobalConfig,
                      _updateConfigAndRun: UpdateConfigCallback
                  ) => Promise<void | boolean>;

                    class JestHook

                    class JestHook {}

                      constructor

                      constructor();

                        method getEmitter

                        getEmitter: () => Readonly<JestHookEmitter>;

                          method getSubscriber

                          getSubscriber: () => Readonly<JestHookSubscriber>;

                            method isUsed

                            isUsed: (hook: AvailableHooks) => boolean;

                              class PatternPrompt

                              abstract class PatternPrompt {}

                                constructor

                                constructor(_pipe: NodeJS.WritableStream, _prompt: Prompt, _entityName?: string);

                                  method run

                                  run: (
                                      onSuccess: (value: string) => void,
                                      onCancel: () => void,
                                      options?: { header: string }
                                  ) => void;

                                    class Prompt

                                    class Prompt {}

                                      constructor

                                      constructor();

                                        method abort

                                        abort: () => void;

                                          method enter

                                          enter: (
                                              onChange: (pattern: string, options: ScrollOptions_2) => void,
                                              onSuccess: (pattern: string) => void,
                                              onCancel: () => void
                                          ) => void;

                                            method isEntering

                                            isEntering: () => boolean;

                                              method put

                                              put: (key: string) => void;

                                                method setPromptLength

                                                setPromptLength: (length: number) => void;

                                                  method setPromptSelection

                                                  setPromptSelection: (selected: string) => void;

                                                    class TestWatcher

                                                    class TestWatcher extends Emittery<{
                                                        change: State;
                                                    }> {}

                                                      constructor

                                                      constructor({ isWatchMode }: { isWatchMode: boolean });

                                                        property state

                                                        state: State;

                                                          method isInterrupted

                                                          isInterrupted: () => boolean;

                                                            method isWatchMode

                                                            isWatchMode: () => boolean;

                                                              method setState

                                                              setState: (state: State) => Promise<void>;

                                                                Interfaces

                                                                interface WatchPlugin

                                                                interface WatchPlugin {}

                                                                  property apply

                                                                  apply?: (hooks: JestHookSubscriber) => void;

                                                                    property getUsageInfo

                                                                    getUsageInfo?: (globalConfig: Config.GlobalConfig) => UsageData | null;

                                                                      property isInternal

                                                                      isInternal?: boolean;

                                                                        property onKey

                                                                        onKey?: (value: string) => void;

                                                                          property run

                                                                          run?: (
                                                                              globalConfig: Config.GlobalConfig,
                                                                              updateConfigAndRun: UpdateConfigCallback
                                                                          ) => Promise<void | boolean>;

                                                                            Type Aliases

                                                                            type AllowedConfigOptions

                                                                            type AllowedConfigOptions = Partial<
                                                                                Pick<
                                                                                    Config.GlobalConfig,
                                                                                    | 'bail'
                                                                                    | 'changedSince'
                                                                                    | 'collectCoverage'
                                                                                    | 'collectCoverageFrom'
                                                                                    | 'coverageDirectory'
                                                                                    | 'coverageReporters'
                                                                                    | 'findRelatedTests'
                                                                                    | 'nonFlagArgs'
                                                                                    | 'notify'
                                                                                    | 'notifyMode'
                                                                                    | 'onlyFailures'
                                                                                    | 'reporters'
                                                                                    | 'testNamePattern'
                                                                                    | 'updateSnapshot'
                                                                                    | 'verbose'
                                                                                > & {
                                                                                    mode: 'watch' | 'watchAll';
                                                                                    testPathPatterns: Array<string>;
                                                                                }
                                                                            >;

                                                                              type JestHookEmitter

                                                                              type JestHookEmitter = {
                                                                                  onFileChange: (fs: JestHookExposedFS) => void;
                                                                                  onTestRunComplete: (results: AggregatedResult) => void;
                                                                                  shouldRunTestSuite: (testSuiteInfo: TestSuiteInfo) => Promise<boolean> | boolean;
                                                                              };

                                                                                type JestHookSubscriber

                                                                                type JestHookSubscriber = {
                                                                                    onFileChange: (fn: FileChange) => void;
                                                                                    onTestRunComplete: (fn: TestRunComplete) => void;
                                                                                    shouldRunTestSuite: (fn: ShouldRunTestSuite) => void;
                                                                                };

                                                                                  type ScrollOptions

                                                                                  type ScrollOptions_2 = {
                                                                                      offset: number;
                                                                                      max: number;
                                                                                  };

                                                                                    type UpdateConfigCallback

                                                                                    type UpdateConfigCallback = (config?: AllowedConfigOptions) => void;

                                                                                      type UsageData

                                                                                      type UsageData = {
                                                                                          key: string;
                                                                                          prompt: string;
                                                                                      };

                                                                                        type WatchPluginClass

                                                                                        type WatchPluginClass = new (options: {
                                                                                            config: Record<string, unknown>;
                                                                                            stdin: ReadStream;
                                                                                            stdout: WriteStream;
                                                                                        }) => WatchPlugin;

                                                                                          Package Files (1)

                                                                                          Dependencies (8)

                                                                                          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/jest-watcher.

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