node-screenshots

The Window class allows you to capture specific application windows. You can list all visible windows using Window.all() and then capture individual windows either synchronously or asynchronously.

const fs = require('fs')
const { Window } = require('node-screenshots')

let windows = Window.all()

windows.forEach((item) => {
  // Capture and save as BMP synchronously
  let image = item.captureImageSync()
  fs.writeFileSync(`${item.id()}-sync.bmp`, image.toBmpSync())

  // Capture, crop, and save as PNG asynchronously
  item.captureImage().then(async (data) => {
    let newImage = await data.crop(10, 10, 10, 10)
    fs.writeFileSync(`${item.id()}.png`, await newImage.toPng())
  })
})

On Linux, you must install libxcb, libxrandr, and dbus for the library to function. Use the command corresponding to your distribution:

Debian / Ubuntu:

apt-get install libxcb1 libxrandr2 libdbus-1-3

Alpine:

apk add libxcb libxrandr dbus

The Image object returned by capture methods supports cropping and multiple format conversions.

Cropping:

• cropSync(x, y, width, height): Synchronous crop.
• crop(x, y, width, height): Asynchronous crop.

Format Conversion: All conversion methods support both synchronous and asynchronous versions. Supported formats include:

• PNG: toPngSync() / toPng()
• JPEG: toJpegSync() / toJpeg()
• BMP: toBmpSync() / toBmp()
• Raw (RGBA): toRawSync() / toRaw()

Note on copyOutputData: When using this library within Electron, you may need to pass a boolean to the conversion methods to prevent crashes. For standard Node.js usage, do not pass this argument or set it to false for better performance.

Use the Window class to capture specific application windows. Use Window.all() to get an array of all visible windows. Each Window instance provides methods to capture its content via captureImageSync() or captureImage().

const { Window } = require('node-screenshots');
const fs = require('fs');

let windows = Window.all();

windows.forEach((item) => {
  // Capture and save as BMP synchronously
  let image = item.captureImageSync();
  fs.writeFileSync(`${item.id()}-sync.bmp`, image.toBmpSync());

  // Capture, crop, and save as PNG asynchronously
  item.captureImage().then(async (data) => {
    let newImage = await data.crop(10, 10, 10, 10);
    fs.writeFileSync(`${item.id()}.png`, await newImage.toPng());
  });
});

You can control how node-screenshots loads its native components using the following environment variables:

• NAPI_RS_NATIVE_LIBRARY_PATH: Specify a custom path to the native library file to bypass automatic detection.
• NAPI_RS_FORCE_WASI: Forces the use of WASI bindings. If set to 'error', the process will throw an error if WASI bindings cannot be found.
• NAPI_RS_ENFORCE_VERSION_CHECK: If set to a non-zero value, the library will strictly enforce that the installed native binding package version matches the expected version (e.g., 0.2.6).

The Monitor class provides the following static and instance methods:

Static Methods:

• static all(): Array<Monitor>: Returns an array of all available monitors.
• static fromPoint(x: number, y: number): Monitor | null: Returns the monitor located at the specified x, y coordinates.

Instance Methods:

• captureImageSync(): Image: Synchronously captures the monitor content.
• captureImage(): Promise<Image>: Asynchronously captures the monitor content.

The Image class handles post-capture processing and encoding.

Cropping Methods:

• cropSync(x: number, y: number, width: number, height: number): Image
• crop(x: number, y: number, width: number, height: number): Promise<Image>

Encoding Methods (Sync/Async): All methods accept an optional copyOutputData?: boolean | undefined | null parameter.

• toPngSync() / toPng(): Convert to PNG.
• toJpegSync() / toJpeg(): Convert to JPEG.
• toBmpSync() / toBmp(): Convert to BMP.
• toRawSync() / toRaw(): Convert to raw (RGBA data).

The Window class provides the following static and instance methods:

Static Methods:

• static all(): Array<Window>: Returns an array of all available windows.

Instance Methods:

• captureImageSync(): Image: Synchronously captures the window content.
• captureImage(): Promise<Image>: Asynchronously captures the window content.

The node-screenshots package provides a native interface for capturing screenshots of monitors, windows, and images. The main entry point exports the following classes:

• Monitor: Used for interacting with physical or virtual monitors.
• Window: Used for interacting with specific application windows.
• Image: Used for image-related operations.

Note that the package relies on native bindings. If you encounter loading errors, it may be due to npm optional dependency issues; try deleting node_modules and package-lock.json and running npm i again.

const { Monitor, Window, Image } = require('node-screenshots');

// Example usage (actual method calls depend on the native binding implementation)
// const monitor = new Monitor();
// const window = new Window();
// const image = new Image();