nodemon

  • Version 3.1.9
  • Published
  • 220 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

Functions

function nodemon

nodemon: Nodemon;

    Interfaces

    interface NodemonConfig

    interface NodemonConfig {}

      property colours

      colours?: boolean;

        property configFile

        configFile?: string;

          property cwd

          cwd?: string;

            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 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 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?: { [key: string]: string };

                                                                                  property events

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

                                                                                    Type Aliases

                                                                                    type Nodemon

                                                                                    type 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>