Crawlee is a comprehensive web scraping and crawling library for Node.js/TypeScript that provides a unified interface for both HTTP-based crawling (using got-scraping with Cheerio/JSDOM/Linkedom) and browser-based crawling (using Playwright/Puppeteer). It features a modular architecture with separate packages for core functionality, specific crawlers, storage abstractions, browser pooling, and utilities. The library handles request queuing, automatic concurrency scaling based on system resources, session management with cookie persistence and fingerprinting, proxy rotation, and robust error handling. It includes built-in mechanisms to avoid bot detection and provides storage abstractions for datasets (structured data), key-value stores (binary data), and request queues (URL frontier). Designed for reliability and scalability, Crawlee supports both local execution and deployment on the Apify platform, with extensive documentation, examples, and CLI tools for project scaffolding.
This repository is the `cron` npm package — a long-standing Node.js library for scheduling callbacks or system commands using cron syntax, with an optional leading seconds field. In production it parses a cron expression into per-field boolean match maps, then drives a setTimeout loop that computes the next matching instant (via Luxon for timezone conversion) and fires registered callbacks. It also supports one-shot Date/Luxon DateTime triggers, execution through child_process spawn, UTC offsets in minutes, presets (@hourly, @daily, etc.), and a threshold option that recovers from missed deadlines caused by event-loop stalls (execute immediately if within threshold, otherwise skip with a warning). Architecture is a compact, clean TypeScript library: src/constants.ts holds field constraints, aliases, and presets; src/time.ts implements CronTime (expression parsing plus next-date search with DST forward/backward ambiguity handling and an 8-year max-match cap for leap-day-only schedules); src/job.ts implements CronJob (timer lifecycle, MAXDELAY chunking for setTimeouts beyond ~24.8 days, waitForCompletion semantics, and threshold-based missed-deadline policy); src/types/cron.types.ts exposes rich parameter/context typing including a recursive IntRange utility that constrains cron field values at compile time. Public entry points exported from src/index.ts are CronJob, CronTime, sendAt, timeout, and validateCronExpression. Maintenance is exemplary: semantic-release automation with trusted npm publishing and provenance, a CI matrix across Node 18/20/22/23/24/25 on Linux/Windows/macOS, enforced coverage thresholds (85% statements/lines/functions, 75% branches), Renovate-driven dependency updates, CodeQL and OpenSSF scorecard checks, and a fast-check property-based fuzz suite (100k randomized runs per tier) complementing the hand-written Jest unit tests. The codebase is current with its ecosystem — TypeScript 5.9, Jest 30, Node 24/25 support — with only a minor lag in ESLint (v8 vs current v9) and typescript-eslint (v7 vs v8), which does not meaningfully impair the project.
wait-on is a cross-platform CLI tool and Node.js library that polls various resource types (files, TCP ports, Unix domain sockets, HTTP/HTTPS endpoints) until they become available (or unavailable in reverse mode). It uses RxJS observables for reactive polling with configurable delay, interval, stability window, timeout, and simultaneous connection limits. The library supports both callback and promise APIs. The codebase demonstrates solid engineering: input validation via Joi, functional utilities from lodash, HTTP requests via axios with TLS/proxy/auth support, and comprehensive test coverage (API and CLI). It is a well-maintained, production-ready utility commonly used in CI/CD pipelines and development workflows to synchronize service startup.
This repository is a mature, well-maintained Node.js library for building SQS-based applications without boilerplate. It provides a `Consumer` class that polls an AWS SQS queue, invokes user-defined message handlers (`handleMessage` or `handleMessageBatch`), and manages the full message lifecycle: receive, process, delete on success, and visibility timeout management. The architecture is a single class extending a typed `EventEmitter`, emitting events for lifecycle hooks (started, stopped, message_received, message_processed, error, etc.). Key entry points are `Consumer.create(options)`, `consumer.start()`, and `consumer.stop()`. The library supports both single and batch message processing, configurable polling intervals, heartbeat extensions for long-running handlers, graceful shutdown with in-flight message completion, and FIFO queue warnings. External dependencies are minimal: `@aws-sdk/client-sqs` for AWS SDK v3 and `debug` for logging. The codebase is written in TypeScript, fully tested with unit and integration tests, and follows semantic versioning with automated releases via semantic-release.
MQTT.js is a comprehensive MQTT protocol client library for Node.js and browsers, implementing MQTT 3.1.1 and 5.0 specifications. It provides core functionality for connecting to brokers, publishing/subscribing with QoS levels, keepalive management, and offline message queuing. The architecture features modular transport abstraction (TCP/TLS/WebSocket/platform-specific), event-driven design with TypedEventEmitter, and pluggable persistence via Store. Entry points include the main library (src/mqtt.ts), CLI tools (src/bin/*), and platform-specific adapters. The codebase demonstrates strong craftsmanship in handling protocol complexities, cross-platform concerns, and maintainable abstractions.
This repository is a zero-dependency JavaScript library for detecting 18 candlestick patterns (29 variants) in financial OHLC data. It provides a consistent API per pattern (boolean check and array scanner), a multi-pattern scanner with optional trend context for confidence adjustment, a streaming API for memory-efficient processing of large datasets, a plugin system for custom patterns, and a CLI tool for quick analysis. The library supports both CommonJS and ES Modules, includes TypeScript definitions, and is extensively tested with unit, integration, and property-based tests. It is designed for use in trading systems, backtesting, and algorithmic trading applications.
The Dropbox SDK for JavaScript (dropbox-sdk-js) is a lightweight, promise-based client library that provides a programmatic interface to the Dropbox v2 API. It supports both Node.js and browser environments, with full OAuth 2.0/PKCE authentication, file upload and download with resumable and parallel streaming, exponential backoff retries, progress reporting, and content hash validation. The library is auto-generated from Dropbox's API specification (Stone) and exposes hundreds of endpoint methods covering files, sharing, team management, users, and more. It is designed for production use with robust error handling, rate-limit awareness, and environment-aware binary types. The codebase demonstrates strong architectural separation of concerns: authentication logic is encapsulated in `DropboxAuth`, file transfer logic in dedicated uploader/downloader classes, and API request routing in generated route definitions. The SDK is well-tested with unit, integration, and TypeScript type tests, and includes comprehensive examples for both browser and Node.js usage patterns.
Sidequest.js is a Redis-free background job processing system for Node.js/TypeScript that provides distributed, durable job processing using existing databases (PostgreSQL, MySQL, SQLite, MongoDB). The system features a modular monorepo architecture with separate packages for core logic, engine, database backends, web dashboard, and CLI tools. It implements job lifecycle management, scheduling via cron expressions, uniqueness constraints, retry mechanisms with backoff strategies, and provides a web interface for monitoring and management. The architecture follows clean separation of concerns with dependency injection, worker thread isolation via Piscina, and process isolation through forked child processes. Key entry points include the main Sidequest facade, engine configuration, dashboard interface, and CLI administration tools.
dockerode is a Node.js library that provides a comprehensive client for the Docker Engine Remote API. It enables direct manipulation of Docker objects such as containers, images, volumes, networks, services, and secrets using idiomatic JavaScript patterns (callbacks, promises, and streams). The library is built on top of docker-modem for HTTP communication and supports advanced features like stream hijacking, BuildKit build progress decoding (via protobuf), and session-based gRPC authentication. It does not abstract the Docker API – it passes options and responses through unchanged, making it a thin but feature-complete wrapper. The codebase is well-structured with separate entity modules (container.js, image.js, etc.) that all follow a consistent pattern of building request options and calling modem.dial(). The architecture is a library, not a service; it is used programmatically in Node.js applications to interact with a local or remote Docker daemon.
This is a high-performance SVG rendering library for Node.js, Deno, Bun, and browsers, powered by the Rust `resvg` engine. It converts SVG to PNG/AVIF with support for cropping, scaling, background colors, custom fonts (including WOFF2), bounding box extraction, and simplified SVG output. The library is implemented as a native addon via `napi-rs` for optimal speed on server-side runtimes, and also ships a WebAssembly build for browsers and edge environments. The codebase is well-structured, with clean separation between Rust core (rendering, option handling, font management) and JavaScript/TypeScript bindings. It includes comprehensive test suites, cross-platform CI/CD with prebuilt binaries for 18+ platforms, and thorough examples. The architecture demonstrates high craftsmanship in memory management (ObjectFinalize), error handling (panic catching), and pattern reuse (shared crop logic between NAPI and WASM).
chrome-remote-interface is a well-crafted Node.js library that provides a clean, dynamic API for interacting with the Chrome DevTools Protocol (CDP). It connects to a remote debugging endpoint (e.g., Chrome with --remote-debugging-port), fetches the full protocol descriptor dynamically, and generates typed JavaScript methods and events for every domain, command, and notification. The library supports callback and Promise patterns, includes a comprehensive CLI with an interactive REPL, and works across multiple implementations (Chrome, Node.js, Edge, Firefox, etc.). It does not bundle a browser; instead, it focuses on low-level protocol access, making it a foundational tool for browser automation, debugging, and custom DevTools clients.
Notifme SDK is a Node.js library for sending transactional notifications across multiple channels (email, SMS, push, webpush, Slack, WhatsApp, voice). It provides a unified interface with a provider pattern, allowing users to configure one or more providers per channel with built-in multi-provider strategies (fallback, round-robin, no-fallback). The library handles authentication, request formatting, and error handling for each provider, and includes a development mode with a notification catcher for local testing. The architecture is centered around a Sender class that dispatches requests to channel-specific strategies, which in turn call provider instances. External dependencies include nodemailer, node-fetch, web-push, winston, and node-pushnotifications. The codebase uses Flow for type checking and Babel for transpilation, with comprehensive Jest tests achieving 100% coverage thresholds.
imghash is a Node.js library for computing perceptual image hashes (pHash) using the block mean value based hashing method. It supports PNG, JPEG, BMP, and WebP image formats, and can accept file paths or Buffers as input. The library provides a simple async API to generate hashes in hex or binary format, with configurable bit lengths. It includes utility functions for converting between hex and binary representations. The codebase is written in TypeScript, well-tested with unit and e2e tests, and follows modern JavaScript practices. It handles edge cases such as palette-based PNGs and problematic JPEG images that cause longjmp errors in WebAssembly decoders by falling back to an alternative JPEG library.
svg-sprite is a mature Node.js library and CLI tool for generating SVG sprites from individual SVG files. It supports five output modes (css, view, defs, symbol, stack) and produces accompanying stylesheets (CSS, SCSS, LESS, Stylus) via Mustache templates. The system processes SVGs through a queue-based pipeline that includes SVGO optimization, dimension calculation, namespace handling, and layout algorithms (including a bin-packing algorithm for compact sprites). It is configuration-driven with YAML/JSON support for meta data, alignment, and shape transformations. The codebase is modular with clear separation of concerns: shape processing, sprite layout, mode-specific rendering, and utility functions. It includes a comprehensive test suite with snapshot tests and visual regression testing using Playwright. While the library is actively maintained and well-structured, it carries some technical debt from older JavaScript patterns and a large dependency footprint. The packer algorithm and queue-based processing are standout reusable components.
This repository is a Node.js library for interacting with the Windows registry. It provides functions to read, write, list, and manipulate registry keys and values using Windows Script Host (cscript.exe) and VBScript. The architecture separates concerns: Node.js handles argument parsing, process spawning, and result parsing, while VBScript files perform the actual registry operations via WMI. The library supports both callback and promise-based APIs, handles different registry value types, provides 32/64-bit registry access options, and includes streaming interfaces for large operations. It's a focused, well-tested solution for a specific platform-specific problem.
node-xml2js is a mature, well-tested Node.js library for bidirectional conversion between XML and JavaScript objects. It uses sax-js for parsing and xmlbuilder-js for building, providing a simple callback or Promise-based API. The library supports extensive configuration options including attribute and tag name processors, value processors, namespace handling, CDATA, and various output formatting. The source code is written in CoffeeScript (compiled to JavaScript), which is now a deprecated language, and the dependencies are outdated (sax >=0.6.0, xmlbuilder ~11.0.0). While the library is functionally complete and has been widely used (over 4900 stars), it has not seen active development in years, and the CoffeeScript source presents a barrier for modern contributions. The codebase is well-structured with clear separation of concerns, but the technical drift is high due to the use of deprecated tools and outdated dependency versions.