nodemon

  • Version 3.1.10
  • Published
  • 219 kB
  • 10 dependencies
  • MIT license

Install

npm i nodemon
yarn add nodemon
pnpm add nodemon

Overview

Simple monitor script for use during development of a Node.js app.

Index

Variables

variable nodemon

const nodemon: Nodemon;

    Interfaces

    interface NodemonConfig

    interface NodemonConfig {}

      property colours

      colours?: boolean;

        property configFile

        configFile?: string;

          property cwd

          cwd?: string;

            property delay

            delay?: number;

              property dump

              dump?: boolean;

                property execMap

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

                  property execOptions

                  execOptions?: NodemonExecOptions;

                    property exitCrash

                    exitCrash?: boolean;

                      property help

                      help?: string;

                        property ignore

                        ignore?: string[];

                          property ignoreRoot

                          ignoreRoot?: string[];

                            property js

                            js?: boolean;
                            • Deprecated

                              as this is "on" by default

                            property legacyWatch

                            legacyWatch?: boolean;

                              property monitor

                              monitor?: string[];

                                property noUpdateNotifier

                                noUpdateNotifier?: boolean;

                                  property pollingInterval

                                  pollingInterval?: number;

                                    property quiet

                                    quiet?: boolean;

                                      property restartable

                                      restartable?: false | string;
                                      • restartable defaults to "rs" as a string the user enters

                                      property runOnChangeOnly

                                      runOnChangeOnly?: boolean;

                                        property signal

                                        signal?: string;

                                          property spawn

                                          spawn?: boolean;

                                            property stdin

                                            stdin?: boolean;

                                              property stdout

                                              stdout?: boolean;

                                                property verbose

                                                verbose?: boolean;

                                                  property version

                                                  version?: boolean;

                                                    property watch

                                                    watch?: string[];

                                                      property watchOptions

                                                      watchOptions?: WatchOptions;

                                                        interface NodemonEventRestart

                                                        interface NodemonEventRestart {}

                                                          property matched

                                                          matched?: {
                                                          result: string[];
                                                          total: number;
                                                          };

                                                            interface NodemonExecOptions

                                                            interface NodemonExecOptions {}

                                                              property args

                                                              args?: string[];

                                                                property exec

                                                                exec?: string;

                                                                  property execArgs

                                                                  execArgs?: string[];

                                                                    property ext

                                                                    ext?: string;

                                                                      property nodeArgs

                                                                      nodeArgs?: string[];

                                                                        property script

                                                                        script: string;

                                                                          property scriptPosition

                                                                          scriptPosition?: number;

                                                                            interface NodemonSettings

                                                                            interface NodemonSettings extends NodemonConfig, NodemonExecOptions {}

                                                                              property env

                                                                              env?: Record<string, string>;

                                                                                property events

                                                                                events?: Record<string, string>;

                                                                                  Type Aliases

                                                                                  type Nodemon

                                                                                  type Nodemon = {
                                                                                  (settings: NodemonSettings): Nodemon;
                                                                                  removeAllListeners(event: NodemonEventHandler): Nodemon;
                                                                                  emit(type: NodemonEventHandler, event?: any): Nodemon;
                                                                                  reset(callback: Function): Nodemon;
                                                                                  restart(): Nodemon;
                                                                                  config: NodemonSettings;
                                                                                  } & NodemonEventListener & {
                                                                                  [K in keyof NodemonEventListener as 'addListener']: NodemonEventListener[K];
                                                                                  } & {
                                                                                  [K in keyof NodemonEventListener as 'once']: NodemonEventListener[K];
                                                                                  };

                                                                                    type NodemonEventConfig

                                                                                    type NodemonEventConfig = {
                                                                                    run: boolean;
                                                                                    system: {
                                                                                    cwd: string;
                                                                                    };
                                                                                    required: boolean;
                                                                                    dirs: string[];
                                                                                    timeout: number;
                                                                                    options: NodemonConfig;
                                                                                    lastStarted: number;
                                                                                    loaded: string[];
                                                                                    load: (
                                                                                    settings: NodemonSettings,
                                                                                    ready: (config: NodemonEventConfig) => void
                                                                                    ) => void;
                                                                                    reset: () => void;
                                                                                    };

                                                                                      type NodemonEventHandler

                                                                                      type NodemonEventHandler =
                                                                                      | 'start'
                                                                                      | 'crash'
                                                                                      | 'exit'
                                                                                      | 'quit'
                                                                                      | 'restart'
                                                                                      | 'config:update'
                                                                                      | 'log'
                                                                                      | 'readable'
                                                                                      | 'stdout'
                                                                                      | 'stderr';

                                                                                        type NodemonEventListener

                                                                                        type NodemonEventListener = {
                                                                                        on(event: 'start' | 'crash' | 'readable', listener: () => void): Nodemon;
                                                                                        on(event: 'log', listener: (e: NodemonEventLog) => void): Nodemon;
                                                                                        on(event: 'stdout' | 'stderr', listener: (e: string) => void): Nodemon;
                                                                                        on(event: 'restart', listener: (e?: NodemonEventRestart) => void): Nodemon;
                                                                                        on(event: 'quit', listener: (e?: NodemonEventQuit) => void): Nodemon;
                                                                                        on(event: 'exit', listener: (e?: number) => void): Nodemon;
                                                                                        on(event: 'config:update', listener: (e?: NodemonEventConfig) => void): Nodemon;
                                                                                        };

                                                                                          type NodemonEventLog

                                                                                          type NodemonEventLog = {
                                                                                          /**
                                                                                          - detail: what you get with nodemon --verbose.
                                                                                          - status: subprocess starting, restarting.
                                                                                          - fail: is the subprocess crashing.
                                                                                          - error: is a nodemon system error.
                                                                                          */
                                                                                          type: 'detail' | 'log' | 'status' | 'error' | 'fail';
                                                                                          /** the plain text message */
                                                                                          message: string;
                                                                                          /** contains the terminal escape codes to add colour, plus the "[nodemon]" prefix */
                                                                                          colour: string;
                                                                                          };

                                                                                            type NodemonEventQuit

                                                                                            type NodemonEventQuit = 143 | 130;

                                                                                              Package Files (1)

                                                                                              Dependencies (10)

                                                                                              Dev Dependencies (11)

                                                                                              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/nodemon.

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