React Hooks for IntersectionObserver.
Tracks the intersection of a DOM element and its containing element or the viewport.
Tracks the intersection of a DOM element and its containing element or the viewport.
``` npm i @ash/use-intersection-observer ```
@stackmeister/react-use-intersection-observer =============================================
easy to use intersection observer
React hook to use intersection API
Monitor if a component is inside the viewport, using IntersectionObserver API
React lmw-use-intersection-observer
Series of utilities in hooks format to extend the operation of Atomico
Tracks the intersection of a DOM element and its containing element or the viewport.
easy to use intersection observer, adapted for vue.
vue directive use Intersection Observer API
easy to use intersection observer, adapted for react.
An easy to use intersection observer hooks based on IntersectionObserver API.
React hooks for observing element visibility using the Intersection Observer API. Supports single element and multiple elements tracking with lifecycle callbacks.
React hook to use IntersectionObserver declaratively.
A React hook for the IntersectionObserver API that uses a polyfill when the native API is not available
Computes the intersection between two SVG paths
A hook to register an intersection observer listener
Tracks the intersection of a DOM element and its containing element or the viewport.
React component for the Intersection Observer API
Intersection Observer Admin for better performance
A React hook for observing element visibility using Intersection Observer API
Intersection result primitives for RustUse geometry
Facade crate for the RustUse geometry workspace.
Group, intersect and Match collections using custom rules.
This gem allows you to pass multiple roles into methods like save and update_attributes
Use Bentley-Ottmann algorithm to solve self-intersecting polygon issue
It recognizes common abbreviations and misspellings for names of the books of the Bible and a variety of ways of denoting ranges of chapters and verses. It can parse pericopes singly or out of a block of text. It's useful for comparing two pericopes for intersection and normalizing them into a well-formatted string.
Analyze code for potentially uncalled / dead methods, now with auto-removal. == Features/Problems: * Static analysis of code. Can be easily hooked up to a CI. * As with all static analysis tools of dynamic languages, can't be 100%. * Whitelisting known good methods by name or regexp. * Use --rails for Rails-specific domain knowledge. * Use debride_rm to brazenly remove all unused methods. BE CAREFUL. * Use `debride_rails_whitelist` to generate an emperical whitelist from logs. * Uses path_expander, so you can use: * dir_arg -- expand a directory automatically * @file_of_args -- persist arguments in a file * -path_to_subtract -- ignore intersecting subsets of files/directories
Allows one to assign random attributes to ranges and juggle them in lists. Also adds parsing from string, but most interesting when used in a PositionRange::List. In lists standard set operations can be applied to them, like addition, substraction and intersection. In addition one can also get the combined size of all the ranges in the list. And cluster overlapping ranges, maintaining the attributes.
It recognizes common abbreviations and misspellings for names of the books of the Bible and a variety of ways of denoting ranges of chapters and verses. It can parse pericopes singly or out of a block of text. It's useful for comparing two pericopes for intersection and normalizing them into a well-formatted string.
Flay analyzes code for structural similarities. Differences in literal values, variable, class, method names, whitespace, programming style, braces vs do/end, etc are all ignored. Making this totally rad. == Features/Problems: * Reports differences at any level of code. * Adds a score multiplier to identical nodes. * Differences in literal values, variable, class, and method names are ignored. * Differences in whitespace, programming style, braces vs do/end, etc are ignored. * Works across files. * Add the flay-persistent plugin to work across large/many projects. * Run --diff to see an N-way diff of the code. * Provides conservative (default) and --liberal pruning options. * Provides --fuzzy duplication detection. * Language independent: Plugin system allows other languages to be flayed. * Ships with .rb and .erb. * javascript and others will be available separately. * Includes FlayTask for Rakefiles. * Uses path_expander, so you can use: * dir_arg -- expand a directory automatically * @file_of_args -- persist arguments in a file * -path_to_subtract -- ignore intersecting subsets of files/directories * Skips files matched via patterns in .flayignore (subset format of .gitignore). * Totally rad.
Bindings for libfa, a library to manipulate finite automata. Automata are constructed from regular expressions, using extended POSIX syntax, and make it possible to compute interesting things like the intersection of two regular expressions (all strings matched by both), or the complement of a regular expression (all strings _not_ matched by the regular expression). It is possible to convert from regular expression (compile) to finite automaton, and from finite automaton to regular expression (as_regexp)
Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking viewport rectangle intersection or containment of a mouse click point in popular geometry shapes such as rectangle, square, arc (open, chord, and pie), ellipse, circle, polygon, and paths containing lines, quadratic bézier curves, and cubic bezier curves, potentially with affine transforms applied like translation, scale, rotation, shear/skew, and inversion (including both the Ray Casting Algorithm, aka Even-odd Rule, and the Winding Number Algorithm, aka Nonzero Rule). Additionally, it contains some purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).