nodemon

  • Version 3.1.14
  • 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 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: (files?: string[]) => 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>