JSPM

An iterable is a sequence of values {web}.

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

A fork from pelias/polygon-lookup with updated dependencies

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

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

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

A helper to work with rectangular regions in the DOM

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

Frequently used tools for React

Dasboard for React

Javascript Object Extensions

Counts occurrences of values.

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

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

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

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

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.

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

Lazy load component with react && react-router.

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

Styled components syntax for creating raw html in javascript.

Helpers for Set objects.

A JavaScript port of the polyclip library

Returns evenly spaced values within given interval.

Framework agnostic library to detect viewable impressions

detect if a 2D triangle and circle collide

A basic library for some utility functions

Lightweight image lazy-loader using the intersection observer API.

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.

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

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


Circle Intersection Regions

javascript intersection observer

Boolean operations on polygons

Greiner-Hormann clipping algorithm; Typescript port.

Counts occurrences of values.

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

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

Gives values present in both arrays.

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

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

Gives values present in both arrays.

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

BVH

Returns evenly spaced values within given interval.

Render on intersection

Scalable distinct value counting system

Intersection Observer implementation for Angular

**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.

An intersection observer hook for all your purposes

Zero-dependency TypeScript runtime type validation with full type inference

Find unique common elements among given arrays

Scroll position-related navigation state management

Component which use intersection observer API to verify if its children are in the screen

Flattens nested array to given depth.

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

React Hook for Tracking Section Visibility in the Viewport

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

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

Javascript library for 2d geometry

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.

Wraps the Observer API

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

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

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

A libraray for Isochrone, Routing & geoprocessing GeoJson Data

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

Implementation of range data structures using plain JavaScript arrays.

A library for slideup animation using directive with Angular

TailwindCSS Zen intersection animation plugin

Find the symmetric difference of two string arrays.

A tiny library to observer elements

Test if two triangles in the plane intersect

Calculate intersection of two lines

🔢 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.

Intersection Observer for React

Easy way to observe HTML element visibility, based on scrolling, resizing, changes in DOM. Emits true when observed element starts to be visible and emits false when the element hides.

Fast testing whether two line segments intersect

Vue JS lazy image loading

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

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

A library for working with Sets and arrays as sets.

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

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

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

Flattens nested array to given depth.

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

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

Handle your array objects with ease

A utility library providing common array manipulations and React hooks.

Hook for intersection observer

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

An easier way to observe the intersections with the viewport

A collection of observers for Svelte

wip

Javascript library for 2d geometry

Returns the vertices of multiple circle intersection

IntersectionObserver MenuSpy

Watches targets position in viewport using IntersectionObserver - similar to menuspy

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

Set Operations in Typescript

An abstract layer that would make using intersection observer easier

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

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

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

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

Set, but for Objects.

Rearranges values in arbitrary order.

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

Simple Javascript IntersectionObserver implementation for Ember applications.

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

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

Find all intersections between two sets of line segments

Two dimensional geometry manipulation

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

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

Rearranges values in arbitrary order.

Javascript library for 2d geometry. Cloned from flattenjs

intersection and difference

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

Broad coverage of sorted array operations

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

Set implementation with some extra utils

Returns the items two arrays do not share

Detects if the inner children are visible

React library for suspending hydration until components enter the viewport.

Rearranges values in arbitrary order.

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

Made with create-react-library

React standard library

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

Disjoint continuous ranges

Manipulation with date periods: intersection, splitting etc.

Add additional features to a TypeScript type at runtime

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

Bezier curve intersection algorithm and utilities

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

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

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

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

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

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

Get callback when a DOM element enters or leaves the viewport.

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

Week day picker for React

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

JavaScript utility to observe sticky elements using the Intersection Observer API

Automatically lazy load images inserted into the DOM

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

React utilities for lazy image loading

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

Takes two lines and returns all intersection points

Tailwind CSS with Intersection Observer variants

React utilities for lazy image loading

JavaScript Package for Creating an array without duplicates

Script for lazyloading assets using Intersection Observer API

Get an intersection of multiple arrays and account objects.

Experimental API for observing the visible box of an element.

Simple modules for functional programming, done for fun.

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

Rearranges values in arbitrary order.

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

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

A set implementation for integers

ray aabb intersection test using the slab method

Compute the closest point between two line segments

React hook for using intersetion observers.

R.intersection exported as a module

Find all intersections in a set of intervals

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

Scroll through a list of data quickly

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

generate array of intersection points from array and geometry

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

A library to lazy load images using Intersection Observer

Simple robust library for finding lines intersections fast.

Javascript Set operations

React utilities for lazy image loading - Patched version

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!

a plugin for vue exposure, used by intersection observer API

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

Checks if two circles intersect.

Angular library that wraps the browser IntersectionObserver in an Angular directive

Function extensions for JavaScript's built-in Set type

Simple Intersection Observer hook for React

calculate the intersection of a ray and a cone in three dimensions

React hooks for detecting if an element is on screen

Tailwind CSS with Intersection Observer & Load variants

React hook to use intersection API

A collection of common algorithm ulities including Binary Search

Simple intersection implement.

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

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

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

Week day picker for React

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

A batteries include Set class built on top of ES6 sets

add intersection events to dom elements

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

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

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.

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

A lightweight library of basic geometry shapes interactions

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

R.intersection exported as a module

Wrapper for IntersectionObserver that returns the scroll direction

To compute axis which some integer ranges on it

Union and Intersection operators for highland.js streams

A fork from pelias/polygon-lookup with updated dependencies

Compute intersections & unions of streams

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

A React component that supports infinite scroll using Intersection Observer API

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

Find characters in a string that also occur in another string

Angular-inspired deferred loading for React with compound triggers, prefetching, and advanced performance optimizations

React utilities for lazy image loading

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

JavaScript Set prototype extensions using Metho

LazyLoading for the New Millenium™

Utility to check if polygons overlap.

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

A library of intersection algorithms covering all SVG shape types

Helper making the observation of element's visibility a little more convenient. Based on the IntersectionObserver API.

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

React utilities for lazy image loading

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

intersect a ray with a quadtree

Extend Quasar animation system

Javascript module for in view animations using the Javascript IntersectionObserver.

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.0.2.

A library of intersection algorithms covering all SVG shape types

geo json operation

An extension of the normal Set datastructure. Holds unique entries in either normal mode or complement mode. In normal mode, the entries are present in the set (normal behavior of a standard Set). In complement mode, the entries are those which are not pr

Observes current visible childrens on root element. [Demo](https://saschanaz.github.io/visible-children-observer/)

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

Directive to tracking of target element intersection ratio

LazyLoading for the New Millenium™

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

a plugin

Doars plugin that adds a intersect directive for reacting to intersection changes.

React hooks for detecting if an element is on screen

A simple, no-frills visibility utility. Will tell you if a component is 100% inside the viewport, and when a visible component exits the viewport.

Compare elements in sets

**With npm:**

A simple infinite scroll component based on react-intersection-observer

Intersection Observer API Animation