JSPM

Determines whether any of the segments of 2 given linestrings intersect

Returns the symmetric difference (exclusive-or) of an array of elements (elements that are present in all given arrays and not in their intersections).

Custom hook designed to detect if an element is visible within the viewport.

ID-based IntersectionObserver for React

react intersection visible hook for react

react native intersection observer

React Hook to call an action if an intersected element was reached

Performant & ergonomic 2D geometry in typescript

A group of functions for working with Maps.

A sorted array is a collection of values, arranged in an order.

Alpine JS magic helper that determines when elements overlap or intersect each other, perfect for menus, tooltips, modals, and collision detection 🥞

A group of functions for working with Maps {web}.

Frequently used tools for React

Angular wrapper for the Intersection Observer API

Simply handle user gestures and actions. Includes widgets.

ILists is a pair of key iterable list and value iterable list, with unique keys.

LISN.js for React.

image-component

compute the intersection between two intervals

A collection of methods for working with Objects.

Observes position change of an element within viewport as a result of resize, scroll, left or top coordinates change, or zooming in and out

A collection of functions for operating upon Entries {web}.

A pack of functions for working with Sets {web}.

A visibility based trigger for loading more data.

Node.js utility functions to handle objects

Gives values present in both arrays.

A helper to work with rectangular regions in the DOM

Bounding interval hierarchy and bounding volume hierarchy library for nodejs

A collection of methods for working with Objects {web}.

ILists is a pair of key iterable list and value iterable list, with unique keys {web}.

A set of helpers in TS/JS, compatible with tree-shaking, for array.

Find the intersection of two glob patterns

An Alpine.js plugin to easily add CSS classes to an element when it enters the viewport.

Returns evenly spaced values within given interval.

Node utility librairies

Lightweight cross-browser library that enables you to create a watcher for a given element, and get back a callback when it has entered the viewport

An array is a collection of values, stored contiguously {web}.

Monitor the scroll percentage of a component inside the viewport, using the IntersectionObserver API.

A collection of helpers for detecting intersections in 2D and 3D

A fork from pelias/polygon-lookup with updated dependencies

A collection of functions for operating upon Lists.

An iterable is a sequence of values {web}.

Creates an array of unique values that are included in all given arrays.

A Vue.js component to lazy load images using the Intersection Observer

Javascript Object Extensions

A sorted array is a collection of values, arranged in an order {web}.

A Svelte action that monitors an element enters or leaves the viewport or a parent element. Performant and efficient thanks to using Intersection Observer under the hood.

Counts occurrences of values.

Lazy load component with react && react-router.

With Target Observer, you can easily trigger animations, lazy load content, or handle visibility-based logic in your application.

A collection of functions for operating upon Entries.

test if a ray intersects an aabb in 2d/3d space

Boolean operations on polygons

Apply boolean polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

Find all intersections between two sets of line segments

Allows Union, Difference, Xor, and Intersection operations on two polygons.

Provides a way with extra configuration options to execute a handler when a given element is on view.

IntersectionTrigger utilizes the most modern web technology to trigger anything by intersection. Including scroll-based animations.

A JavaScript port of the polyclip library

Styled components syntax for creating raw html in javascript.

Greiner-Hormann clipping algorithm; Typescript port.

javascript intersection observer

Frequently used tools for React

A basic library for some utility functions

Javascript library for 2d geometry

RegexSolver allows you to manipulate regular expressions as sets, enabling operations such as intersection, union, and subtraction.

A small wrapper around turf-intersect to safely clip one geojson polygon to another

Apply boolean Polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

A libraray for Isochrone, Routing & geoprocessing GeoJson Data

Test if two triangles in the plane intersect

Helpers for Set objects.

Create an iterator which returns the intersection of two or more iterators.

A utility library providing common array manipulations and React hooks.

detect if a 2D triangle and circle collide

Apply boolean polygon clipping operations (union, intersection, difference, xor) to Polygons & MultiPolygons in your GeoJSON files.


ReactJS component that applies CSS styles as it approaches the top of the viewport.

An easy-to-use React hook that tells you whether a component/element is visible on the viewport currently, and if yes, how much of it is visible.

Gives values present in both arrays.

Counts occurrences of values.

A collection of functions for operating upon Lists {web}.

Detect self-intersecting polygons in Javascript. An implementation of the Bentley–Ottmann sweep line algorithm for detecting crossings in a set of line segments.

React Hook for Tracking Section Visibility in the Viewport

Dasboard for React

Intersection Observer implementation for Angular

A Bounding Volume Hierarchy data structure, for fast ray-mesh intersection

Returns evenly spaced values within given interval.

A Vue.js component to lazy load images using the Intersection Observer.

A minimalistic es6 implementation of set

Zero-dependency TypeScript runtime type validation with full type inference

Return intersect object that have same key from a number of objects

An abstract layer that would make using intersection observer easier

Wraps the Observer API

BVH

Framework agnostic library to detect viewable impressions

Calculate intersection of two lines

React lazy loading component using vanilla-lazyload library. Speedy, lightweight and easy to use.

Scalable distinct value counting system

Render on intersection

A simple and fast API to manage viewport and DOM elements intersections as you scroll

Monitor if a component is inside the viewport, using IntersectionObserver API

🔢 JavaScript range validation library - Extend Number and BigInt prototypes with powerful range checking, validation, and manipulation utilities. Perfect for form validation, game development, and scientific computing.

Monitor if a component is inside the viewport, using IntersectionObserver API

Javascript library for 2d geometry. Cloned from flattenjs

A library for working with Sets and arrays as sets.

Rearranges values in arbitrary order.

Flattens nested array to given depth.

A wrapper for @loadable/component that uses IntersectionObserver to trigger component load.

Flattens nested array to given depth.

Handle your array objects with ease

A collection of observers for Svelte

Gives values present in both arrays.

This is a simple React Hooks that trigger a callback all time the element is viewed.

Two dimensional geometry manipulation

Remove self intersections, t-junctions and duplicate edges/vertices from a planar straight line graph

A Svelte action that monitors an element enters or leaves the viewport or a parent element. Performant and efficient thanks to using Intersection Observer under the hood. Forked from maciekgrzybek to support Svelte 5 after no merge of fixes.

test for the intersection of convex polytopes in 2d or 3d, computing the minimum translation vector

Fast testing whether two line segments intersect

A BVH implementation to speed up raycasting against three.js meshes.

Javascript library for 2d geometry

Implementation of range data structures using plain JavaScript arrays.

A infinite scroll component in ReactJS, using Intersection Observer API.

An intersection observer hook for all your purposes

TailwindCSS Zen intersection animation plugin

Find the symmetric difference of two string arrays.

Scroll position-related navigation state management

Plain vanilla JS IntersectionObserver utility, to be used as a mixin

An API (wrapper actually) for connect trough Intersection Controller game data like users and maps

Rearranges values in arbitrary order.

Simple Javascript IntersectionObserver implementation for Ember applications.

Small wrapper for IntersectionObserver, to use it more modular way.

Find unique common elements among given arrays

An easy to use intersection observer hooks based on IntersectionObserver API.

An easier way to observe the intersections with the viewport

Given a graph with a graph with a non planar embedding, make changes to this graph so that it becomes planar.

Detects if the inner children are visible

[Deprecated] JST to perform set intersection and set subtraction operations on 2 user provided arrays

Returns the vertices of multiple circle intersection

Bezier curve intersection algorithm and utilities

Script for lazyloading assets using Intersection Observer API

calculate the intersection of a ray and a disk or plane in three dimensions

Broad coverage of sorted array operations

Apply boolean Polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

React standard library

A library for slideup animation using directive with Angular

Creates an array of unique values, in order, from all given arrays.

wip

Javascript Set operations

Extending the Set class in order to support mathematical set properties and operations.

A tiny library to observe elements entering the viewport using Intersection Observer.

[![npm package][npm-badge]][npm] ![Module formats][module-formats]

Create an iterator which returns the intersection of two or more iterators according to a hash function.

Lightweight image lazy-loader using the intersection observer API.

Simple modules for functional programming, done for fun.

Returns the items two arrays do not share

A tiny library to observer elements

A Vue.js component to lazy load images using the Intersection Observer.

Provides functions to operate on Sets, Arrays and Array-Like JavaScript data structures

Monitor if a component is inside the viewport, using IntersectionObserver API

Manipulation with date periods: intersection, splitting etc.

Circle Intersection Regions

Monitor if a component is inside the viewport, using IntersectionObserver API

Get an intersection of multiple arrays and account objects.

Intersection Observer for React

Experimental API for observing the visible box of an element.

🧮 Common set operations (union, difference, isSubset, etc.) for any Iterable

Takes two lines and returns all intersection points

Rearranges values in arbitrary order.

Rearranges values in arbitrary order.

React utilities for lazy image loading

a node.js port of jsclipper [JS]... which is a port of clipper [C++, C#, Delphi]

Compute the closest point between two line segments

ray aabb intersection test using the slab method

A set implementation for integers

a plugin for vue exposure, used by intersection observer API

intersections of sorted streams

A dependency free utility to set and remove animation classes on elements as they become visible in the viewport, using the Intersection Observer API

JavaScript utility to observe sticky elements using the Intersection Observer API

A scroll-to-reveal JavaScript library that unmasks your elements using the clip-path CSS property.

Find all intersections in a set of intervals

Simple robust library for finding lines intersections fast.

Extremely fast set and map/reduce operations for Arrays and Sets plus CartesianProducts

Catching the moment when the specific part of an element is visible in the viewport

React utilities for lazy image loading - Patched version

Watches targets position in viewport using IntersectionObserver - similar to menuspy

React components to add reveal animations using the Intersection Observer API and CSS Animations.

A lightweight and simple React hook for detecting if an element is in the viewport using the Intersection Observer API. Perfect for lazy loading, infinite scrolling, animations, and more!

generate array of intersection points from array and geometry

Tailwind CSS with Intersection Observer variants

A lightweight TypeScript library providing utilities for observing intersection and resize events of DOM elements with automatic cleanup.

This is a React component that loads an image source, only after it is partially or fully visible in the viewport

Simple Intersection Observer hook for React

A library of intersection algorithms covering all SVG shape types

intersection and difference

Tailwind CSS with Intersection Observer & Load variants

Automatically lazy load images inserted into the DOM

Hook for intersection observer

A React hook that tells you when an element enters or leaves the viewport.

React library for observing and loading blocks of items in lists.

A JS/TS library that expands upon the functionality of Sets

This will return the array of objects that are common in a set of array of objects based on single or multiple keys

Modern React component for scroll-based triggers and animations with TypeScript support. A rewritten and modernized version of the original react-scroll-trigger package.

Simple intersection implement.

The package is a "sentinel" that trigger a function when is visible.

Perform Set Operations (Union|Intersection|Difference) on SVG Paths

Week day picker for React

Set, but for Objects.

A collection of common algorithm ulities including Binary Search

React <img> drop-in replacement for lazy image loading

Supply visibility classes and data to selected elements on your webpage.

Adds a directive that listens for click events and scrolls to elements.

A very simple script to compute the intersection point of two great circles specified using two points. The intersection point is computed either in the Cartesian plane of its coordinates or on a Sphere.

JavaScript Package for Creating an array without duplicates

Combine user-defined type guards / type predicates as unions and intersections.

A lightweight library of basic geometry shapes interactions

intersect a ray with a quadtree

A batteries include Set class built on top of ES6 sets

Creates an array of unique values that are included in all given arrays.

web component that dispatches an event whenever it comes in and goes out of viewport

Snap points to the nearest point in a GeoJSON collection of points.

A library to lazy load images using Intersection Observer

Checks if two circles intersect.

Angular library that wraps the browser IntersectionObserver in an Angular directive

Union and Intersection operators for highland.js streams

Function extensions for JavaScript's built-in Set type

Compare two sets (array of items) and get relationships between them (Disjoint | Intersecting | Subset | Superset | Equal)

React hook to use intersection API

An esay-to-use wrapper class over intersection observer API.

Find characters in a string that also occur in another string

Wrapper for IntersectionObserver that returns the scroll direction

Set Operations in Typescript

Compute intersections & unions of streams

More operations on Sets: union, intersection, include, etc.

Week day picker for React

A React component that supports infinite scroll using Intersection Observer API

A fork from pelias/polygon-lookup with updated dependencies

Lazy Loading images and other (JS, etc.) using Intersection Observer with polyfill

React hook for using intersetion observers.

Disjoint continuous ranges

R.intersection exported as a module

JavaScript Set prototype extensions using Metho

Scroll through a list of data quickly

**React Lazily IMG** is a React Wrapper Component to lazily load images. The goal is to use the convenient and known standard HTML tags and just have them lazily loaded.

A set of useful functions that give easier control over set manipulation

add intersection events to dom elements

A tiny library for lazily loading any content in React

- Version 1.0.2 Rename directive selector rtIsElementVisible to rtIsVisibleElement - Version 1.0.3 Edit readme

React utilities for lazy image loading

**With npm:**

given an array of 3d line segments, chop the lines at all points of intersection, returning non-intersecting sub-segments