You're Invited:Meet the Socket Team at BlackHat and DEF CON in Las Vegas, Aug 7-8.RSVP
Sign inDemoInstall


Package Overview
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies



The engine that powers scroll-into-view-if-needed

Version published

Package description

What is compute-scroll-into-view?

The compute-scroll-into-view npm package is a utility that calculates the scroll position necessary to make an element visible within its container. This is useful for smoothly scrolling items into view, especially in custom scrolling interfaces where the default browser behavior does not suffice.

What are compute-scroll-into-view's main functionalities?

Compute scroll position

This feature calculates the necessary scroll positions to bring an element into view within its container. The function returns an array of actions that can be applied to achieve the desired scroll effect. Each action specifies the element to scroll and the new top and left scroll positions.

import computeScrollIntoView from 'compute-scroll-into-view';
const element = document.getElementById('targetElement');
const actions = computeScrollIntoView(element, {
  scrollMode: 'if-needed',
  block: 'nearest',
  inline: 'nearest'
actions.forEach(({ el, top, left }) => {
  el.scrollTop = top;
  el.scrollLeft = left;

Other packages similar to compute-scroll-into-view



3.1.0 (2023-09-30)


  • account for scroll margin (#906) (b932154)

Bug Fixes



npm stat npm version gzip size size semantic-release


Lower level API that is used by the ponyfill scroll-into-view-if-needed to compute where (if needed) elements should scroll based on options defined in the spec and the scrollMode: "if-needed" draft spec proposal. Use this if you want the smallest possible bundlesize and is ok with implementing the actual scrolling yourself.

Scrolling SVG elements are supported, as well as Shadow DOM elements. The VisualViewport API is also supported, ensuring scrolling works properly on modern devices. Quirksmode is also supported as long as you polyfill document.scrollingElement.


npm i compute-scroll-into-view

You can also use it from a CDN:

const { compute } = await import('')


import { compute } from 'compute-scroll-into-view'

const node = document.getElementById('hero')

// same behavior as Element.scrollIntoView({block: "nearest", inline: "nearest"})
// see:
const actions = compute(node, {
  scrollMode: 'if-needed',
  block: 'nearest',
  inline: 'nearest',

// same behavior as Element.scrollIntoViewIfNeeded(true)
// see:
const actions = compute(node, {
  scrollMode: 'if-needed',
  block: 'center',
  inline: 'center',

// Then perform the scrolling, use scroll-into-view-if-needed if you don't want to implement this part
actions.forEach(({ el, top, left }) => {
  el.scrollTop = top
  el.scrollLeft = left


compute(target, options)


Type: Object


Type: 'start' | 'center' | 'end' | 'nearest'
Default: 'center'

Control the logical scroll position on the y-axis. The spec states that the block direction is related to the writing-mode, but this is not implemented yet in this library. This means that block: 'start' aligns to the top edge and block: 'end' to the bottom.


Type: 'start' | 'center' | 'end' | 'nearest'
Default: 'nearest'

Like block this is affected by the writing-mode. In left-to-right pages inline: 'start' will align to the left edge. In right-to-left it should be flipped. This will be supported in a future release.


Type: 'always' | 'if-needed'
Default: 'always'

This is a proposed addition to the spec that you can track here:

This library will be updated to reflect any changes to the spec and will provide a migration path. To be backwards compatible with Element.scrollIntoViewIfNeeded if something is not 100% visible it will count as "needs scrolling". If you need a different visibility ratio your best option would be to implement an Intersection Observer.


Type: Element | Function

By default there is no boundary. All the parent elements of your target is checked until it reaches the viewport (document.scrollingElement) when calculating layout and what to scroll. By passing a boundary you can short-circuit this loop depending on your needs:

  • Prevent the browser window from scrolling.
  • Scroll elements into view in a list, without scrolling container elements.

You can also pass a function to do more dynamic checks to override the scroll scoping:

const actions = compute(target, {
  boundary: (parent) => {
    // By default `overflow: hidden` elements are allowed, only `overflow: visible | clip` is skipped as
    // this is required by the CSSOM spec
    if (getComputedStyle(parent)['overflow'] === 'hidden') {
      return false

    return true


Type: Boolean
Default: false

By default the spec states that overflow: hidden elements should be scrollable because it has been used to allow programatic scrolling. This behavior can sometimes lead to scrolling issues when you have a node that is a child of an overflow: hidden node.

This package follows the convention adopted by Firefox of setting a boolean option to not scroll all nodes with overflow: hidden set.



Package last updated on 30 Sep 2023

Did you know?


Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.


Related posts

SocketSocket SOC 2 Logo


  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog


Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc