normalize-wheel-es

This package does exactly what it promises: normalizes mouse wheel events across browsers into predictable pixel values. The API is dead simple - import the function, pass it a wheel event, and get back an object with spinX, spinY, and pixelX/Y values. I've used it in custom scrollable components and canvas-based editors where precise wheel control matters, and it handles the cross-browser quirks (Firefox's different units, trackpad vs mouse wheel) without intervention.

The main friction point is documentation. While TypeScript definitions exist and work fine, there's minimal explanation of what the return values actually represent or how to interpret them for different use cases. You'll likely need to experiment or read the source (which is mercifully short) to understand the difference between 'spin' and 'pixel' values. Error handling is non-existent - pass it something that's not an event and you'll get runtime errors without helpful messages.

Despite these gaps, it's a solid utility that solves a genuine pain point. Once you understand the API through trial and error, it just works reliably across all browsers.

This is a single-purpose utility that does one thing well: normalizes wheel event deltas across browsers. It's a pure mathematical transformation with no dependencies, which is ideal from a supply chain perspective. The API is straightforward—pass in a wheel event, get back normalized pixel values. I've used this in production dashboards and canvas-based editors without issues.

From a security standpoint, it's about as safe as a UI utility can be. There's no network activity, no DOM manipulation, no string parsing or eval risks. The input validation is implicit through TypeScript types and the code simply performs arithmetic on event properties. Errors are rare since it's just reading standard WheelEvent properties and returning numbers.

The main concern is that it hasn't been updated since 2022, though wheel events are stable enough that this isn't critical. The code is small enough (~100 lines) that you can audit it in minutes. No auth, crypto, or data handling means the attack surface is essentially zero.

This package does exactly one thing: takes native wheel events and returns normalized pixel values you can actually use. The API is refreshingly simple - import `normalizeWheel` and call it with your event. You get back an object with `spinX`, `spinY`, `pixelX`, and `pixelY` values that are consistent across browsers. No configuration, no setup, just call the function.

The TypeScript definitions are solid and autocomplete works perfectly in VS Code. The returned object structure is intuitive and the normalized values handle the Firefox/Chrome/Safari differences seamlessly. I've used this in custom scroll implementations and canvas zoom controls without issues.

The biggest weakness is minimal documentation - the README is sparse and doesn't explain what the different return values represent or when to use `pixel` vs `spin`. You'll need to read the source or experiment to understand the nuances. Also no active maintenance since 2022, though for a stable utility like this, that's less concerning.