chokidar vs nodemon vs sane vs gaze vs node-watch vs watch
File Watching Libraries Comparison
Search packages..
1 Year
chokidarnodemonsanegazenode-watchwatchSimilar Packages:
What's File Watching Libraries?

File watching libraries are essential tools in web development that monitor file system changes and trigger actions based on those changes. They are commonly used in development environments to automatically reload applications, rebuild assets, or run tests when files are modified. These libraries help streamline the development process by reducing the need for manual intervention, thus enhancing productivity and efficiency.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
chokidar65,987,09011,222149 kB242 months agoMIT
nodemon7,408,06326,452220 kB72 months agoMIT
sane4,250,583387-344 years agoMIT
gaze2,534,1851,153-697 years agoMIT
node-watch652,07934126.1 kB62 years agoMIT
watch584,5511,278-608 years agoApache-2.0
Feature Comparison: chokidar vs nodemon vs sane vs gaze vs node-watch vs watch

Performance

  • chokidar:

    Chokidar is designed for high performance and efficiency, utilizing native file system events where possible to minimize CPU usage. It can handle large directories with many files without significant performance degradation, making it suitable for complex projects.

  • nodemon:

    Nodemon is optimized for development use, automatically restarting your application with minimal overhead. It is efficient in monitoring changes but is primarily focused on Node.js applications rather than general file watching.

  • sane:

    Sane is designed for speed and efficiency, particularly in large projects. It uses a polling mechanism, which can be faster than traditional file watching methods in certain environments, making it a good choice for extensive codebases.

  • gaze:

    Gaze is relatively performant for smaller projects but may struggle with larger directories due to its reliance on polling for file changes. It is best suited for simpler use cases where performance is not a critical concern.

  • node-watch:

    Node-watch is lightweight and efficient for small to medium-sized projects. However, it may not be as performant as Chokidar for larger file sets, as it uses a polling mechanism that can increase resource usage.

  • watch:

    Watch is straightforward and performs adequately for basic file watching tasks. However, it may not be as efficient as other options for larger projects.

Ease of Use

  • chokidar:

    Chokidar offers a simple API that is easy to use, with extensive documentation and examples. It allows for quick setup and integration into existing projects, making it accessible for developers of all skill levels.

  • nodemon:

    Nodemon is extremely user-friendly, requiring just a single command to start monitoring your application. It is particularly beneficial for developers who want to focus on coding without worrying about manual restarts.

  • sane:

    Sane is designed for ease of use, with a simple API that allows developers to quickly set up file watching. Its straightforward configuration makes it accessible for beginners.

  • gaze:

    Gaze provides an intuitive API that supports glob patterns, making it easy to specify which files to watch. Its simplicity makes it a good choice for developers looking for a quick and easy solution.

  • node-watch:

    Node-watch is very easy to use, with minimal configuration required. Its straightforward approach makes it ideal for developers who want a simple file watcher without any complex setup.

  • watch:

    Watch is very simple to use, with a minimalistic approach that allows for quick integration into build processes. It is suitable for developers who need a basic file watching solution.

Flexibility

  • chokidar:

    Chokidar is highly flexible, allowing developers to customize the behavior of the watcher through various options and event listeners. It supports a wide range of file system events, making it adaptable to different use cases.

  • nodemon:

    Nodemon is specifically tailored for Node.js applications, providing flexibility in how applications are restarted based on file changes. It allows for configuration options to suit different development needs.

  • sane:

    Sane is flexible in its approach to file watching, allowing developers to configure polling intervals and other settings. It is particularly useful in environments where traditional file events may not be reliable.

  • gaze:

    Gaze offers flexibility through its support for glob patterns, allowing developers to specify complex file matching rules. However, it may not provide as many customization options as Chokidar.

  • node-watch:

    Node-watch is flexible in its simplicity, allowing developers to easily integrate it into existing applications. However, it may lack some advanced features found in other libraries.

  • watch:

    Watch is flexible enough for basic use cases, allowing developers to specify commands to run on file changes. However, it may not offer the same level of customization as more advanced libraries.

Use Cases

  • chokidar:

    Chokidar is ideal for a variety of use cases, including frontend build processes, backend file monitoring, and any situation where efficient file watching is required. It is suitable for both small and large projects.

  • nodemon:

    Nodemon is specifically designed for Node.js applications, making it the go-to choice for developers who want automatic restarts during development. It is particularly useful for backend development.

  • sane:

    Sane is well-suited for large projects where performance is critical, as it can efficiently monitor many files and directories without significant resource usage.

  • gaze:

    Gaze is best suited for smaller projects or scripts where simple file watching is needed, such as monitoring configuration files or assets in a web application.

  • node-watch:

    Node-watch is perfect for lightweight applications or scripts that require basic file watching capabilities without the overhead of more complex libraries.

  • watch:

    Watch is suitable for basic file watching tasks, such as running build scripts or executing commands when files change. It is ideal for simple use cases.

Community and Support

  • chokidar:

    Chokidar has a strong community and is widely used in the Node.js ecosystem, ensuring good support and regular updates. Its extensive documentation and active GitHub repository make it easy to find help and resources.

  • nodemon:

    Nodemon has a large user base and is well-supported within the Node.js community. Its popularity ensures that developers can find ample resources and community support for troubleshooting.

  • sane:

    Sane has a growing community and is actively maintained, providing good support for developers. Its performance-oriented design has garnered interest among developers working on larger projects.

  • gaze:

    Gaze has a smaller community compared to Chokidar, but it is still maintained and has adequate documentation. Support may be limited, but it is sufficient for basic use cases.

  • node-watch:

    Node-watch has a modest community and is less frequently updated than some other libraries. However, it is simple enough that many developers find it easy to troubleshoot without extensive support.

  • watch:

    Watch has a smaller community and may not have as many resources available, but it is simple enough for developers to use without extensive documentation.

How to Choose: chokidar vs nodemon vs sane vs gaze vs node-watch vs watch
  • chokidar:

    Choose Chokidar if you need a highly efficient and reliable file watcher that supports a wide range of file system events and is optimized for performance. It is particularly useful for large projects with many files, as it minimizes resource usage and provides robust handling of file changes.

  • nodemon:

    Use Nodemon if you are primarily focused on automatically restarting your Node.js application when file changes are detected. It is specifically designed for development environments and is perfect for backend applications that require frequent restarts during development.

  • sane:

    Choose Sane if you need a file watcher that is fast and efficient, particularly for large projects. It uses a polling mechanism to detect changes, which can be beneficial in environments where file system events are not reliably emitted.

  • gaze:

    Select Gaze if you require a simple and straightforward file watching solution that supports glob patterns for matching files. It is suitable for smaller projects or when you need a quick setup without extensive configuration.

  • node-watch:

    Opt for Node-watch if you want a lightweight and minimalistic file watcher that is easy to use and integrates well with other Node.js applications. It is ideal for projects where simplicity and ease of use are prioritized over advanced features.

  • watch:

    Select Watch if you want a simple and straightforward solution for watching files and executing commands based on changes. It is suitable for basic use cases and can be easily integrated into build processes.

Similar Npm Packages to chokidar

chokidar is a popular file-watching library for Node.js applications. It provides a simple and efficient way to monitor file changes in real-time, making it an essential tool for tasks such as live reloading during development, automated build processes, and file synchronization. Chokidar is known for its performance and reliability, as it uses native file system events to minimize resource usage while maintaining accuracy.

While chokidar is a robust choice for file watching, there are several alternatives available in the Node.js ecosystem. Here are a few noteworthy options:

  • gaze is a file-watching library that provides a simple API for monitoring file changes. It supports glob patterns, allowing users to watch multiple files or directories easily. Gaze is particularly useful for projects that require a straightforward solution for file watching without the need for advanced features. Its simplicity makes it a good choice for smaller projects or scripts where minimal configuration is desired.

  • node-watch is another lightweight file-watching library for Node.js. It provides a simple interface for monitoring changes to files and directories, and it can handle both file additions and deletions. Node-watch is easy to set up and can be a good alternative for developers looking for a minimalistic solution without the overhead of more complex libraries.

  • sane is a file-watching library that focuses on performance and efficiency. It uses a polling mechanism to watch files, which can be beneficial in certain scenarios where native file system events may not be reliable. Sane is particularly useful for projects that require compatibility across different operating systems or environments where file system events may behave inconsistently.

  • watchpack is a file-watching library that is often used in conjunction with build tools like Webpack. It provides a more advanced API for monitoring file changes and is designed to work efficiently with large codebases. Watchpack is ideal for developers who need a powerful solution for file watching in complex build systems and want to leverage its integration with other tools.

To explore how chokidar compares with its alternatives, check out the comparison: Comparing chokidar vs gaze vs node-watch vs sane vs watchpack.

Similar Npm Packages to nodemon

nodemon is a utility that helps develop Node.js applications by automatically restarting the server whenever file changes in the directory are detected. This tool is particularly useful during development, as it allows developers to see changes in real-time without the need to manually stop and restart the server. With its simple configuration and ease of use, nodemon has become a popular choice among Node.js developers.

However, there are several alternatives to nodemon that also provide process management and server monitoring capabilities. Here are a few notable options:

  • forever is a simple CLI tool that ensures that a given script runs continuously. It is designed to keep your Node.js applications running indefinitely, automatically restarting them if they crash. While it doesn’t provide the same file-watching capabilities as nodemon, it is an excellent choice for production environments where you need to ensure that your application is always up and running.

  • pm2 is a powerful process manager for Node.js applications that offers advanced features such as load balancing, monitoring, and clustering. PM2 is particularly well-suited for production environments, as it provides robust process management capabilities, including automatic restarts, log management, and performance monitoring. If you're looking for a comprehensive solution to manage your Node.js applications in production, PM2 is an excellent choice.

  • supervisor is another tool that automatically restarts your Node.js application when file changes are detected. It is similar to nodemon but offers additional features such as the ability to monitor multiple processes and run scripts in parallel. Supervisor is a good alternative for developers who need a simple way to manage multiple Node.js applications during development.

For a detailed comparison of these packages, check out the following link: Comparing forever vs nodemon vs pm2 vs supervisor.

Similar Npm Packages to sane

sane is a file watching library for Node.js that provides a simple and efficient way to monitor changes in the filesystem. It is particularly useful for applications that need to respond to file modifications, such as build tools, development servers, or any application that requires real-time updates based on file changes. While sane offers a robust solution for file watching, there are several alternatives in the Node.js ecosystem that provide similar functionality. Here are a few notable options:

  • chokidar is one of the most popular file watching libraries for Node.js. It is built on top of the native file watching capabilities of the operating system and is known for its performance and reliability. Chokidar can efficiently watch for changes in directories and files, handling a variety of events such as additions, deletions, and modifications. If you need a powerful and feature-rich file watcher, chokidar is an excellent choice.
  • filewatcher is a lightweight file watching library that provides a simple API for monitoring file changes. It is designed to be easy to use and integrates well with various workflows. While it may not have all the advanced features of some other libraries, filewatcher is a solid option for projects that require basic file watching capabilities without the overhead of more complex solutions.
  • gaze is another file watching library that allows you to watch files and directories for changes. It supports glob patterns, making it easy to specify which files to monitor. Gaze is particularly useful for projects that need to watch multiple files or directories at once and provides a straightforward API for handling file change events.
  • node-watch is a simple and efficient file watcher for Node.js that provides a minimalistic API. It can watch files and directories for changes and trigger callbacks when modifications occur. If you're looking for a straightforward solution without additional complexity, node-watch is a good choice.
  • watch is a basic file watching library that provides a simple interface for monitoring file changes. It is lightweight and easy to use, making it suitable for smaller projects or scenarios where advanced features are not required.
  • watchpack is a file watching library that is optimized for performance and is often used in build tools like Webpack. It is designed to handle large numbers of files efficiently and can be a great choice for applications that require high performance and scalability when watching files.

For a comprehensive comparison of these libraries, check out the following link: Comparing chokidar vs filewatcher vs gaze vs node-watch vs sane vs watch vs watchpack.

Similar Npm Packages to gaze

gaze is a file watching library for Node.js that allows developers to monitor file changes in a directory. It is particularly useful for tasks such as automatically rebuilding projects, reloading servers, or triggering other actions when files are modified. While gaze is a solid choice for file watching, there are several alternatives available that provide similar functionality. Here are a few noteworthy options:

  • chokidar is a widely used file watching library that is known for its performance and efficiency. It uses native file system events to provide a more reliable and faster experience compared to other libraries. Chokidar is capable of watching large directories and can handle a variety of file system events, making it a popular choice for projects that require robust file watching capabilities. If you need a reliable and efficient solution for monitoring file changes, chokidar is an excellent option.
  • node-watch is another lightweight file watching library for Node.js. It provides a simple API for watching files and directories, and it supports both synchronous and asynchronous file change detection. Node-watch is easy to set up and can be a good choice for smaller projects or for developers who prefer a minimalistic approach to file watching.
  • nodemon is a utility that monitors for changes in your Node.js application and automatically restarts the server when file changes are detected. While it is primarily used for development purposes, nodemon can also be considered a file watching tool. It is particularly useful for developers who want to streamline their workflow by automatically restarting their applications during development.
  • watch is a simple file watching library that provides basic functionality for monitoring file changes. It is lightweight and easy to use, making it suitable for smaller projects or for developers who need a straightforward solution without additional complexity.

To see how gaze compares with chokidar, node-watch, nodemon, and watch, check out the comparison: Comparing chokidar vs gaze vs node-watch vs nodemon vs watch.

Similar Npm Packages to node-watch

node-watch is a simple and efficient file watching library for Node.js applications. It allows developers to monitor changes in the filesystem, such as file additions, deletions, and modifications, enabling automated tasks like rebuilding, reloading, or executing scripts in response to these changes. While node-watch is a solid choice for file watching, there are several alternatives available that offer similar or enhanced functionality. Here are a few noteworthy options:

  • chokidar is a popular file watching library that provides a more robust and feature-rich alternative to node-watch. It is built on top of the native file watching APIs and offers better performance and reliability. Chokidar supports a wide range of features, including debounce and throttle options, ignoring specific files or directories, and handling large directories efficiently. If you need a powerful and flexible file watcher for your Node.js applications, chokidar is an excellent choice.
  • gaze is another file watching library that focuses on simplicity and ease of use. It allows you to watch files and directories for changes and execute callbacks when changes occur. Gaze is particularly useful for smaller projects or when you need a straightforward solution without the additional complexity of more feature-rich libraries. If you want a lightweight option for file watching, gaze is worth considering.
  • nodemon is primarily a development tool that automatically restarts your Node.js application when file changes are detected. While it is not a dedicated file watching library like node-watch, it leverages file watching capabilities to enhance the development experience. Nodemon is particularly useful for Node.js developers who want to streamline their workflow by automatically reloading their applications during development.
  • sane is a file watching library that aims to provide a simple and efficient solution for monitoring file changes. It uses a polling mechanism to detect changes, making it suitable for environments where native file watching APIs may not be available or reliable. If you need a straightforward file watcher that works across various platforms, sane is a good option.
  • watch is a minimalistic file watching library that provides a simple API for monitoring file changes. It is designed to be lightweight and easy to use, making it suitable for smaller projects or scripts where you need basic file watching functionality without additional overhead.

To explore how these libraries compare, check out the comparison: Comparing chokidar vs gaze vs node-watch vs nodemon vs sane vs watch.

Similar Npm Packages to watch

watch is a simple file watching library for Node.js applications. It allows developers to monitor changes in files and directories, triggering specified actions when changes are detected. While watch provides a straightforward solution for file watching, there are several alternatives in the Node.js ecosystem that offer additional features or improved performance. Here are a few notable alternatives:

  • chokidar is a highly efficient file watcher that is built on top of the native file watching capabilities of the operating system. It provides a rich API and is known for its performance and reliability. chokidar is particularly useful for applications that require real-time file watching, such as build tools or development servers. Its ability to handle large numbers of files and directories with minimal overhead makes it a popular choice among developers.
  • fsevents is a native file system event listener for macOS, specifically designed to provide efficient file watching capabilities on Apple’s operating system. It leverages the native file system events API, making it extremely fast and efficient for monitoring changes in files and directories. While fsevents is macOS-specific, it is often used in conjunction with other libraries to provide cross-platform file watching capabilities.
  • gaze is another file watching library that offers a simple API for monitoring file changes. It supports multiple file patterns and can watch files in subdirectories. gaze is particularly useful for projects that require a straightforward solution for file watching without the complexity of more advanced libraries. Its ease of use makes it a good choice for smaller projects or scripts.
  • node-watch is a minimalistic file watching library for Node.js that provides a simple API for monitoring file changes. It is lightweight and easy to use, making it suitable for projects that need basic file watching capabilities without additional overhead. node-watch is a good option for developers looking for a straightforward solution without the need for advanced features.

To compare these packages, check out the link: Comparing chokidar vs fsevents vs gaze vs node-watch vs watch.

README for chokidar

Chokidar Weekly downloads

Minimal and efficient cross-platform file watching library

Why?

There are many reasons to prefer Chokidar to raw fs.watch / fs.watchFile in 2024:

  • Events are properly reported
    • macOS events report filenames
    • events are not reported twice
    • changes are reported as add / change / unlink instead of useless rename
  • Atomic writes are supported, using atomic option
    • Some file editors use them
  • Chunked writes are supported, using awaitWriteFinish option
    • Large files are commonly written in chunks
  • File / dir filtering is supported
  • Symbolic links are supported
  • Recursive watching is always supported, instead of partial when using raw events
    • Includes a way to limit recursion depth

Chokidar relies on the Node.js core fs module, but when using fs.watch and fs.watchFile for watching, it normalizes the events it receives, often checking for truth by getting file stats and/or dir contents. The fs.watch-based implementation is the default, which avoids polling and keeps CPU usage down. Be advised that chokidar will initiate watchers recursively for everything within scope of the paths that have been specified, so be judicious about not wasting system resources by watching much more than needed. For some cases, fs.watchFile, which utilizes polling and uses more resources, is used.

Made for Brunch in 2012, it is now used in ~30 million repositories and has proven itself in production environments.

Sep 2024 update: v4 is out! It decreases dependency count from 13 to 1, removes support for globs, adds support for ESM / Common.js modules, and bumps minimum node.js version from v8 to v14. Check out upgrading.

Getting started

Install with npm:

npm install chokidar

Use it in your code:

import chokidar from 'chokidar';

// One-liner for current directory
chokidar.watch('.').on('all', (event, path) => {
  console.log(event, path);
});


// Extended options
// ----------------

// Initialize watcher.
const watcher = chokidar.watch('file, dir, or array', {
  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
  persistent: true
});

// Something to use when events are received.
const log = console.log.bind(console);
// Add event listeners.
watcher
  .on('add', path => log(`File ${path} has been added`))
  .on('change', path => log(`File ${path} has been changed`))
  .on('unlink', path => log(`File ${path} has been removed`));

// More possible events.
watcher
  .on('addDir', path => log(`Directory ${path} has been added`))
  .on('unlinkDir', path => log(`Directory ${path} has been removed`))
  .on('error', error => log(`Watcher error: ${error}`))
  .on('ready', () => log('Initial scan complete. Ready for changes'))
  .on('raw', (event, path, details) => { // internal
    log('Raw event info:', event, path, details);
  });

// 'add', 'addDir' and 'change' events also receive stat() results as second
// argument when available: https://nodejs.org/api/fs.html#fs_class_fs_stats
watcher.on('change', (path, stats) => {
  if (stats) console.log(`File ${path} changed size to ${stats.size}`);
});

// Watch new files.
watcher.add('new-file');
watcher.add(['new-file-2', 'new-file-3']);

// Get list of actual paths being watched on the filesystem
let watchedPaths = watcher.getWatched();

// Un-watch some files.
await watcher.unwatch('new-file');

// Stop watching. The method is async!
await watcher.close().then(() => console.log('closed'));

// Full list of options. See below for descriptions.
// Do not use this example!
chokidar.watch('file', {
  persistent: true,

  // ignore .txt files
  ignored: (file) => file.endsWith('.txt'),
  // watch only .txt files
  // ignored: (file, _stats) => _stats?.isFile() && !file.endsWith('.txt'),

  awaitWriteFinish: true, // emit single event when chunked writes are completed
  atomic: true, // emit proper events when "atomic writes" (mv _tmp file) are used

  // The options also allow specifying custom intervals in ms
  // awaitWriteFinish: {
  //   stabilityThreshold: 2000,
  //   pollInterval: 100
  // },
  // atomic: 100,

  interval: 100,
  binaryInterval: 300,

  cwd: '.',
  depth: 99,

  followSymlinks: true,
  ignoreInitial: false,
  ignorePermissionErrors: false,
  usePolling: false,
  alwaysStat: false,
});

chokidar.watch(paths, [options])

  • paths (string or array of strings). Paths to files, dirs to be watched recursively.
  • options (object) Options object as defined below:

Persistence

  • persistent (default: true). Indicates whether the process should continue to run as long as files are being watched.

Path filtering

  • ignored function, regex, or path. Defines files/paths to be ignored. The whole relative or absolute path is tested, not just filename. If a function with two arguments is provided, it gets called twice per path - once with a single argument (the path), second time with two arguments (the path and the fs.Stats object of that path).
  • ignoreInitial (default: false). If set to false then add/addDir events are also emitted for matching paths while instantiating the watching as chokidar discovers these file paths (before the ready event).
  • followSymlinks (default: true). When false, only the symlinks themselves will be watched for changes instead of following the link references and bubbling events through the link's path.
  • cwd (no default). The base directory from which watch paths are to be derived. Paths emitted with events will be relative to this.

Performance

  • usePolling (default: false). Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU utilization, consider setting this to false. It is typically necessary to set this to true to successfully watch files over a network, and it may be necessary to successfully watch files in other non-standard situations. Setting to true explicitly on MacOS overrides the useFsEvents default. You may also set the CHOKIDAR_USEPOLLING env variable to true (1) or false (0) in order to override this option.
  • Polling-specific settings (effective when usePolling: true)
    • interval (default: 100). Interval of file system polling, in milliseconds. You may also set the CHOKIDAR_INTERVAL env variable to override this option.
    • binaryInterval (default: 300). Interval of file system polling for binary files. (see list of binary extensions)
  • alwaysStat (default: false). If relying upon the fs.Stats object that may get passed with add, addDir, and change events, set this to true to ensure it is provided even in cases where it wasn't already available from the underlying watch events.
  • depth (default: undefined). If set, limits how many levels of subdirectories will be traversed.
  • awaitWriteFinish (default: false). By default, the add event will fire when a file first appears on disk, before the entire file has been written. Furthermore, in some cases some change events will be emitted while the file is being written. In some cases, especially when watching for large files there will be a need to wait for the write operation to finish before responding to a file creation or modification. Setting awaitWriteFinish to true (or a truthy value) will poll file size, holding its add and change events until the size does not change for a configurable amount of time. The appropriate duration setting is heavily dependent on the OS and hardware. For accurate detection this parameter should be relatively high, making file watching much less responsive. Use with caution.
    • options.awaitWriteFinish can be set to an object in order to adjust timing params:
    • awaitWriteFinish.stabilityThreshold (default: 2000). Amount of time in milliseconds for a file size to remain constant before emitting its event.
    • awaitWriteFinish.pollInterval (default: 100). File size polling interval, in milliseconds.

Errors

  • ignorePermissionErrors (default: false). Indicates whether to watch files that don't have read permissions if possible. If watching fails due to EPERM or EACCES with this set to true, the errors will be suppressed silently.
  • atomic (default: true if useFsEvents and usePolling are false). Automatically filters out artifacts that occur when using editors that use "atomic writes" instead of writing directly to the source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a change event rather than unlink then add. If the default of 100 ms does not work well for you, you can override it by setting atomic to a custom value, in milliseconds.

Methods & Events

chokidar.watch() produces an instance of FSWatcher. Methods of FSWatcher:

  • .add(path / paths): Add files, directories for tracking. Takes an array of strings or just one string.
  • .on(event, callback): Listen for an FS event. Available events: add, addDir, change, unlink, unlinkDir, ready, raw, error. Additionally all is available which gets emitted with the underlying event name and path for every event other than ready, raw, and error. raw is internal, use it carefully.
  • .unwatch(path / paths): Stop watching files or directories. Takes an array of strings or just one string.
  • .close(): async Removes all listeners from watched files. Asynchronous, returns Promise. Use with await to ensure bugs don't happen.
  • .getWatched(): Returns an object representing all the paths on the file system being watched by this FSWatcher instance. The object's keys are all the directories (using absolute paths unless the cwd option was used), and the values are arrays of the names of the items contained in each directory.

CLI

Check out third party chokidar-cli, which allows to execute a command on each change, or get a stdio stream of change events.

Troubleshooting

Sometimes, Chokidar runs out of file handles, causing EMFILE and ENOSP errors:

  • bash: cannot set terminal process group (-1): Inappropriate ioctl for device bash: no job control in this shell
  • Error: watch /home/ ENOSPC

There are two things that can cause it.

  1. Exhausted file handles for generic fs operations
    • Can be solved by using graceful-fs, which can monkey-patch native fs module used by chokidar: let fs = require('fs'); let grfs = require('graceful-fs'); grfs.gracefulify(fs);
    • Can also be solved by tuning OS: echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p.
  2. Exhausted file handles for fs.watch
    • Can't seem to be solved by graceful-fs or OS tuning
    • It's possible to start using usePolling: true, which will switch backend to resource-intensive fs.watchFile

All fsevents-related issues (WARN optional dep failed, fsevents is not a constructor) are solved by upgrading to v4+.

Changelog

  • v4 (Sep 2024): remove glob support and bundled fsevents. Decrease dependency count from 13 to 1. Rewrite in typescript. Bumps minimum node.js requirement to v14+
  • v3 (Apr 2019): massive CPU & RAM consumption improvements; reduces deps / package size by a factor of 17x and bumps Node.js requirement to v8.16+.
  • v2 (Dec 2017): globs are now posix-style-only. Tons of bugfixes.
  • v1 (Apr 2015): glob support, symlink support, tons of bugfixes. Node 0.8+ is supported
  • v0.1 (Apr 2012): Initial release, extracted from Brunch

Upgrading

If you've used globs before and want do replicate the functionality with v4:

// v3
chok.watch('**/*.js');
chok.watch("./directory/**/*");

// v4
chok.watch('.', {
  ignored: (path, stats) => stats?.isFile() && !path.endsWith('.js'), // only watch js files
});
chok.watch('./directory');

// other way
import { glob } from 'node:fs/promises';
const watcher = watch(await Array.fromAsync(glob('**/*.js')));

// unwatching
// v3
chok.unwatch('**/*.js');
// v4
chok.unwatch(await glob('**/*.js'));

Also

Why was chokidar named this way? What's the meaning behind it?

Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four). This word is also used in other languages like Urdu as (چوکیدار) which is widely used in Pakistan and India.

License

MIT (c) Paul Miller (https://paulmillr.com), see LICENSE file.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.