website/pages/docs/detectOverflow.mdx
<PageCard>
# detectOverflow
Detects when the floating or reference element is overflowing a
clipping container or custom boundary.
<ShowFor packages={['core']}>
```js
import {detectOverflow} from '@floating-ui/core';
```
</ShowFor>
<ShowFor packages={['dom']}>
```js
import {detectOverflow} from '@floating-ui/dom';
```
</ShowFor>
<ShowFor packages={['react']}>
```js
import {detectOverflow} from '@floating-ui/react';
```
</ShowFor>
<ShowFor packages={['react-dom']}>
```js
import {detectOverflow} from '@floating-ui/react-dom';
```
</ShowFor>
<ShowFor packages={['vue']}>
```js
import {detectOverflow} from '@floating-ui/vue';
```
</ShowFor>
<ShowFor packages={['react-native']}>
```js
import {detectOverflow} from '@floating-ui/react-native';
```
</ShowFor>
</PageCard>
A clipping container (or boundary) is one that causes child
elements inside it to be clipped if they overflow it. Visibility
optimizer middleware use this function for **collision
detection**, making it useful for your own custom middleware that
do the same.
## Usage
Inside your custom middleware, make your `fn{:.function}`
`async{:.keyword}` and `await{:js}` it, passing in the middleware
`state{:.param}`:
```js
const middleware = {
name: 'middleware',
async fn(state) {
const overflow = await detectOverflow(state);
return {};
},
};
```
The returned value, `overflow{:.const}`, is a
`SideObject{:.class}` containing side properties with numbers
representing offsets.
- A positive number means the element is overflowing the clipping
boundary by that number of pixels.
- A negative number means the element has that number of pixels
left before it will overflow the clipping boundary.
- `0{:js}` means the side lies flush with the clipping boundary.
## Options
`detectOverflow(){:js}` takes options as a second argument.
```js
await detectOverflow(state, {
// options
});
```
```ts
interface DetectOverflowOptions {
boundary: Boundary;
rootBoundary: RootBoundary;
elementContext: ElementContext;
altBoundary: boolean;
padding: Padding;
}
```
### `boundary{:.key}`
```ts
type Boundary =
| 'clippingAncestors'
| Element
| Array<Element>
| Rect;
```
This describes the clipping element(s) or area that overflow will
be checked relative to. The default is
`'clippingAncestors'{:js}`, which are the overflow ancestors
which will cause the element to be clipped.
```js
await detectOverflow(state, {
boundary: document.querySelector('#container'),
});
```
### `rootBoundary{:.key}`
```ts
type RootBoundary = 'viewport' | 'document' | Rect;
```
This describes the root boundary that the element will be checked
for overflow relative to. The default is `'viewport'{:js}`, which
is the area of the page the user can see on the screen. This is
the
[Visual Viewport](https://developer.mozilla.org/en-US/docs/Web/API/Visual_Viewport_API)
which correctly handles pinch-zooming and mobile viewports when
the keyboard is open.
The other string option is `'document'{:js}`, which is the entire
page outside the viewport.
```js
await detectOverflow(state, {
rootBoundary: 'document', // 'viewport' by default
});
```
You may also pass a `Rect{:.class}` object to define a custom
boundary area (relative to the viewport).
```js
await detectOverflow(state, {
// Layout viewport, instead of the visual viewport
rootBoundary: {
x: 0,
y: 0,
width: document.documentElement.clientWidth,
height: document.documentElement.clientHeight,
},
});
```
### `padding{:.key}`
```ts
type Padding =
| number
| Partial<{
top: number;
right: number;
bottom: number;
left: number;
}>;
```
This describes the virtual padding around the boundary to check
for overflow.
```js
await detectOverflow(state, {
// 5px on all sides
padding: 5,
// Unspecified sides are 0
padding: {
top: 5,
left: 20,
},
});
```
### `elementContext{:.key}`
```ts
type ElementContext = 'reference' | 'floating';
```
By default, the floating element is the one being checked for
overflow.
But you can also change the context to `'reference'{:js}` to
instead check its overflow relative to its clipping boundary.
```js
await detectOverflow(state, {
elementContext: 'reference', // 'floating' by default
});
```
### `altBoundary{:.key}`
This is a boolean value which determines whether to check the
alternate `elementContext{:.key}`'s boundary.
For instance, if the `elementContext{:.key}` is
`'floating'{:js}`, and you enable this option, then the boundary
in which overflow is checked for is the `'reference'{:js}`'s
boundary. This only applies if you are using the default
`'clippingAncestors'{:js}` string as the `boundary{:.key}`.
```js
await detectOverflow(state, {
altBoundary: true, // false by default
});
```