pre-installations and preparations
This commit is contained in:
1 parent
3e5a0329cb
commit
201d621ac3
6977 files changed
+742826
No files matched your search
+20
@@ -0,0 +1,20 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2021-present Floating UI contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
# @floating-ui/core
|
||||
|
||||
This is the platform-agnostic core of Floating UI, exposing the main
|
||||
`computePosition` function but no platform interface logic.
|
||||
+1
@@ -0,0 +1 @@
|
||||
const t=["top","right","bottom","left"],e=["start","end"],n=t.reduce(((t,n)=>t.concat(n,n+"-"+e[0],n+"-"+e[1])),[]),o=Math.min,i=Math.max,r={left:"right",right:"left",bottom:"top",top:"bottom"},a={start:"end",end:"start"};function l(t,e,n){return i(t,o(e,n))}function s(t,e){return"function"==typeof t?t(e):t}function c(t){return t.split("-")[0]}function f(t){return t.split("-")[1]}function m(t){return"x"===t?"y":"x"}function u(t){return"y"===t?"height":"width"}function g(t){return["top","bottom"].includes(c(t))?"y":"x"}function d(t){return m(g(t))}function p(t,e,n){void 0===n&&(n=!1);const o=f(t),i=d(t),r=u(i);let a="x"===i?o===(n?"end":"start")?"right":"left":"start"===o?"bottom":"top";return e.reference[r]>e.floating[r]&&(a=y(a)),[a,y(a)]}function h(t){return t.replace(/start|end/g,(t=>a[t]))}function y(t){return t.replace(/left|right|bottom|top/g,(t=>r[t]))}function w(t){return"number"!=typeof t?function(t){return{top:0,right:0,bottom:0,left:0,...t}}(t):{top:t,right:t,bottom:t,left:t}}function x(t){const{x:e,y:n,width:o,height:i}=t;return{width:o,height:i,top:n,left:e,right:e+o,bottom:n+i,x:e,y:n}}function v(t,e,n){let{reference:o,floating:i}=t;const r=g(e),a=d(e),l=u(a),s=c(e),m="y"===r,p=o.x+o.width/2-i.width/2,h=o.y+o.height/2-i.height/2,y=o[l]/2-i[l]/2;let w;switch(s){case"top":w={x:p,y:o.y-i.height};break;case"bottom":w={x:p,y:o.y+o.height};break;case"right":w={x:o.x+o.width,y:h};break;case"left":w={x:o.x-i.width,y:h};break;default:w={x:o.x,y:o.y}}switch(f(e)){case"start":w[a]-=y*(n&&m?-1:1);break;case"end":w[a]+=y*(n&&m?-1:1)}return w}const b=async(t,e,n)=>{const{placement:o="bottom",strategy:i="absolute",middleware:r=[],platform:a}=n,l=r.filter(Boolean),s=await(null==a.isRTL?void 0:a.isRTL(e));let c=await a.getElementRects({reference:t,floating:e,strategy:i}),{x:f,y:m}=v(c,o,s),u=o,g={},d=0;for(let n=0;n<l.length;n++){const{name:r,fn:p}=l[n],{x:h,y:y,data:w,reset:x}=await p({x:f,y:m,initialPlacement:o,placement:u,strategy:i,middlewareData:g,rects:c,platform:a,elements:{reference:t,floating:e}});f=null!=h?h:f,m=null!=y?y:m,g={...g,[r]:{...g[r],...w}},x&&d<=50&&(d++,"object"==typeof x&&(x.placement&&(u=x.placement),x.rects&&(c=!0===x.rects?await a.getElementRects({reference:t,floating:e,strategy:i}):x.rects),({x:f,y:m}=v(c,u,s))),n=-1)}return{x:f,y:m,placement:u,strategy:i,middlewareData:g}};async function A(t,e){var n;void 0===e&&(e={});const{x:o,y:i,platform:r,rects:a,elements:l,strategy:c}=t,{boundary:f="clippingAncestors",rootBoundary:m="viewport",elementContext:u="floating",altBoundary:g=!1,padding:d=0}=s(e,t),p=w(d),h=l[g?"floating"===u?"reference":"floating":u],y=x(await r.getClippingRect({element:null==(n=await(null==r.isElement?void 0:r.isElement(h)))||n?h:h.contextElement||await(null==r.getDocumentElement?void 0:r.getDocumentElement(l.floating)),boundary:f,rootBoundary:m,strategy:c})),v="floating"===u?{x:o,y:i,width:a.floating.width,height:a.floating.height}:a.reference,b=await(null==r.getOffsetParent?void 0:r.getOffsetParent(l.floating)),A=await(null==r.isElement?void 0:r.isElement(b))&&await(null==r.getScale?void 0:r.getScale(b))||{x:1,y:1},R=x(r.convertOffsetParentRelativeRectToViewportRelativeRect?await r.convertOffsetParentRelativeRectToViewportRelativeRect({elements:l,rect:v,offsetParent:b,strategy:c}):v);return{top:(y.top-R.top+p.top)/A.y,bottom:(R.bottom-y.bottom+p.bottom)/A.y,left:(y.left-R.left+p.left)/A.x,right:(R.right-y.right+p.right)/A.x}}const R=t=>({name:"arrow",options:t,async fn(e){const{x:n,y:i,placement:r,rects:a,platform:c,elements:m,middlewareData:g}=e,{element:p,padding:h=0}=s(t,e)||{};if(null==p)return{};const y=w(h),x={x:n,y:i},v=d(r),b=u(v),A=await c.getDimensions(p),R="y"===v,P=R?"top":"left",D=R?"bottom":"right",E=R?"clientHeight":"clientWidth",O=a.reference[b]+a.reference[v]-x[v]-a.floating[b],T=x[v]-a.reference[v],L=await(null==c.getOffsetParent?void 0:c.getOffsetParent(p));let k=L?L[E]:0;k&&await(null==c.isElement?void 0:c.isElement(L))||(k=m.floating[E]||a.floating[b]);const B=O/2-T/2,C=k/2-A[b]/2-1,H=o(y[P],C),S=o(y[D],C),F=H,M=k-A[b]-S,V=k/2-A[b]/2+B,W=l(F,V,M),j=!g.arrow&&null!=f(r)&&V!==W&&a.reference[b]/2-(V<F?H:S)-A[b]/2<0,z=j?V<F?V-F:V-M:0;return{[v]:x[v]+z,data:{[v]:W,centerOffset:V-W-z,...j&&{alignmentOffset:z}},reset:j}}});const P=function(t){return void 0===t&&(t={}),{name:"autoPlacement",options:t,async fn(e){var o,i,r;const{rects:a,middlewareData:l,placement:m,platform:u,elements:g}=e,{crossAxis:d=!1,alignment:y,allowedPlacements:w=n,autoAlignment:x=!0,...v}=s(t,e),b=void 0!==y||w===n?function(t,e,n){return(t?[...n.filter((e=>f(e)===t)),...n.filter((e=>f(e)!==t))]:n.filter((t=>c(t)===t))).filter((n=>!t||f(n)===t||!!e&&h(n)!==n))}(y||null,x,w):w,R=await A(e,v),P=(null==(o=l.autoPlacement)?void 0:o.index)||0,D=b[P];if(null==D)return{};const E=p(D,a,await(null==u.isRTL?void 0:u.isRTL(g.floating)));if(m!==D)return{reset:{placement:b[0]}};const O=[R[c(D)],R[E[0]],R[E[1]]],T=[...(null==(i=l.autoPlacement)?void 0:i.overflows)||[],{placement:D,overflowsLine truncated
|
||||
+1153
File diff suppressed because it is too large.
Load diff
+521
@@ -0,0 +1,521 @@
|
||||
import { AlignedPlacement } from '@floating-ui/utils';
|
||||
import { Alignment } from '@floating-ui/utils';
|
||||
import { Axis } from '@floating-ui/utils';
|
||||
import { ClientRectObject } from '@floating-ui/utils';
|
||||
import { Coords } from '@floating-ui/utils';
|
||||
import { Dimensions } from '@floating-ui/utils';
|
||||
import { ElementRects } from '@floating-ui/utils';
|
||||
import { Length } from '@floating-ui/utils';
|
||||
import { Padding } from '@floating-ui/utils';
|
||||
import { Placement } from '@floating-ui/utils';
|
||||
import { Rect } from '@floating-ui/utils';
|
||||
import { rectToClientRect } from '@floating-ui/utils';
|
||||
import { Side } from '@floating-ui/utils';
|
||||
import { SideObject } from '@floating-ui/utils';
|
||||
import { Strategy } from '@floating-ui/utils';
|
||||
import { VirtualElement } from '@floating-ui/utils';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare interface ArrowOptions {
|
||||
/**
|
||||
* The arrow element to be positioned.
|
||||
* @default undefined
|
||||
*/
|
||||
element: any;
|
||||
/**
|
||||
* The padding between the arrow element and the floating element edges.
|
||||
* Useful when the floating element has rounded corners.
|
||||
* @default 0
|
||||
*/
|
||||
padding?: Padding;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
|
||||
|
||||
export declare type AutoPlacementOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether to check for most space along this axis.
|
||||
* @default false
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Choose placements with a particular alignment.
|
||||
* @default undefined
|
||||
*/
|
||||
alignment: Alignment | null;
|
||||
/**
|
||||
* Whether to choose placements with the opposite alignment if the preferred
|
||||
* alignment does not fit.
|
||||
* @default true
|
||||
*/
|
||||
autoAlignment: boolean;
|
||||
/**
|
||||
* Which placements are allowed to be chosen. Placements must be within the
|
||||
* `alignment` option if explicitly set.
|
||||
* @default allPlacements (variable)
|
||||
*/
|
||||
allowedPlacements: Array<Placement>;
|
||||
}>;
|
||||
|
||||
export { Axis }
|
||||
|
||||
export declare type Boundary = any;
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
export declare type ComputePosition = (reference: unknown, floating: unknown, config: ComputePositionConfig) => Promise<ComputePositionReturn>;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*
|
||||
* This export does not have any `platform` interface logic. You will need to
|
||||
* write one for the platform you are using Floating UI with.
|
||||
*/
|
||||
export declare const computePosition: ComputePosition;
|
||||
|
||||
export declare interface ComputePositionConfig {
|
||||
/**
|
||||
* Object to interface with the current platform.
|
||||
*/
|
||||
platform: Platform;
|
||||
/**
|
||||
* Where to place the floating element relative to the reference element.
|
||||
*/
|
||||
placement?: Placement;
|
||||
/**
|
||||
* The strategy to use when positioning the floating element.
|
||||
*/
|
||||
strategy?: Strategy;
|
||||
/**
|
||||
* Array of middleware objects to modify the positioning or provide data for
|
||||
* rendering.
|
||||
*/
|
||||
middleware?: Array<Middleware | null | undefined | false>;
|
||||
}
|
||||
|
||||
export declare interface ComputePositionReturn extends Coords {
|
||||
/**
|
||||
* The final chosen placement of the floating element.
|
||||
*/
|
||||
placement: Placement;
|
||||
/**
|
||||
* The strategy used to position the floating element.
|
||||
*/
|
||||
strategy: Strategy;
|
||||
/**
|
||||
* Object containing data returned from all middleware, keyed by their name.
|
||||
*/
|
||||
middlewareData: MiddlewareData;
|
||||
}
|
||||
|
||||
export { Coords }
|
||||
|
||||
/**
|
||||
* Function option to derive middleware options from state.
|
||||
*/
|
||||
export declare type Derivable<T> = (state: MiddlewareState) => T;
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
export declare function detectOverflow(state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>): Promise<SideObject>;
|
||||
|
||||
export declare type DetectOverflowOptions = Partial<{
|
||||
/**
|
||||
* The clipping element(s) or area in which overflow will be checked.
|
||||
* @default 'clippingAncestors'
|
||||
*/
|
||||
boundary: Boundary;
|
||||
/**
|
||||
* The root clipping area in which overflow will be checked.
|
||||
* @default 'viewport'
|
||||
*/
|
||||
rootBoundary: RootBoundary;
|
||||
/**
|
||||
* The element in which overflow is being checked relative to a boundary.
|
||||
* @default 'floating'
|
||||
*/
|
||||
elementContext: ElementContext;
|
||||
/**
|
||||
* Whether to check for overflow using the alternate element's boundary
|
||||
* (`clippingAncestors` boundary only).
|
||||
* @default false
|
||||
*/
|
||||
altBoundary: boolean;
|
||||
/**
|
||||
* Virtual padding for the resolved overflow detection offsets.
|
||||
* @default 0
|
||||
*/
|
||||
padding: Padding;
|
||||
}>;
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export declare type ElementContext = 'reference' | 'floating';
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export declare interface Elements {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
|
||||
|
||||
export declare type FlipOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform a flip.
|
||||
* @default true
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform a flip.
|
||||
* @default true
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Placements to try sequentially if the preferred `placement` does not fit.
|
||||
* @default [oppositePlacement] (computed)
|
||||
*/
|
||||
fallbackPlacements: Array<Placement>;
|
||||
/**
|
||||
* What strategy to use when no placements fit.
|
||||
* @default 'bestFit'
|
||||
*/
|
||||
fallbackStrategy: 'bestFit' | 'initialPlacement';
|
||||
/**
|
||||
* Whether to allow fallback to the perpendicular axis of the preferred
|
||||
* placement, and if so, which side direction along the axis to prefer.
|
||||
* @default 'none' (disallow fallback)
|
||||
*/
|
||||
fallbackAxisSideDirection: 'none' | 'start' | 'end';
|
||||
/**
|
||||
* Whether to flip to placements with the opposite alignment if they fit
|
||||
* better.
|
||||
* @default true
|
||||
*/
|
||||
flipAlignment: boolean;
|
||||
}>;
|
||||
|
||||
export declare type FloatingElement = any;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
|
||||
|
||||
export declare type HideOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The strategy used to determine when to hide the floating element.
|
||||
*/
|
||||
strategy: 'referenceHidden' | 'escaped';
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
|
||||
|
||||
export declare type InlineOptions = Partial<{
|
||||
/**
|
||||
* Viewport-relative `x` coordinate to choose a `ClientRect`.
|
||||
* @default undefined
|
||||
*/
|
||||
x: number;
|
||||
/**
|
||||
* Viewport-relative `y` coordinate to choose a `ClientRect`.
|
||||
* @default undefined
|
||||
*/
|
||||
y: number;
|
||||
/**
|
||||
* Represents the padding around a disjoined rect when choosing it.
|
||||
* @default 2
|
||||
*/
|
||||
padding: Padding;
|
||||
}>;
|
||||
|
||||
export { Length }
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
|
||||
options: any;
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
};
|
||||
|
||||
declare type LimitShiftOffset = number | Partial<{
|
||||
/**
|
||||
* Offset the limiting of the axis that runs along the alignment of the
|
||||
* floating element.
|
||||
*/
|
||||
mainAxis: number;
|
||||
/**
|
||||
* Offset the limiting of the axis that runs along the side of the
|
||||
* floating element.
|
||||
*/
|
||||
crossAxis: number;
|
||||
}>;
|
||||
|
||||
export declare type LimitShiftOptions = Partial<{
|
||||
/**
|
||||
* Offset when limiting starts. `0` will limit when the opposite edges of the
|
||||
* reference and floating elements are aligned.
|
||||
* - positive = start limiting earlier
|
||||
* - negative = start limiting later
|
||||
*/
|
||||
offset: LimitShiftOffset | Derivable<LimitShiftOffset>;
|
||||
/**
|
||||
* Whether to limit the axis that runs along the alignment of the floating
|
||||
* element.
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* Whether to limit the axis that runs along the side of the floating element.
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
}>;
|
||||
|
||||
export declare type Middleware = {
|
||||
name: string;
|
||||
options?: any;
|
||||
fn: (state: MiddlewareState) => Promisable<MiddlewareReturn>;
|
||||
};
|
||||
|
||||
/**
|
||||
* @deprecated use `MiddlewareState` instead.
|
||||
*/
|
||||
export declare type MiddlewareArguments = MiddlewareState;
|
||||
|
||||
export declare interface MiddlewareData {
|
||||
[key: string]: any;
|
||||
arrow?: Partial<Coords> & {
|
||||
centerOffset: number;
|
||||
alignmentOffset?: number;
|
||||
};
|
||||
autoPlacement?: {
|
||||
index?: number;
|
||||
overflows: Array<{
|
||||
placement: Placement;
|
||||
overflows: Array<number>;
|
||||
}>;
|
||||
};
|
||||
flip?: {
|
||||
index?: number;
|
||||
overflows: Array<{
|
||||
placement: Placement;
|
||||
overflows: Array<number>;
|
||||
}>;
|
||||
};
|
||||
hide?: {
|
||||
referenceHidden?: boolean;
|
||||
escaped?: boolean;
|
||||
referenceHiddenOffsets?: SideObject;
|
||||
escapedOffsets?: SideObject;
|
||||
};
|
||||
offset?: Coords & {
|
||||
placement: Placement;
|
||||
};
|
||||
shift?: Coords;
|
||||
}
|
||||
|
||||
export declare interface MiddlewareReturn extends Partial<Coords> {
|
||||
data?: {
|
||||
[key: string]: any;
|
||||
};
|
||||
reset?: boolean | {
|
||||
placement?: Placement;
|
||||
rects?: boolean | ElementRects;
|
||||
};
|
||||
}
|
||||
|
||||
export declare interface MiddlewareState extends Coords {
|
||||
initialPlacement: Placement;
|
||||
placement: Placement;
|
||||
strategy: Strategy;
|
||||
middlewareData: MiddlewareData;
|
||||
elements: Elements;
|
||||
rects: ElementRects;
|
||||
platform: Platform;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
export declare const offset: (options?: OffsetOptions) => Middleware;
|
||||
|
||||
export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
|
||||
|
||||
declare type OffsetValue = number | Partial<{
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Represents
|
||||
* the distance (gutter or margin) between the reference and floating
|
||||
* element.
|
||||
* @default 0
|
||||
*/
|
||||
mainAxis: number;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element.
|
||||
* Represents the skidding between the reference and floating element.
|
||||
* @default 0
|
||||
*/
|
||||
crossAxis: number;
|
||||
/**
|
||||
* The same axis as `crossAxis` but applies only to aligned placements
|
||||
* and inverts the `end` alignment. When set to a number, it overrides the
|
||||
* `crossAxis` value.
|
||||
*
|
||||
* A positive number will move the floating element in the direction of
|
||||
* the opposite edge to the one that is aligned, while a negative number
|
||||
* the reverse.
|
||||
* @default null
|
||||
*/
|
||||
alignmentAxis: number | null;
|
||||
}>;
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
/**
|
||||
* Platform interface methods to work with the current platform.
|
||||
* @see https://floating-ui.com/docs/platform
|
||||
*/
|
||||
export declare interface Platform {
|
||||
getElementRects: (args: {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<ElementRects>;
|
||||
getClippingRect: (args: {
|
||||
element: any;
|
||||
boundary: Boundary;
|
||||
rootBoundary: RootBoundary;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getDimensions: (element: any) => Promisable<Dimensions>;
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect?: (args: {
|
||||
elements?: Elements;
|
||||
rect: Rect;
|
||||
offsetParent: any;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getOffsetParent?: (element: any) => Promisable<any>;
|
||||
isElement?: (value: any) => Promisable<boolean>;
|
||||
getDocumentElement?: (element: any) => Promisable<any>;
|
||||
getClientRects?: (element: any) => Promisable<Array<ClientRectObject>>;
|
||||
isRTL?: (element: any) => Promisable<boolean>;
|
||||
getScale?: (element: any) => Promisable<{
|
||||
x: number;
|
||||
y: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
declare type Promisable<T> = T | Promise<T>;
|
||||
|
||||
export { Rect }
|
||||
|
||||
export { rectToClientRect }
|
||||
|
||||
export declare type ReferenceElement = any;
|
||||
|
||||
export declare type RootBoundary = 'viewport' | 'document' | Rect;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
|
||||
|
||||
export declare type ShiftOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform shifting.
|
||||
* @default true
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform shifting.
|
||||
* @default false
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Accepts a function that limits the shifting done in order to prevent
|
||||
* detachment.
|
||||
*/
|
||||
limiter: {
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
options?: any;
|
||||
};
|
||||
}>;
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
|
||||
|
||||
export declare type SizeOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* Function that is called to perform style mutations to the floating element
|
||||
* to change its size.
|
||||
* @default undefined
|
||||
*/
|
||||
apply(args: MiddlewareState & {
|
||||
availableWidth: number;
|
||||
availableHeight: number;
|
||||
}): void | Promise<void>;
|
||||
}>;
|
||||
|
||||
export { Strategy }
|
||||
|
||||
export { VirtualElement }
|
||||
|
||||
export { }
|
||||
+521
@@ -0,0 +1,521 @@
|
||||
import { AlignedPlacement } from '@floating-ui/utils';
|
||||
import { Alignment } from '@floating-ui/utils';
|
||||
import { Axis } from '@floating-ui/utils';
|
||||
import { ClientRectObject } from '@floating-ui/utils';
|
||||
import { Coords } from '@floating-ui/utils';
|
||||
import { Dimensions } from '@floating-ui/utils';
|
||||
import { ElementRects } from '@floating-ui/utils';
|
||||
import { Length } from '@floating-ui/utils';
|
||||
import { Padding } from '@floating-ui/utils';
|
||||
import { Placement } from '@floating-ui/utils';
|
||||
import { Rect } from '@floating-ui/utils';
|
||||
import { rectToClientRect } from '@floating-ui/utils';
|
||||
import { Side } from '@floating-ui/utils';
|
||||
import { SideObject } from '@floating-ui/utils';
|
||||
import { Strategy } from '@floating-ui/utils';
|
||||
import { VirtualElement } from '@floating-ui/utils';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare interface ArrowOptions {
|
||||
/**
|
||||
* The arrow element to be positioned.
|
||||
* @default undefined
|
||||
*/
|
||||
element: any;
|
||||
/**
|
||||
* The padding between the arrow element and the floating element edges.
|
||||
* Useful when the floating element has rounded corners.
|
||||
* @default 0
|
||||
*/
|
||||
padding?: Padding;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
|
||||
|
||||
export declare type AutoPlacementOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether to check for most space along this axis.
|
||||
* @default false
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Choose placements with a particular alignment.
|
||||
* @default undefined
|
||||
*/
|
||||
alignment: Alignment | null;
|
||||
/**
|
||||
* Whether to choose placements with the opposite alignment if the preferred
|
||||
* alignment does not fit.
|
||||
* @default true
|
||||
*/
|
||||
autoAlignment: boolean;
|
||||
/**
|
||||
* Which placements are allowed to be chosen. Placements must be within the
|
||||
* `alignment` option if explicitly set.
|
||||
* @default allPlacements (variable)
|
||||
*/
|
||||
allowedPlacements: Array<Placement>;
|
||||
}>;
|
||||
|
||||
export { Axis }
|
||||
|
||||
export declare type Boundary = any;
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
export declare type ComputePosition = (reference: unknown, floating: unknown, config: ComputePositionConfig) => Promise<ComputePositionReturn>;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*
|
||||
* This export does not have any `platform` interface logic. You will need to
|
||||
* write one for the platform you are using Floating UI with.
|
||||
*/
|
||||
export declare const computePosition: ComputePosition;
|
||||
|
||||
export declare interface ComputePositionConfig {
|
||||
/**
|
||||
* Object to interface with the current platform.
|
||||
*/
|
||||
platform: Platform;
|
||||
/**
|
||||
* Where to place the floating element relative to the reference element.
|
||||
*/
|
||||
placement?: Placement;
|
||||
/**
|
||||
* The strategy to use when positioning the floating element.
|
||||
*/
|
||||
strategy?: Strategy;
|
||||
/**
|
||||
* Array of middleware objects to modify the positioning or provide data for
|
||||
* rendering.
|
||||
*/
|
||||
middleware?: Array<Middleware | null | undefined | false>;
|
||||
}
|
||||
|
||||
export declare interface ComputePositionReturn extends Coords {
|
||||
/**
|
||||
* The final chosen placement of the floating element.
|
||||
*/
|
||||
placement: Placement;
|
||||
/**
|
||||
* The strategy used to position the floating element.
|
||||
*/
|
||||
strategy: Strategy;
|
||||
/**
|
||||
* Object containing data returned from all middleware, keyed by their name.
|
||||
*/
|
||||
middlewareData: MiddlewareData;
|
||||
}
|
||||
|
||||
export { Coords }
|
||||
|
||||
/**
|
||||
* Function option to derive middleware options from state.
|
||||
*/
|
||||
export declare type Derivable<T> = (state: MiddlewareState) => T;
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
export declare function detectOverflow(state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>): Promise<SideObject>;
|
||||
|
||||
export declare type DetectOverflowOptions = Partial<{
|
||||
/**
|
||||
* The clipping element(s) or area in which overflow will be checked.
|
||||
* @default 'clippingAncestors'
|
||||
*/
|
||||
boundary: Boundary;
|
||||
/**
|
||||
* The root clipping area in which overflow will be checked.
|
||||
* @default 'viewport'
|
||||
*/
|
||||
rootBoundary: RootBoundary;
|
||||
/**
|
||||
* The element in which overflow is being checked relative to a boundary.
|
||||
* @default 'floating'
|
||||
*/
|
||||
elementContext: ElementContext;
|
||||
/**
|
||||
* Whether to check for overflow using the alternate element's boundary
|
||||
* (`clippingAncestors` boundary only).
|
||||
* @default false
|
||||
*/
|
||||
altBoundary: boolean;
|
||||
/**
|
||||
* Virtual padding for the resolved overflow detection offsets.
|
||||
* @default 0
|
||||
*/
|
||||
padding: Padding;
|
||||
}>;
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export declare type ElementContext = 'reference' | 'floating';
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export declare interface Elements {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
|
||||
|
||||
export declare type FlipOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform a flip.
|
||||
* @default true
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform a flip.
|
||||
* @default true
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Placements to try sequentially if the preferred `placement` does not fit.
|
||||
* @default [oppositePlacement] (computed)
|
||||
*/
|
||||
fallbackPlacements: Array<Placement>;
|
||||
/**
|
||||
* What strategy to use when no placements fit.
|
||||
* @default 'bestFit'
|
||||
*/
|
||||
fallbackStrategy: 'bestFit' | 'initialPlacement';
|
||||
/**
|
||||
* Whether to allow fallback to the perpendicular axis of the preferred
|
||||
* placement, and if so, which side direction along the axis to prefer.
|
||||
* @default 'none' (disallow fallback)
|
||||
*/
|
||||
fallbackAxisSideDirection: 'none' | 'start' | 'end';
|
||||
/**
|
||||
* Whether to flip to placements with the opposite alignment if they fit
|
||||
* better.
|
||||
* @default true
|
||||
*/
|
||||
flipAlignment: boolean;
|
||||
}>;
|
||||
|
||||
export declare type FloatingElement = any;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
|
||||
|
||||
export declare type HideOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The strategy used to determine when to hide the floating element.
|
||||
*/
|
||||
strategy: 'referenceHidden' | 'escaped';
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
|
||||
|
||||
export declare type InlineOptions = Partial<{
|
||||
/**
|
||||
* Viewport-relative `x` coordinate to choose a `ClientRect`.
|
||||
* @default undefined
|
||||
*/
|
||||
x: number;
|
||||
/**
|
||||
* Viewport-relative `y` coordinate to choose a `ClientRect`.
|
||||
* @default undefined
|
||||
*/
|
||||
y: number;
|
||||
/**
|
||||
* Represents the padding around a disjoined rect when choosing it.
|
||||
* @default 2
|
||||
*/
|
||||
padding: Padding;
|
||||
}>;
|
||||
|
||||
export { Length }
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
|
||||
options: any;
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
};
|
||||
|
||||
declare type LimitShiftOffset = number | Partial<{
|
||||
/**
|
||||
* Offset the limiting of the axis that runs along the alignment of the
|
||||
* floating element.
|
||||
*/
|
||||
mainAxis: number;
|
||||
/**
|
||||
* Offset the limiting of the axis that runs along the side of the
|
||||
* floating element.
|
||||
*/
|
||||
crossAxis: number;
|
||||
}>;
|
||||
|
||||
export declare type LimitShiftOptions = Partial<{
|
||||
/**
|
||||
* Offset when limiting starts. `0` will limit when the opposite edges of the
|
||||
* reference and floating elements are aligned.
|
||||
* - positive = start limiting earlier
|
||||
* - negative = start limiting later
|
||||
*/
|
||||
offset: LimitShiftOffset | Derivable<LimitShiftOffset>;
|
||||
/**
|
||||
* Whether to limit the axis that runs along the alignment of the floating
|
||||
* element.
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* Whether to limit the axis that runs along the side of the floating element.
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
}>;
|
||||
|
||||
export declare type Middleware = {
|
||||
name: string;
|
||||
options?: any;
|
||||
fn: (state: MiddlewareState) => Promisable<MiddlewareReturn>;
|
||||
};
|
||||
|
||||
/**
|
||||
* @deprecated use `MiddlewareState` instead.
|
||||
*/
|
||||
export declare type MiddlewareArguments = MiddlewareState;
|
||||
|
||||
export declare interface MiddlewareData {
|
||||
[key: string]: any;
|
||||
arrow?: Partial<Coords> & {
|
||||
centerOffset: number;
|
||||
alignmentOffset?: number;
|
||||
};
|
||||
autoPlacement?: {
|
||||
index?: number;
|
||||
overflows: Array<{
|
||||
placement: Placement;
|
||||
overflows: Array<number>;
|
||||
}>;
|
||||
};
|
||||
flip?: {
|
||||
index?: number;
|
||||
overflows: Array<{
|
||||
placement: Placement;
|
||||
overflows: Array<number>;
|
||||
}>;
|
||||
};
|
||||
hide?: {
|
||||
referenceHidden?: boolean;
|
||||
escaped?: boolean;
|
||||
referenceHiddenOffsets?: SideObject;
|
||||
escapedOffsets?: SideObject;
|
||||
};
|
||||
offset?: Coords & {
|
||||
placement: Placement;
|
||||
};
|
||||
shift?: Coords;
|
||||
}
|
||||
|
||||
export declare interface MiddlewareReturn extends Partial<Coords> {
|
||||
data?: {
|
||||
[key: string]: any;
|
||||
};
|
||||
reset?: boolean | {
|
||||
placement?: Placement;
|
||||
rects?: boolean | ElementRects;
|
||||
};
|
||||
}
|
||||
|
||||
export declare interface MiddlewareState extends Coords {
|
||||
initialPlacement: Placement;
|
||||
placement: Placement;
|
||||
strategy: Strategy;
|
||||
middlewareData: MiddlewareData;
|
||||
elements: Elements;
|
||||
rects: ElementRects;
|
||||
platform: Platform;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
export declare const offset: (options?: OffsetOptions) => Middleware;
|
||||
|
||||
export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
|
||||
|
||||
declare type OffsetValue = number | Partial<{
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Represents
|
||||
* the distance (gutter or margin) between the reference and floating
|
||||
* element.
|
||||
* @default 0
|
||||
*/
|
||||
mainAxis: number;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element.
|
||||
* Represents the skidding between the reference and floating element.
|
||||
* @default 0
|
||||
*/
|
||||
crossAxis: number;
|
||||
/**
|
||||
* The same axis as `crossAxis` but applies only to aligned placements
|
||||
* and inverts the `end` alignment. When set to a number, it overrides the
|
||||
* `crossAxis` value.
|
||||
*
|
||||
* A positive number will move the floating element in the direction of
|
||||
* the opposite edge to the one that is aligned, while a negative number
|
||||
* the reverse.
|
||||
* @default null
|
||||
*/
|
||||
alignmentAxis: number | null;
|
||||
}>;
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
/**
|
||||
* Platform interface methods to work with the current platform.
|
||||
* @see https://floating-ui.com/docs/platform
|
||||
*/
|
||||
export declare interface Platform {
|
||||
getElementRects: (args: {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<ElementRects>;
|
||||
getClippingRect: (args: {
|
||||
element: any;
|
||||
boundary: Boundary;
|
||||
rootBoundary: RootBoundary;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getDimensions: (element: any) => Promisable<Dimensions>;
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect?: (args: {
|
||||
elements?: Elements;
|
||||
rect: Rect;
|
||||
offsetParent: any;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getOffsetParent?: (element: any) => Promisable<any>;
|
||||
isElement?: (value: any) => Promisable<boolean>;
|
||||
getDocumentElement?: (element: any) => Promisable<any>;
|
||||
getClientRects?: (element: any) => Promisable<Array<ClientRectObject>>;
|
||||
isRTL?: (element: any) => Promisable<boolean>;
|
||||
getScale?: (element: any) => Promisable<{
|
||||
x: number;
|
||||
y: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
declare type Promisable<T> = T | Promise<T>;
|
||||
|
||||
export { Rect }
|
||||
|
||||
export { rectToClientRect }
|
||||
|
||||
export declare type ReferenceElement = any;
|
||||
|
||||
export declare type RootBoundary = 'viewport' | 'document' | Rect;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
|
||||
|
||||
export declare type ShiftOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform shifting.
|
||||
* @default true
|
||||
*/
|
||||
mainAxis: boolean;
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Determines
|
||||
* whether overflow along this axis is checked to perform shifting.
|
||||
* @default false
|
||||
*/
|
||||
crossAxis: boolean;
|
||||
/**
|
||||
* Accepts a function that limits the shifting done in order to prevent
|
||||
* detachment.
|
||||
*/
|
||||
limiter: {
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
options?: any;
|
||||
};
|
||||
}>;
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
|
||||
|
||||
export declare type SizeOptions = Partial<DetectOverflowOptions & {
|
||||
/**
|
||||
* Function that is called to perform style mutations to the floating element
|
||||
* to change its size.
|
||||
* @default undefined
|
||||
*/
|
||||
apply(args: MiddlewareState & {
|
||||
availableWidth: number;
|
||||
availableHeight: number;
|
||||
}): void | Promise<void>;
|
||||
}>;
|
||||
|
||||
export { Strategy }
|
||||
|
||||
export { VirtualElement }
|
||||
|
||||
export { }
|
||||
+1025
File diff suppressed because it is too large.
Load diff
+1025
File diff suppressed because it is too large.
Load diff
+1172
File diff suppressed because it is too large.
Load diff
+1
@@ -0,0 +1 @@
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).FloatingUICore={})}(this,(function(t){"use strict";const e=["top","right","bottom","left"],n=["start","end"],i=e.reduce(((t,e)=>t.concat(e,e+"-"+n[0],e+"-"+n[1])),[]),o=Math.min,r=Math.max,a={left:"right",right:"left",bottom:"top",top:"bottom"},l={start:"end",end:"start"};function s(t,e,n){return r(t,o(e,n))}function f(t,e){return"function"==typeof t?t(e):t}function c(t){return t.split("-")[0]}function u(t){return t.split("-")[1]}function m(t){return"x"===t?"y":"x"}function d(t){return"y"===t?"height":"width"}function g(t){return["top","bottom"].includes(c(t))?"y":"x"}function p(t){return m(g(t))}function h(t,e,n){void 0===n&&(n=!1);const i=u(t),o=p(t),r=d(o);let a="x"===o?i===(n?"end":"start")?"right":"left":"start"===i?"bottom":"top";return e.reference[r]>e.floating[r]&&(a=w(a)),[a,w(a)]}function y(t){return t.replace(/start|end/g,(t=>l[t]))}function w(t){return t.replace(/left|right|bottom|top/g,(t=>a[t]))}function x(t){return"number"!=typeof t?function(t){return{top:0,right:0,bottom:0,left:0,...t}}(t):{top:t,right:t,bottom:t,left:t}}function v(t){const{x:e,y:n,width:i,height:o}=t;return{width:i,height:o,top:n,left:e,right:e+i,bottom:n+o,x:e,y:n}}function b(t,e,n){let{reference:i,floating:o}=t;const r=g(e),a=p(e),l=d(a),s=c(e),f="y"===r,m=i.x+i.width/2-o.width/2,h=i.y+i.height/2-o.height/2,y=i[l]/2-o[l]/2;let w;switch(s){case"top":w={x:m,y:i.y-o.height};break;case"bottom":w={x:m,y:i.y+i.height};break;case"right":w={x:i.x+i.width,y:h};break;case"left":w={x:i.x-o.width,y:h};break;default:w={x:i.x,y:i.y}}switch(u(e)){case"start":w[a]-=y*(n&&f?-1:1);break;case"end":w[a]+=y*(n&&f?-1:1)}return w}async function A(t,e){var n;void 0===e&&(e={});const{x:i,y:o,platform:r,rects:a,elements:l,strategy:s}=t,{boundary:c="clippingAncestors",rootBoundary:u="viewport",elementContext:m="floating",altBoundary:d=!1,padding:g=0}=f(e,t),p=x(g),h=l[d?"floating"===m?"reference":"floating":m],y=v(await r.getClippingRect({element:null==(n=await(null==r.isElement?void 0:r.isElement(h)))||n?h:h.contextElement||await(null==r.getDocumentElement?void 0:r.getDocumentElement(l.floating)),boundary:c,rootBoundary:u,strategy:s})),w="floating"===m?{x:i,y:o,width:a.floating.width,height:a.floating.height}:a.reference,b=await(null==r.getOffsetParent?void 0:r.getOffsetParent(l.floating)),A=await(null==r.isElement?void 0:r.isElement(b))&&await(null==r.getScale?void 0:r.getScale(b))||{x:1,y:1},R=v(r.convertOffsetParentRelativeRectToViewportRelativeRect?await r.convertOffsetParentRelativeRectToViewportRelativeRect({elements:l,rect:w,offsetParent:b,strategy:s}):w);return{top:(y.top-R.top+p.top)/A.y,bottom:(R.bottom-y.bottom+p.bottom)/A.y,left:(y.left-R.left+p.left)/A.x,right:(R.right-y.right+p.right)/A.x}}function R(t,e){return{top:t.top-e.height,right:t.right-e.width,bottom:t.bottom-e.height,left:t.left-e.width}}function P(t){return e.some((e=>t[e]>=0))}function T(t){const e=o(...t.map((t=>t.left))),n=o(...t.map((t=>t.top)));return{x:e,y:n,width:r(...t.map((t=>t.right)))-e,height:r(...t.map((t=>t.bottom)))-n}}t.arrow=t=>({name:"arrow",options:t,async fn(e){const{x:n,y:i,placement:r,rects:a,platform:l,elements:c,middlewareData:m}=e,{element:g,padding:h=0}=f(t,e)||{};if(null==g)return{};const y=x(h),w={x:n,y:i},v=p(r),b=d(v),A=await l.getDimensions(g),R="y"===v,P=R?"top":"left",T=R?"bottom":"right",D=R?"clientHeight":"clientWidth",O=a.reference[b]+a.reference[v]-w[v]-a.floating[b],E=w[v]-a.reference[v],L=await(null==l.getOffsetParent?void 0:l.getOffsetParent(g));let k=L?L[D]:0;k&&await(null==l.isElement?void 0:l.isElement(L))||(k=c.floating[D]||a.floating[b]);const C=O/2-E/2,B=k/2-A[b]/2-1,H=o(y[P],B),S=o(y[T],B),F=H,j=k-A[b]-S,z=k/2-A[b]/2+C,M=s(F,z,j),V=!m.arrow&&null!=u(r)&&z!==M&&a.reference[b]/2-(z<F?H:S)-A[b]/2<0,W=V?z<F?z-F:z-j:0;return{[v]:w[v]+W,data:{[v]:M,centerOffset:z-M-W,...V&&{alignmentOffset:W}},reset:V}}}),t.autoPlacement=function(t){return void 0===t&&(t={}),{name:"autoPlacement",options:t,async fn(e){var n,o,r;const{rects:a,middlewareData:l,placement:s,platform:m,elements:d}=e,{crossAxis:g=!1,alignment:p,allowedPlacements:w=i,autoAlignment:x=!0,...v}=f(t,e),b=void 0!==p||w===i?function(t,e,n){return(t?[...n.filter((e=>u(e)===t)),...n.filter((e=>u(e)!==t))]:n.filter((t=>c(t)===t))).filter((n=>!t||u(n)===t||!!e&&y(n)!==n))}(p||null,x,w):w,R=await A(e,v),P=(null==(n=l.autoPlacement)?void 0:n.index)||0,T=b[P];if(null==T)return{};const D=h(T,a,await(null==m.isRTL?void 0:m.isRTL(d.floating)));if(s!==T)return{reset:{placement:b[0]}};const O=[R[c(T)],R[D[0]],R[D[1]]],E=[...(null==(o=l.autoPlacement)?void 0:o.overflows)||[],{placement:T,overflows:O}],L=b[P+1];if(L)return{data:{index:P+1,overflows:E},reset:{placement:L}};const k=E.map((t=>{const e=u(t.placement);return[t.placement,e&&g?t.overflows.slice(0,2).reduce(((t,e)=>t+e),0):t.overflows[0],t.oLine truncated
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
{
|
||||
"name": "@floating-ui/core",
|
||||
"version": "1.6.1",
|
||||
"description": "Positioning library for floating elements: tooltips, popovers, dropdowns, and more",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "./dist/floating-ui.core.umd.js",
|
||||
"module": "./dist/floating-ui.core.esm.js",
|
||||
"unpkg": "./dist/floating-ui.core.umd.min.js",
|
||||
"types": "./dist/floating-ui.core.d.ts",
|
||||
"exports": {
|
||||
"./package.json": "./package.json",
|
||||
".": {
|
||||
"import": {
|
||||
"types": "./dist/floating-ui.core.d.mts",
|
||||
"default": "./dist/floating-ui.core.mjs"
|
||||
},
|
||||
"types": "./dist/floating-ui.core.d.ts",
|
||||
"module": "./dist/floating-ui.core.esm.js",
|
||||
"default": "./dist/floating-ui.core.umd.js"
|
||||
}
|
||||
},
|
||||
"sideEffects": false,
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"author": "atomiks",
|
||||
"license": "MIT",
|
||||
"bugs": "https://github.com/floating-ui/floating-ui",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/floating-ui/floating-ui.git",
|
||||
"directory": "packages/core"
|
||||
},
|
||||
"homepage": "https://floating-ui.com",
|
||||
"keywords": [
|
||||
"tooltip",
|
||||
"popover",
|
||||
"dropdown",
|
||||
"menu",
|
||||
"popup",
|
||||
"positioning"
|
||||
],
|
||||
"dependencies": {
|
||||
"@floating-ui/utils": "^0.2.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"config": "0.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "vitest run",
|
||||
"test:watch": "vitest watch",
|
||||
"lint": "eslint .",
|
||||
"format": "prettier --write .",
|
||||
"clean": "rimraf dist out-tsc",
|
||||
"dev": "rollup -c -w",
|
||||
"build": "rollup -c",
|
||||
"build:api": "build-api --tsc tsconfig.lib.json",
|
||||
"publint": "publint",
|
||||
"typecheck": "tsc -b"
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2021-present Floating UI contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
# @floating-ui/dom
|
||||
|
||||
This is the library to use Floating UI on the web, wrapping `@floating-ui/core`
|
||||
with DOM interface logic.
|
||||
+1
@@ -0,0 +1 @@
|
||||
import{rectToClientRect as t,detectOverflow as e,offset as n,autoPlacement as o,shift as i,flip as r,size as c,hide as l,arrow as s,inline as f,limitShift as u,computePosition as a}from"@floating-ui/core";const d=Math.min,h=Math.max,p=Math.round,m=Math.floor,g=t=>({x:t,y:t});function y(t){return x(t)?(t.nodeName||"").toLowerCase():"#document"}function w(t){var e;return(null==t||null==(e=t.ownerDocument)?void 0:e.defaultView)||window}function v(t){var e;return null==(e=(x(t)?t.ownerDocument:t.document)||window.document)?void 0:e.documentElement}function x(t){return t instanceof Node||t instanceof w(t).Node}function b(t){return t instanceof Element||t instanceof w(t).Element}function L(t){return t instanceof HTMLElement||t instanceof w(t).HTMLElement}function T(t){return"undefined"!=typeof ShadowRoot&&(t instanceof ShadowRoot||t instanceof w(t).ShadowRoot)}function R(t){const{overflow:e,overflowX:n,overflowY:o,display:i}=O(t);return/auto|scroll|overlay|hidden|clip/.test(e+o+n)&&!["inline","contents"].includes(i)}function E(t){return["table","td","th"].includes(y(t))}function S(t){const e=C(),n=O(t);return"none"!==n.transform||"none"!==n.perspective||!!n.containerType&&"normal"!==n.containerType||!e&&!!n.backdropFilter&&"none"!==n.backdropFilter||!e&&!!n.filter&&"none"!==n.filter||["transform","perspective","filter"].some((t=>(n.willChange||"").includes(t)))||["paint","layout","strict","content"].some((t=>(n.contain||"").includes(t)))}function C(){return!("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function F(t){return["html","body","#document"].includes(y(t))}function O(t){return w(t).getComputedStyle(t)}function D(t){return b(t)?{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}:{scrollLeft:t.pageXOffset,scrollTop:t.pageYOffset}}function H(t){if("html"===y(t))return t;const e=t.assignedSlot||t.parentNode||T(t)&&t.host||v(t);return T(e)?e.host:e}function W(t){const e=H(t);return F(e)?t.ownerDocument?t.ownerDocument.body:t.body:L(e)&&R(e)?e:W(e)}function M(t,e,n){var o;void 0===e&&(e=[]),void 0===n&&(n=!0);const i=W(t),r=i===(null==(o=t.ownerDocument)?void 0:o.body),c=w(i);return r?e.concat(c,c.visualViewport||[],R(i)?i:[],c.frameElement&&n?M(c.frameElement):[]):e.concat(i,M(i,[],n))}function z(t){const e=O(t);let n=parseFloat(e.width)||0,o=parseFloat(e.height)||0;const i=L(t),r=i?t.offsetWidth:n,c=i?t.offsetHeight:o,l=p(n)!==r||p(o)!==c;return l&&(n=r,o=c),{width:n,height:o,$:l}}function P(t){return b(t)?t:t.contextElement}function V(t){const e=P(t);if(!L(e))return g(1);const n=e.getBoundingClientRect(),{width:o,height:i,$:r}=z(e);let c=(r?p(n.width):n.width)/o,l=(r?p(n.height):n.height)/i;return c&&Number.isFinite(c)||(c=1),l&&Number.isFinite(l)||(l=1),{x:c,y:l}}const A=g(0);function N(t){const e=w(t);return C()&&e.visualViewport?{x:e.visualViewport.offsetLeft,y:e.visualViewport.offsetTop}:A}function B(e,n,o,i){void 0===n&&(n=!1),void 0===o&&(o=!1);const r=e.getBoundingClientRect(),c=P(e);let l=g(1);n&&(i?b(i)&&(l=V(i)):l=V(e));const s=function(t,e,n){return void 0===e&&(e=!1),!(!n||e&&n!==w(t))&&e}(c,o,i)?N(c):g(0);let f=(r.left+s.x)/l.x,u=(r.top+s.y)/l.y,a=r.width/l.x,d=r.height/l.y;if(c){const t=w(c),e=i&&b(i)?w(i):i;let n=t,o=n.frameElement;for(;o&&i&&e!==n;){const t=V(o),e=o.getBoundingClientRect(),i=O(o),r=e.left+(o.clientLeft+parseFloat(i.paddingLeft))*t.x,c=e.top+(o.clientTop+parseFloat(i.paddingTop))*t.y;f*=t.x,u*=t.y,a*=t.x,d*=t.y,f+=r,u+=c,n=w(o),o=n.frameElement}}return t({width:a,height:d,x:f,y:u})}const k=[":popover-open",":modal"];function I(t){return k.some((e=>{try{return t.matches(e)}catch(t){return!1}}))}function q(t){return B(v(t)).left+D(t).scrollLeft}function X(e,n,o){let i;if("viewport"===n)i=function(t,e){const n=w(t),o=v(t),i=n.visualViewport;let r=o.clientWidth,c=o.clientHeight,l=0,s=0;if(i){r=i.width,c=i.height;const t=C();(!t||t&&"fixed"===e)&&(l=i.offsetLeft,s=i.offsetTop)}return{width:r,height:c,x:l,y:s}}(e,o);else if("document"===n)i=function(t){const e=v(t),n=D(t),o=t.ownerDocument.body,i=h(e.scrollWidth,e.clientWidth,o.scrollWidth,o.clientWidth),r=h(e.scrollHeight,e.clientHeight,o.scrollHeight,o.clientHeight);let c=-n.scrollLeft+q(t);const l=-n.scrollTop;return"rtl"===O(o).direction&&(c+=h(e.clientWidth,o.clientWidth)-i),{width:i,height:r,x:c,y:l}}(v(e));else if(b(n))i=function(t,e){const n=B(t,!0,"fixed"===e),o=n.top+t.clientTop,i=n.left+t.clientLeft,r=L(t)?V(t):g(1);return{width:t.clientWidth*r.x,height:t.clientHeight*r.y,x:i*r.x,y:o*r.y}}(n,o);else{const t=N(e);i={...n,x:n.x-t.x,y:n.y-t.y}}return t(i)}function Y(t,e){const n=H(t);return!(n===e||!b(n)||F(n))&&("fixed"===O(n).position||Y(n,e))}function $(t,e,n){const o=L(e),i=v(e),r="fixed"===n,c=B(t,!0,r,e);let l={scrollLeft:0,scrollTop:0};const s=g(0);if(o||!o&&!r)if(("body"!==y(e)||R(i))&&(l=D(e)),o){const t=B(e,!0,r,e);s.x=t.x+e.clientLeft,s.y=t.y+e.clientTop}else i&&(s.x=q(i));return{x:c.left+l.scrollLeft-s.x,y:c.top+l.scrollTop-s.y,width:c.width,height:c.height}}function _(t){rLine truncated
|
||||
+852
@@ -0,0 +1,852 @@
|
||||
import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
|
||||
const min = Math.min;
|
||||
const max = Math.max;
|
||||
const round = Math.round;
|
||||
const floor = Math.floor;
|
||||
const createCoords = v => ({
|
||||
x: v,
|
||||
y: v
|
||||
});
|
||||
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
function getCssDimensions(element) {
|
||||
const css = getComputedStyle(element);
|
||||
// In testing environments, the `width` and `height` properties are empty
|
||||
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
|
||||
let width = parseFloat(css.width) || 0;
|
||||
let height = parseFloat(css.height) || 0;
|
||||
const hasOffset = isHTMLElement(element);
|
||||
const offsetWidth = hasOffset ? element.offsetWidth : width;
|
||||
const offsetHeight = hasOffset ? element.offsetHeight : height;
|
||||
const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
|
||||
if (shouldFallback) {
|
||||
width = offsetWidth;
|
||||
height = offsetHeight;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
$: shouldFallback
|
||||
};
|
||||
}
|
||||
|
||||
function unwrapElement(element) {
|
||||
return !isElement(element) ? element.contextElement : element;
|
||||
}
|
||||
|
||||
function getScale(element) {
|
||||
const domElement = unwrapElement(element);
|
||||
if (!isHTMLElement(domElement)) {
|
||||
return createCoords(1);
|
||||
}
|
||||
const rect = domElement.getBoundingClientRect();
|
||||
const {
|
||||
width,
|
||||
height,
|
||||
$
|
||||
} = getCssDimensions(domElement);
|
||||
let x = ($ ? round(rect.width) : rect.width) / width;
|
||||
let y = ($ ? round(rect.height) : rect.height) / height;
|
||||
|
||||
// 0, NaN, or Infinity should always fallback to 1.
|
||||
|
||||
if (!x || !Number.isFinite(x)) {
|
||||
x = 1;
|
||||
}
|
||||
if (!y || !Number.isFinite(y)) {
|
||||
y = 1;
|
||||
}
|
||||
return {
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
const noOffsets = /*#__PURE__*/createCoords(0);
|
||||
function getVisualOffsets(element) {
|
||||
const win = getWindow(element);
|
||||
if (!isWebKit() || !win.visualViewport) {
|
||||
return noOffsets;
|
||||
}
|
||||
return {
|
||||
x: win.visualViewport.offsetLeft,
|
||||
y: win.visualViewport.offsetTop
|
||||
};
|
||||
}
|
||||
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
|
||||
if (isFixed === void 0) {
|
||||
isFixed = false;
|
||||
}
|
||||
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
|
||||
return false;
|
||||
}
|
||||
return isFixed;
|
||||
}
|
||||
|
||||
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
|
||||
if (includeScale === void 0) {
|
||||
includeScale = false;
|
||||
}
|
||||
if (isFixedStrategy === void 0) {
|
||||
isFixedStrategy = false;
|
||||
}
|
||||
const clientRect = element.getBoundingClientRect();
|
||||
const domElement = unwrapElement(element);
|
||||
let scale = createCoords(1);
|
||||
if (includeScale) {
|
||||
if (offsetParent) {
|
||||
if (isElement(offsetParent)) {
|
||||
scale = getScale(offsetParent);
|
||||
}
|
||||
} else {
|
||||
scale = getScale(element);
|
||||
}
|
||||
}
|
||||
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
|
||||
let x = (clientRect.left + visualOffsets.x) / scale.x;
|
||||
let y = (clientRect.top + visualOffsets.y) / scale.y;
|
||||
let width = clientRect.width / scale.x;
|
||||
let height = clientRect.height / scale.y;
|
||||
if (domElement) {
|
||||
const win = getWindow(domElement);
|
||||
const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
|
||||
let currentWin = win;
|
||||
let currentIFrame = currentWin.frameElement;
|
||||
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
|
||||
const iframeScale = getScale(currentIFrame);
|
||||
const iframeRect = currentIFrame.getBoundingClientRect();
|
||||
const css = getComputedStyle(currentIFrame);
|
||||
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
|
||||
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
|
||||
x *= iframeScale.x;
|
||||
y *= iframeScale.y;
|
||||
width *= iframeScale.x;
|
||||
height *= iframeScale.y;
|
||||
x += left;
|
||||
y += top;
|
||||
currentWin = getWindow(currentIFrame);
|
||||
currentIFrame = currentWin.frameElement;
|
||||
}
|
||||
}
|
||||
return rectToClientRect({
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
});
|
||||
}
|
||||
|
||||
const topLayerSelectors = [':popover-open', ':modal'];
|
||||
function isTopLayer(element) {
|
||||
return topLayerSelectors.some(selector => {
|
||||
try {
|
||||
return element.matches(selector);
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
|
||||
let {
|
||||
elements,
|
||||
rect,
|
||||
offsetParent,
|
||||
strategy
|
||||
} = _ref;
|
||||
const isFixed = strategy === 'fixed';
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const topLayer = elements ? isTopLayer(elements.floating) : false;
|
||||
if (offsetParent === documentElement || topLayer && isFixed) {
|
||||
return rect;
|
||||
}
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
let scale = createCoords(1);
|
||||
const offsets = createCoords(0);
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isHTMLElement(offsetParent)) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent);
|
||||
scale = getScale(offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width: rect.width * scale.x,
|
||||
height: rect.height * scale.y,
|
||||
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
|
||||
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
|
||||
};
|
||||
}
|
||||
|
||||
function getClientRects(element) {
|
||||
return Array.from(element.getClientRects());
|
||||
}
|
||||
|
||||
function getWindowScrollBarX(element) {
|
||||
// If <html> has a CSS width greater than the viewport, then this will be
|
||||
// incorrect for RTL.
|
||||
return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
|
||||
}
|
||||
|
||||
// Gets the entire size of the scrollable document area, even extending outside
|
||||
// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
|
||||
function getDocumentRect(element) {
|
||||
const html = getDocumentElement(element);
|
||||
const scroll = getNodeScroll(element);
|
||||
const body = element.ownerDocument.body;
|
||||
const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
||||
const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
||||
let x = -scroll.scrollLeft + getWindowScrollBarX(element);
|
||||
const y = -scroll.scrollTop;
|
||||
if (getComputedStyle(body).direction === 'rtl') {
|
||||
x += max(html.clientWidth, body.clientWidth) - width;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
function getViewportRect(element, strategy) {
|
||||
const win = getWindow(element);
|
||||
const html = getDocumentElement(element);
|
||||
const visualViewport = win.visualViewport;
|
||||
let width = html.clientWidth;
|
||||
let height = html.clientHeight;
|
||||
let x = 0;
|
||||
let y = 0;
|
||||
if (visualViewport) {
|
||||
width = visualViewport.width;
|
||||
height = visualViewport.height;
|
||||
const visualViewportBased = isWebKit();
|
||||
if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
|
||||
x = visualViewport.offsetLeft;
|
||||
y = visualViewport.offsetTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
// Returns the inner client rect, subtracting scrollbars if present.
|
||||
function getInnerBoundingClientRect(element, strategy) {
|
||||
const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
|
||||
const top = clientRect.top + element.clientTop;
|
||||
const left = clientRect.left + element.clientLeft;
|
||||
const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
|
||||
const width = element.clientWidth * scale.x;
|
||||
const height = element.clientHeight * scale.y;
|
||||
const x = left * scale.x;
|
||||
const y = top * scale.y;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
|
||||
let rect;
|
||||
if (clippingAncestor === 'viewport') {
|
||||
rect = getViewportRect(element, strategy);
|
||||
} else if (clippingAncestor === 'document') {
|
||||
rect = getDocumentRect(getDocumentElement(element));
|
||||
} else if (isElement(clippingAncestor)) {
|
||||
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
|
||||
} else {
|
||||
const visualOffsets = getVisualOffsets(element);
|
||||
rect = {
|
||||
...clippingAncestor,
|
||||
x: clippingAncestor.x - visualOffsets.x,
|
||||
y: clippingAncestor.y - visualOffsets.y
|
||||
};
|
||||
}
|
||||
return rectToClientRect(rect);
|
||||
}
|
||||
function hasFixedPositionAncestor(element, stopNode) {
|
||||
const parentNode = getParentNode(element);
|
||||
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
|
||||
return false;
|
||||
}
|
||||
return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
|
||||
}
|
||||
|
||||
// A "clipping ancestor" is an `overflow` element with the characteristic of
|
||||
// clipping (or hiding) child elements. This returns all clipping ancestors
|
||||
// of the given element up the tree.
|
||||
function getClippingElementAncestors(element, cache) {
|
||||
const cachedResult = cache.get(element);
|
||||
if (cachedResult) {
|
||||
return cachedResult;
|
||||
}
|
||||
let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
|
||||
let currentContainingBlockComputedStyle = null;
|
||||
const elementIsFixed = getComputedStyle(element).position === 'fixed';
|
||||
let currentNode = elementIsFixed ? getParentNode(element) : element;
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
const computedStyle = getComputedStyle(currentNode);
|
||||
const currentNodeIsContaining = isContainingBlock(currentNode);
|
||||
if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
|
||||
currentContainingBlockComputedStyle = null;
|
||||
}
|
||||
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
|
||||
if (shouldDropCurrentNode) {
|
||||
// Drop non-containing blocks.
|
||||
result = result.filter(ancestor => ancestor !== currentNode);
|
||||
} else {
|
||||
// Record last containing block for next iteration.
|
||||
currentContainingBlockComputedStyle = computedStyle;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
cache.set(element, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Gets the maximum area that the element is visible in due to any number of
|
||||
// clipping ancestors.
|
||||
function getClippingRect(_ref) {
|
||||
let {
|
||||
element,
|
||||
boundary,
|
||||
rootBoundary,
|
||||
strategy
|
||||
} = _ref;
|
||||
const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
|
||||
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
|
||||
const firstClippingAncestor = clippingAncestors[0];
|
||||
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
|
||||
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
|
||||
accRect.top = max(rect.top, accRect.top);
|
||||
accRect.right = min(rect.right, accRect.right);
|
||||
accRect.bottom = min(rect.bottom, accRect.bottom);
|
||||
accRect.left = max(rect.left, accRect.left);
|
||||
return accRect;
|
||||
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
|
||||
return {
|
||||
width: clippingRect.right - clippingRect.left,
|
||||
height: clippingRect.bottom - clippingRect.top,
|
||||
x: clippingRect.left,
|
||||
y: clippingRect.top
|
||||
};
|
||||
}
|
||||
|
||||
function getDimensions(element) {
|
||||
const {
|
||||
width,
|
||||
height
|
||||
} = getCssDimensions(element);
|
||||
return {
|
||||
width,
|
||||
height
|
||||
};
|
||||
}
|
||||
|
||||
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const isFixed = strategy === 'fixed';
|
||||
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
const offsets = createCoords(0);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isOffsetParentAnElement) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
} else if (documentElement) {
|
||||
offsets.x = getWindowScrollBarX(documentElement);
|
||||
}
|
||||
}
|
||||
const x = rect.left + scroll.scrollLeft - offsets.x;
|
||||
const y = rect.top + scroll.scrollTop - offsets.y;
|
||||
return {
|
||||
x,
|
||||
y,
|
||||
width: rect.width,
|
||||
height: rect.height
|
||||
};
|
||||
}
|
||||
|
||||
function isStaticPositioned(element) {
|
||||
return getComputedStyle(element).position === 'static';
|
||||
}
|
||||
|
||||
function getTrueOffsetParent(element, polyfill) {
|
||||
if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
|
||||
return null;
|
||||
}
|
||||
if (polyfill) {
|
||||
return polyfill(element);
|
||||
}
|
||||
return element.offsetParent;
|
||||
}
|
||||
|
||||
// Gets the closest ancestor positioned element. Handles some edge cases,
|
||||
// such as table ancestors and cross browser bugs.
|
||||
function getOffsetParent(element, polyfill) {
|
||||
const win = getWindow(element);
|
||||
if (isTopLayer(element)) {
|
||||
return win;
|
||||
}
|
||||
if (!isHTMLElement(element)) {
|
||||
let svgOffsetParent = getParentNode(element);
|
||||
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
|
||||
if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
|
||||
return svgOffsetParent;
|
||||
}
|
||||
svgOffsetParent = getParentNode(svgOffsetParent);
|
||||
}
|
||||
return win;
|
||||
}
|
||||
let offsetParent = getTrueOffsetParent(element, polyfill);
|
||||
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
|
||||
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
|
||||
}
|
||||
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
|
||||
return win;
|
||||
}
|
||||
return offsetParent || getContainingBlock(element) || win;
|
||||
}
|
||||
|
||||
const getElementRects = async function (data) {
|
||||
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
|
||||
const getDimensionsFn = this.getDimensions;
|
||||
const floatingDimensions = await getDimensionsFn(data.floating);
|
||||
return {
|
||||
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
|
||||
floating: {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: floatingDimensions.width,
|
||||
height: floatingDimensions.height
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function isRTL(element) {
|
||||
return getComputedStyle(element).direction === 'rtl';
|
||||
}
|
||||
|
||||
const platform = {
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect,
|
||||
getDocumentElement,
|
||||
getClippingRect,
|
||||
getOffsetParent,
|
||||
getElementRects,
|
||||
getClientRects,
|
||||
getDimensions,
|
||||
getScale,
|
||||
isElement,
|
||||
isRTL
|
||||
};
|
||||
|
||||
// https://samthor.au/2021/observing-dom/
|
||||
function observeMove(element, onMove) {
|
||||
let io = null;
|
||||
let timeoutId;
|
||||
const root = getDocumentElement(element);
|
||||
function cleanup() {
|
||||
var _io;
|
||||
clearTimeout(timeoutId);
|
||||
(_io = io) == null || _io.disconnect();
|
||||
io = null;
|
||||
}
|
||||
function refresh(skip, threshold) {
|
||||
if (skip === void 0) {
|
||||
skip = false;
|
||||
}
|
||||
if (threshold === void 0) {
|
||||
threshold = 1;
|
||||
}
|
||||
cleanup();
|
||||
const {
|
||||
left,
|
||||
top,
|
||||
width,
|
||||
height
|
||||
} = element.getBoundingClientRect();
|
||||
if (!skip) {
|
||||
onMove();
|
||||
}
|
||||
if (!width || !height) {
|
||||
return;
|
||||
}
|
||||
const insetTop = floor(top);
|
||||
const insetRight = floor(root.clientWidth - (left + width));
|
||||
const insetBottom = floor(root.clientHeight - (top + height));
|
||||
const insetLeft = floor(left);
|
||||
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
||||
const options = {
|
||||
rootMargin,
|
||||
threshold: max(0, min(1, threshold)) || 1
|
||||
};
|
||||
let isFirstUpdate = true;
|
||||
function handleObserve(entries) {
|
||||
const ratio = entries[0].intersectionRatio;
|
||||
if (ratio !== threshold) {
|
||||
if (!isFirstUpdate) {
|
||||
return refresh();
|
||||
}
|
||||
if (!ratio) {
|
||||
// If the reference is clipped, the ratio is 0. Throttle the refresh
|
||||
// to prevent an infinite loop of updates.
|
||||
timeoutId = setTimeout(() => {
|
||||
refresh(false, 1e-7);
|
||||
}, 1000);
|
||||
} else {
|
||||
refresh(false, ratio);
|
||||
}
|
||||
}
|
||||
isFirstUpdate = false;
|
||||
}
|
||||
|
||||
// Older browsers don't support a `document` as the root and will throw an
|
||||
// error.
|
||||
try {
|
||||
io = new IntersectionObserver(handleObserve, {
|
||||
...options,
|
||||
// Handle <iframe>s
|
||||
root: root.ownerDocument
|
||||
});
|
||||
} catch (e) {
|
||||
io = new IntersectionObserver(handleObserve, options);
|
||||
}
|
||||
io.observe(element);
|
||||
}
|
||||
refresh(true);
|
||||
return cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
function autoUpdate(reference, floating, update, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
ancestorScroll = true,
|
||||
ancestorResize = true,
|
||||
elementResize = typeof ResizeObserver === 'function',
|
||||
layoutShift = typeof IntersectionObserver === 'function',
|
||||
animationFrame = false
|
||||
} = options;
|
||||
const referenceEl = unwrapElement(reference);
|
||||
const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.addEventListener('scroll', update, {
|
||||
passive: true
|
||||
});
|
||||
ancestorResize && ancestor.addEventListener('resize', update);
|
||||
});
|
||||
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
|
||||
let reobserveFrame = -1;
|
||||
let resizeObserver = null;
|
||||
if (elementResize) {
|
||||
resizeObserver = new ResizeObserver(_ref => {
|
||||
let [firstEntry] = _ref;
|
||||
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
|
||||
// Prevent update loops when using the `size` middleware.
|
||||
// https://github.com/floating-ui/floating-ui/issues/1740
|
||||
resizeObserver.unobserve(floating);
|
||||
cancelAnimationFrame(reobserveFrame);
|
||||
reobserveFrame = requestAnimationFrame(() => {
|
||||
var _resizeObserver;
|
||||
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
||||
});
|
||||
}
|
||||
update();
|
||||
});
|
||||
if (referenceEl && !animationFrame) {
|
||||
resizeObserver.observe(referenceEl);
|
||||
}
|
||||
resizeObserver.observe(floating);
|
||||
}
|
||||
let frameId;
|
||||
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
|
||||
if (animationFrame) {
|
||||
frameLoop();
|
||||
}
|
||||
function frameLoop() {
|
||||
const nextRefRect = getBoundingClientRect(reference);
|
||||
if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
|
||||
update();
|
||||
}
|
||||
prevRefRect = nextRefRect;
|
||||
frameId = requestAnimationFrame(frameLoop);
|
||||
}
|
||||
update();
|
||||
return () => {
|
||||
var _resizeObserver2;
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.removeEventListener('scroll', update);
|
||||
ancestorResize && ancestor.removeEventListener('resize', update);
|
||||
});
|
||||
cleanupIo == null || cleanupIo();
|
||||
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
|
||||
resizeObserver = null;
|
||||
if (animationFrame) {
|
||||
cancelAnimationFrame(frameId);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
const detectOverflow = detectOverflow$1;
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
const offset = offset$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
const autoPlacement = autoPlacement$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
const shift = shift$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
const flip = flip$1;
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
const size = size$1;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
const hide = hide$1;
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = arrow$1;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
const inline = inline$1;
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
const limitShift = limitShift$1;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
const computePosition = (reference, floating, options) => {
|
||||
// This caches the expensive `getClippingElementAncestors` function so that
|
||||
// multiple lifecycle resets re-use the same result. It only lives for a
|
||||
// single call. If other functions become expensive, we can add them as well.
|
||||
const cache = new Map();
|
||||
const mergedOptions = {
|
||||
platform,
|
||||
...options
|
||||
};
|
||||
const platformWithCache = {
|
||||
...mergedOptions.platform,
|
||||
_c: cache
|
||||
};
|
||||
return computePosition$1(reference, floating, {
|
||||
...mergedOptions,
|
||||
platform: platformWithCache
|
||||
});
|
||||
};
|
||||
|
||||
export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size };
|
||||
+353
@@ -0,0 +1,353 @@
|
||||
import { AlignedPlacement } from '@floating-ui/core';
|
||||
import { Alignment } from '@floating-ui/core';
|
||||
import type { ArrowOptions as ArrowOptions_2 } from '@floating-ui/core';
|
||||
import type { AutoPlacementOptions as AutoPlacementOptions_2 } from '@floating-ui/core';
|
||||
import { Axis } from '@floating-ui/core';
|
||||
import { ClientRectObject } from '@floating-ui/core';
|
||||
import type { ComputePositionConfig as ComputePositionConfig_2 } from '@floating-ui/core';
|
||||
import { ComputePositionReturn } from '@floating-ui/core';
|
||||
import { Coords } from '@floating-ui/core';
|
||||
import type { DetectOverflowOptions as DetectOverflowOptions_2 } from '@floating-ui/core';
|
||||
import { Dimensions } from '@floating-ui/core';
|
||||
import { ElementContext } from '@floating-ui/core';
|
||||
import { ElementRects } from '@floating-ui/core';
|
||||
import type { FlipOptions as FlipOptions_2 } from '@floating-ui/core';
|
||||
import { getOverflowAncestors } from '@floating-ui/utils/dom';
|
||||
import type { HideOptions as HideOptions_2 } from '@floating-ui/core';
|
||||
import { InlineOptions } from '@floating-ui/core';
|
||||
import { Length } from '@floating-ui/core';
|
||||
import type { LimitShiftOptions } from '@floating-ui/core';
|
||||
import type { Middleware as Middleware_2 } from '@floating-ui/core';
|
||||
import { MiddlewareData } from '@floating-ui/core';
|
||||
import { MiddlewareReturn } from '@floating-ui/core';
|
||||
import type { MiddlewareState as MiddlewareState_2 } from '@floating-ui/core';
|
||||
import { Padding } from '@floating-ui/core';
|
||||
import { Placement } from '@floating-ui/core';
|
||||
import { Rect } from '@floating-ui/core';
|
||||
import { RootBoundary } from '@floating-ui/core';
|
||||
import type { ShiftOptions as ShiftOptions_2 } from '@floating-ui/core';
|
||||
import { Side } from '@floating-ui/core';
|
||||
import { SideObject } from '@floating-ui/core';
|
||||
import type { SizeOptions as SizeOptions_2 } from '@floating-ui/core';
|
||||
import { Strategy } from '@floating-ui/core';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
|
||||
element: Element;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
|
||||
|
||||
export declare type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
export declare function autoUpdate(reference: ReferenceElement, floating: FloatingElement, update: () => void, options?: AutoUpdateOptions): () => void;
|
||||
|
||||
export declare type AutoUpdateOptions = Partial<{
|
||||
/**
|
||||
* Whether to update the position when an overflow ancestor is scrolled.
|
||||
* @default true
|
||||
*/
|
||||
ancestorScroll: boolean;
|
||||
/**
|
||||
* Whether to update the position when an overflow ancestor is resized. This
|
||||
* uses the native `resize` event.
|
||||
* @default true
|
||||
*/
|
||||
ancestorResize: boolean;
|
||||
/**
|
||||
* Whether to update the position when either the reference or floating
|
||||
* elements resized. This uses a `ResizeObserver`.
|
||||
* @default true
|
||||
*/
|
||||
elementResize: boolean;
|
||||
/**
|
||||
* Whether to update the position when the reference relocated on the screen
|
||||
* due to layout shift.
|
||||
* @default true
|
||||
*/
|
||||
layoutShift: boolean;
|
||||
/**
|
||||
* Whether to update on every animation frame if necessary. Only use if you
|
||||
* need to update the position in response to an animation using transforms.
|
||||
* @default false
|
||||
*/
|
||||
animationFrame: boolean;
|
||||
}>;
|
||||
|
||||
export { Axis }
|
||||
|
||||
/**
|
||||
* The clipping boundary area of the floating element.
|
||||
*/
|
||||
export declare type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
|
||||
|
||||
export declare type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
|
||||
/**
|
||||
* Array of middleware objects to modify the positioning or provide data for
|
||||
* rendering.
|
||||
*/
|
||||
middleware?: Array<Middleware | null | undefined | false>;
|
||||
/**
|
||||
* Custom or extended platform object.
|
||||
*/
|
||||
platform?: Platform;
|
||||
}>;
|
||||
|
||||
export { ComputePositionReturn }
|
||||
|
||||
export { Coords }
|
||||
|
||||
export declare type Derivable<T> = (state: MiddlewareState) => T;
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
export declare const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
|
||||
|
||||
export declare type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
|
||||
boundary?: Boundary;
|
||||
}>;
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export { ElementContext }
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export declare interface Elements {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
|
||||
|
||||
export declare type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
export declare type FloatingElement = HTMLElement;
|
||||
|
||||
export { getOverflowAncestors }
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
|
||||
|
||||
export declare type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
|
||||
|
||||
export { InlineOptions }
|
||||
|
||||
export { Length }
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
|
||||
options: any;
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
};
|
||||
|
||||
export declare type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
|
||||
fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* @deprecated use `MiddlewareState` instead.
|
||||
*/
|
||||
export declare type MiddlewareArguments = MiddlewareState;
|
||||
|
||||
export { MiddlewareData }
|
||||
|
||||
export { MiddlewareReturn }
|
||||
|
||||
export declare type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
|
||||
elements: Elements;
|
||||
}>;
|
||||
|
||||
export declare interface NodeScroll {
|
||||
scrollLeft: number;
|
||||
scrollTop: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
export declare const offset: (options?: OffsetOptions) => Middleware;
|
||||
|
||||
export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
|
||||
|
||||
declare type OffsetValue = number | {
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Represents
|
||||
* the distance (gutter or margin) between the reference and floating
|
||||
* element.
|
||||
* @default 0
|
||||
*/
|
||||
mainAxis?: number;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element.
|
||||
* Represents the skidding between the reference and floating element.
|
||||
* @default 0
|
||||
*/
|
||||
crossAxis?: number;
|
||||
/**
|
||||
* The same axis as `crossAxis` but applies only to aligned placements
|
||||
* and inverts the `end` alignment. When set to a number, it overrides the
|
||||
* `crossAxis` value.
|
||||
*
|
||||
* A positive number will move the floating element in the direction of
|
||||
* the opposite edge to the one that is aligned, while a negative number
|
||||
* the reverse.
|
||||
* @default null
|
||||
*/
|
||||
alignmentAxis?: number | null;
|
||||
};
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
export declare interface Platform {
|
||||
getElementRects: (args: {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<ElementRects>;
|
||||
getClippingRect: (args: {
|
||||
element: Element;
|
||||
boundary: Boundary;
|
||||
rootBoundary: RootBoundary;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getDimensions: (element: Element) => Promisable<Dimensions>;
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
|
||||
elements?: Elements;
|
||||
rect: Rect;
|
||||
offsetParent: Element;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getOffsetParent: (element: Element, polyfill?: (element: HTMLElement) => Element | null) => Promisable<Element | Window>;
|
||||
isElement: (value: unknown) => Promisable<boolean>;
|
||||
getDocumentElement: (element: Element) => Promisable<HTMLElement>;
|
||||
getClientRects: (element: Element) => Promisable<Array<ClientRectObject>>;
|
||||
isRTL: (element: Element) => Promisable<boolean>;
|
||||
getScale: (element: HTMLElement) => Promisable<{
|
||||
x: number;
|
||||
y: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export declare const platform: Platform;
|
||||
|
||||
declare type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
|
||||
declare type Promisable<T> = T | Promise<T>;
|
||||
|
||||
export { Rect }
|
||||
|
||||
export declare type ReferenceElement = Element | VirtualElement;
|
||||
|
||||
export { RootBoundary }
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
|
||||
|
||||
export declare type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
|
||||
|
||||
export declare type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
|
||||
/**
|
||||
* Function that is called to perform style mutations to the floating element
|
||||
* to change its size.
|
||||
* @default undefined
|
||||
*/
|
||||
apply?(args: MiddlewareState & {
|
||||
availableWidth: number;
|
||||
availableHeight: number;
|
||||
}): Promisable<void>;
|
||||
}>;
|
||||
|
||||
export { Strategy }
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
export declare interface VirtualElement {
|
||||
getBoundingClientRect(): ClientRectObject;
|
||||
contextElement?: Element;
|
||||
}
|
||||
|
||||
export { }
|
||||
+353
@@ -0,0 +1,353 @@
|
||||
import { AlignedPlacement } from '@floating-ui/core';
|
||||
import { Alignment } from '@floating-ui/core';
|
||||
import type { ArrowOptions as ArrowOptions_2 } from '@floating-ui/core';
|
||||
import type { AutoPlacementOptions as AutoPlacementOptions_2 } from '@floating-ui/core';
|
||||
import { Axis } from '@floating-ui/core';
|
||||
import { ClientRectObject } from '@floating-ui/core';
|
||||
import type { ComputePositionConfig as ComputePositionConfig_2 } from '@floating-ui/core';
|
||||
import { ComputePositionReturn } from '@floating-ui/core';
|
||||
import { Coords } from '@floating-ui/core';
|
||||
import type { DetectOverflowOptions as DetectOverflowOptions_2 } from '@floating-ui/core';
|
||||
import { Dimensions } from '@floating-ui/core';
|
||||
import { ElementContext } from '@floating-ui/core';
|
||||
import { ElementRects } from '@floating-ui/core';
|
||||
import type { FlipOptions as FlipOptions_2 } from '@floating-ui/core';
|
||||
import { getOverflowAncestors } from '@floating-ui/utils/dom';
|
||||
import type { HideOptions as HideOptions_2 } from '@floating-ui/core';
|
||||
import { InlineOptions } from '@floating-ui/core';
|
||||
import { Length } from '@floating-ui/core';
|
||||
import type { LimitShiftOptions } from '@floating-ui/core';
|
||||
import type { Middleware as Middleware_2 } from '@floating-ui/core';
|
||||
import { MiddlewareData } from '@floating-ui/core';
|
||||
import { MiddlewareReturn } from '@floating-ui/core';
|
||||
import type { MiddlewareState as MiddlewareState_2 } from '@floating-ui/core';
|
||||
import { Padding } from '@floating-ui/core';
|
||||
import { Placement } from '@floating-ui/core';
|
||||
import { Rect } from '@floating-ui/core';
|
||||
import { RootBoundary } from '@floating-ui/core';
|
||||
import type { ShiftOptions as ShiftOptions_2 } from '@floating-ui/core';
|
||||
import { Side } from '@floating-ui/core';
|
||||
import { SideObject } from '@floating-ui/core';
|
||||
import type { SizeOptions as SizeOptions_2 } from '@floating-ui/core';
|
||||
import { Strategy } from '@floating-ui/core';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare type ArrowOptions = Prettify<Omit<ArrowOptions_2, 'element'> & {
|
||||
element: Element;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
export declare const autoPlacement: (options?: AutoPlacementOptions | Derivable<AutoPlacementOptions>) => Middleware;
|
||||
|
||||
export declare type AutoPlacementOptions = Prettify<Omit<AutoPlacementOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
export declare function autoUpdate(reference: ReferenceElement, floating: FloatingElement, update: () => void, options?: AutoUpdateOptions): () => void;
|
||||
|
||||
export declare type AutoUpdateOptions = Partial<{
|
||||
/**
|
||||
* Whether to update the position when an overflow ancestor is scrolled.
|
||||
* @default true
|
||||
*/
|
||||
ancestorScroll: boolean;
|
||||
/**
|
||||
* Whether to update the position when an overflow ancestor is resized. This
|
||||
* uses the native `resize` event.
|
||||
* @default true
|
||||
*/
|
||||
ancestorResize: boolean;
|
||||
/**
|
||||
* Whether to update the position when either the reference or floating
|
||||
* elements resized. This uses a `ResizeObserver`.
|
||||
* @default true
|
||||
*/
|
||||
elementResize: boolean;
|
||||
/**
|
||||
* Whether to update the position when the reference relocated on the screen
|
||||
* due to layout shift.
|
||||
* @default true
|
||||
*/
|
||||
layoutShift: boolean;
|
||||
/**
|
||||
* Whether to update on every animation frame if necessary. Only use if you
|
||||
* need to update the position in response to an animation using transforms.
|
||||
* @default false
|
||||
*/
|
||||
animationFrame: boolean;
|
||||
}>;
|
||||
|
||||
export { Axis }
|
||||
|
||||
/**
|
||||
* The clipping boundary area of the floating element.
|
||||
*/
|
||||
export declare type Boundary = 'clippingAncestors' | Element | Array<Element> | Rect;
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
export declare const computePosition: (reference: ReferenceElement, floating: FloatingElement, options?: Partial<ComputePositionConfig>) => Promise<ComputePositionReturn>;
|
||||
|
||||
export declare type ComputePositionConfig = Prettify<Omit<ComputePositionConfig_2, 'middleware' | 'platform'> & {
|
||||
/**
|
||||
* Array of middleware objects to modify the positioning or provide data for
|
||||
* rendering.
|
||||
*/
|
||||
middleware?: Array<Middleware | null | undefined | false>;
|
||||
/**
|
||||
* Custom or extended platform object.
|
||||
*/
|
||||
platform?: Platform;
|
||||
}>;
|
||||
|
||||
export { ComputePositionReturn }
|
||||
|
||||
export { Coords }
|
||||
|
||||
export declare type Derivable<T> = (state: MiddlewareState) => T;
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
export declare const detectOverflow: (state: MiddlewareState, options?: DetectOverflowOptions | Derivable<DetectOverflowOptions>) => Promise<SideObject>;
|
||||
|
||||
export declare type DetectOverflowOptions = Prettify<Omit<DetectOverflowOptions_2, 'boundary'> & {
|
||||
boundary?: Boundary;
|
||||
}>;
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export { ElementContext }
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export declare interface Elements {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
export declare const flip: (options?: FlipOptions | Derivable<FlipOptions>) => Middleware;
|
||||
|
||||
export declare type FlipOptions = Prettify<Omit<FlipOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
export declare type FloatingElement = HTMLElement;
|
||||
|
||||
export { getOverflowAncestors }
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
export declare const hide: (options?: HideOptions | Derivable<HideOptions>) => Middleware;
|
||||
|
||||
export declare type HideOptions = Prettify<Omit<HideOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
export declare const inline: (options?: InlineOptions | Derivable<InlineOptions>) => Middleware;
|
||||
|
||||
export { InlineOptions }
|
||||
|
||||
export { Length }
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
export declare const limitShift: (options?: LimitShiftOptions | Derivable<LimitShiftOptions>) => {
|
||||
options: any;
|
||||
fn: (state: MiddlewareState) => Coords;
|
||||
};
|
||||
|
||||
export declare type Middleware = Prettify<Omit<Middleware_2, 'fn'> & {
|
||||
fn(state: MiddlewareState): Promisable<MiddlewareReturn>;
|
||||
}>;
|
||||
|
||||
/**
|
||||
* @deprecated use `MiddlewareState` instead.
|
||||
*/
|
||||
export declare type MiddlewareArguments = MiddlewareState;
|
||||
|
||||
export { MiddlewareData }
|
||||
|
||||
export { MiddlewareReturn }
|
||||
|
||||
export declare type MiddlewareState = Prettify<Omit<MiddlewareState_2, 'elements'> & {
|
||||
elements: Elements;
|
||||
}>;
|
||||
|
||||
export declare interface NodeScroll {
|
||||
scrollLeft: number;
|
||||
scrollTop: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
export declare const offset: (options?: OffsetOptions) => Middleware;
|
||||
|
||||
export declare type OffsetOptions = OffsetValue | Derivable<OffsetValue>;
|
||||
|
||||
declare type OffsetValue = number | {
|
||||
/**
|
||||
* The axis that runs along the side of the floating element. Represents
|
||||
* the distance (gutter or margin) between the reference and floating
|
||||
* element.
|
||||
* @default 0
|
||||
*/
|
||||
mainAxis?: number;
|
||||
/**
|
||||
* The axis that runs along the alignment of the floating element.
|
||||
* Represents the skidding between the reference and floating element.
|
||||
* @default 0
|
||||
*/
|
||||
crossAxis?: number;
|
||||
/**
|
||||
* The same axis as `crossAxis` but applies only to aligned placements
|
||||
* and inverts the `end` alignment. When set to a number, it overrides the
|
||||
* `crossAxis` value.
|
||||
*
|
||||
* A positive number will move the floating element in the direction of
|
||||
* the opposite edge to the one that is aligned, while a negative number
|
||||
* the reverse.
|
||||
* @default null
|
||||
*/
|
||||
alignmentAxis?: number | null;
|
||||
};
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
export declare interface Platform {
|
||||
getElementRects: (args: {
|
||||
reference: ReferenceElement;
|
||||
floating: FloatingElement;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<ElementRects>;
|
||||
getClippingRect: (args: {
|
||||
element: Element;
|
||||
boundary: Boundary;
|
||||
rootBoundary: RootBoundary;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getDimensions: (element: Element) => Promisable<Dimensions>;
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect: (args: {
|
||||
elements?: Elements;
|
||||
rect: Rect;
|
||||
offsetParent: Element;
|
||||
strategy: Strategy;
|
||||
}) => Promisable<Rect>;
|
||||
getOffsetParent: (element: Element, polyfill?: (element: HTMLElement) => Element | null) => Promisable<Element | Window>;
|
||||
isElement: (value: unknown) => Promisable<boolean>;
|
||||
getDocumentElement: (element: Element) => Promisable<HTMLElement>;
|
||||
getClientRects: (element: Element) => Promisable<Array<ClientRectObject>>;
|
||||
isRTL: (element: Element) => Promisable<boolean>;
|
||||
getScale: (element: HTMLElement) => Promisable<{
|
||||
x: number;
|
||||
y: number;
|
||||
}>;
|
||||
}
|
||||
|
||||
export declare const platform: Platform;
|
||||
|
||||
declare type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
|
||||
declare type Promisable<T> = T | Promise<T>;
|
||||
|
||||
export { Rect }
|
||||
|
||||
export declare type ReferenceElement = Element | VirtualElement;
|
||||
|
||||
export { RootBoundary }
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
export declare const shift: (options?: ShiftOptions | Derivable<ShiftOptions>) => Middleware;
|
||||
|
||||
export declare type ShiftOptions = Prettify<Omit<ShiftOptions_2, 'boundary'> & DetectOverflowOptions>;
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
export declare const size: (options?: SizeOptions | Derivable<SizeOptions>) => Middleware;
|
||||
|
||||
export declare type SizeOptions = Prettify<Omit<SizeOptions_2, 'apply' | 'boundary'> & DetectOverflowOptions & {
|
||||
/**
|
||||
* Function that is called to perform style mutations to the floating element
|
||||
* to change its size.
|
||||
* @default undefined
|
||||
*/
|
||||
apply?(args: MiddlewareState & {
|
||||
availableWidth: number;
|
||||
availableHeight: number;
|
||||
}): Promisable<void>;
|
||||
}>;
|
||||
|
||||
export { Strategy }
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
export declare interface VirtualElement {
|
||||
getBoundingClientRect(): ClientRectObject;
|
||||
contextElement?: Element;
|
||||
}
|
||||
|
||||
export { }
|
||||
+715
@@ -0,0 +1,715 @@
|
||||
import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
|
||||
import { round, createCoords, max, min, floor } from '@floating-ui/utils';
|
||||
import { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';
|
||||
export { getOverflowAncestors } from '@floating-ui/utils/dom';
|
||||
|
||||
function getCssDimensions(element) {
|
||||
const css = getComputedStyle(element);
|
||||
// In testing environments, the `width` and `height` properties are empty
|
||||
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
|
||||
let width = parseFloat(css.width) || 0;
|
||||
let height = parseFloat(css.height) || 0;
|
||||
const hasOffset = isHTMLElement(element);
|
||||
const offsetWidth = hasOffset ? element.offsetWidth : width;
|
||||
const offsetHeight = hasOffset ? element.offsetHeight : height;
|
||||
const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
|
||||
if (shouldFallback) {
|
||||
width = offsetWidth;
|
||||
height = offsetHeight;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
$: shouldFallback
|
||||
};
|
||||
}
|
||||
|
||||
function unwrapElement(element) {
|
||||
return !isElement(element) ? element.contextElement : element;
|
||||
}
|
||||
|
||||
function getScale(element) {
|
||||
const domElement = unwrapElement(element);
|
||||
if (!isHTMLElement(domElement)) {
|
||||
return createCoords(1);
|
||||
}
|
||||
const rect = domElement.getBoundingClientRect();
|
||||
const {
|
||||
width,
|
||||
height,
|
||||
$
|
||||
} = getCssDimensions(domElement);
|
||||
let x = ($ ? round(rect.width) : rect.width) / width;
|
||||
let y = ($ ? round(rect.height) : rect.height) / height;
|
||||
|
||||
// 0, NaN, or Infinity should always fallback to 1.
|
||||
|
||||
if (!x || !Number.isFinite(x)) {
|
||||
x = 1;
|
||||
}
|
||||
if (!y || !Number.isFinite(y)) {
|
||||
y = 1;
|
||||
}
|
||||
return {
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
const noOffsets = /*#__PURE__*/createCoords(0);
|
||||
function getVisualOffsets(element) {
|
||||
const win = getWindow(element);
|
||||
if (!isWebKit() || !win.visualViewport) {
|
||||
return noOffsets;
|
||||
}
|
||||
return {
|
||||
x: win.visualViewport.offsetLeft,
|
||||
y: win.visualViewport.offsetTop
|
||||
};
|
||||
}
|
||||
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
|
||||
if (isFixed === void 0) {
|
||||
isFixed = false;
|
||||
}
|
||||
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
|
||||
return false;
|
||||
}
|
||||
return isFixed;
|
||||
}
|
||||
|
||||
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
|
||||
if (includeScale === void 0) {
|
||||
includeScale = false;
|
||||
}
|
||||
if (isFixedStrategy === void 0) {
|
||||
isFixedStrategy = false;
|
||||
}
|
||||
const clientRect = element.getBoundingClientRect();
|
||||
const domElement = unwrapElement(element);
|
||||
let scale = createCoords(1);
|
||||
if (includeScale) {
|
||||
if (offsetParent) {
|
||||
if (isElement(offsetParent)) {
|
||||
scale = getScale(offsetParent);
|
||||
}
|
||||
} else {
|
||||
scale = getScale(element);
|
||||
}
|
||||
}
|
||||
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
|
||||
let x = (clientRect.left + visualOffsets.x) / scale.x;
|
||||
let y = (clientRect.top + visualOffsets.y) / scale.y;
|
||||
let width = clientRect.width / scale.x;
|
||||
let height = clientRect.height / scale.y;
|
||||
if (domElement) {
|
||||
const win = getWindow(domElement);
|
||||
const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
|
||||
let currentWin = win;
|
||||
let currentIFrame = currentWin.frameElement;
|
||||
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
|
||||
const iframeScale = getScale(currentIFrame);
|
||||
const iframeRect = currentIFrame.getBoundingClientRect();
|
||||
const css = getComputedStyle(currentIFrame);
|
||||
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
|
||||
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
|
||||
x *= iframeScale.x;
|
||||
y *= iframeScale.y;
|
||||
width *= iframeScale.x;
|
||||
height *= iframeScale.y;
|
||||
x += left;
|
||||
y += top;
|
||||
currentWin = getWindow(currentIFrame);
|
||||
currentIFrame = currentWin.frameElement;
|
||||
}
|
||||
}
|
||||
return rectToClientRect({
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
});
|
||||
}
|
||||
|
||||
const topLayerSelectors = [':popover-open', ':modal'];
|
||||
function isTopLayer(element) {
|
||||
return topLayerSelectors.some(selector => {
|
||||
try {
|
||||
return element.matches(selector);
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
|
||||
let {
|
||||
elements,
|
||||
rect,
|
||||
offsetParent,
|
||||
strategy
|
||||
} = _ref;
|
||||
const isFixed = strategy === 'fixed';
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const topLayer = elements ? isTopLayer(elements.floating) : false;
|
||||
if (offsetParent === documentElement || topLayer && isFixed) {
|
||||
return rect;
|
||||
}
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
let scale = createCoords(1);
|
||||
const offsets = createCoords(0);
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isHTMLElement(offsetParent)) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent);
|
||||
scale = getScale(offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width: rect.width * scale.x,
|
||||
height: rect.height * scale.y,
|
||||
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
|
||||
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
|
||||
};
|
||||
}
|
||||
|
||||
function getClientRects(element) {
|
||||
return Array.from(element.getClientRects());
|
||||
}
|
||||
|
||||
function getWindowScrollBarX(element) {
|
||||
// If <html> has a CSS width greater than the viewport, then this will be
|
||||
// incorrect for RTL.
|
||||
return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
|
||||
}
|
||||
|
||||
// Gets the entire size of the scrollable document area, even extending outside
|
||||
// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
|
||||
function getDocumentRect(element) {
|
||||
const html = getDocumentElement(element);
|
||||
const scroll = getNodeScroll(element);
|
||||
const body = element.ownerDocument.body;
|
||||
const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
||||
const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
||||
let x = -scroll.scrollLeft + getWindowScrollBarX(element);
|
||||
const y = -scroll.scrollTop;
|
||||
if (getComputedStyle(body).direction === 'rtl') {
|
||||
x += max(html.clientWidth, body.clientWidth) - width;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
function getViewportRect(element, strategy) {
|
||||
const win = getWindow(element);
|
||||
const html = getDocumentElement(element);
|
||||
const visualViewport = win.visualViewport;
|
||||
let width = html.clientWidth;
|
||||
let height = html.clientHeight;
|
||||
let x = 0;
|
||||
let y = 0;
|
||||
if (visualViewport) {
|
||||
width = visualViewport.width;
|
||||
height = visualViewport.height;
|
||||
const visualViewportBased = isWebKit();
|
||||
if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
|
||||
x = visualViewport.offsetLeft;
|
||||
y = visualViewport.offsetTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
// Returns the inner client rect, subtracting scrollbars if present.
|
||||
function getInnerBoundingClientRect(element, strategy) {
|
||||
const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
|
||||
const top = clientRect.top + element.clientTop;
|
||||
const left = clientRect.left + element.clientLeft;
|
||||
const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
|
||||
const width = element.clientWidth * scale.x;
|
||||
const height = element.clientHeight * scale.y;
|
||||
const x = left * scale.x;
|
||||
const y = top * scale.y;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
|
||||
let rect;
|
||||
if (clippingAncestor === 'viewport') {
|
||||
rect = getViewportRect(element, strategy);
|
||||
} else if (clippingAncestor === 'document') {
|
||||
rect = getDocumentRect(getDocumentElement(element));
|
||||
} else if (isElement(clippingAncestor)) {
|
||||
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
|
||||
} else {
|
||||
const visualOffsets = getVisualOffsets(element);
|
||||
rect = {
|
||||
...clippingAncestor,
|
||||
x: clippingAncestor.x - visualOffsets.x,
|
||||
y: clippingAncestor.y - visualOffsets.y
|
||||
};
|
||||
}
|
||||
return rectToClientRect(rect);
|
||||
}
|
||||
function hasFixedPositionAncestor(element, stopNode) {
|
||||
const parentNode = getParentNode(element);
|
||||
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
|
||||
return false;
|
||||
}
|
||||
return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
|
||||
}
|
||||
|
||||
// A "clipping ancestor" is an `overflow` element with the characteristic of
|
||||
// clipping (or hiding) child elements. This returns all clipping ancestors
|
||||
// of the given element up the tree.
|
||||
function getClippingElementAncestors(element, cache) {
|
||||
const cachedResult = cache.get(element);
|
||||
if (cachedResult) {
|
||||
return cachedResult;
|
||||
}
|
||||
let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
|
||||
let currentContainingBlockComputedStyle = null;
|
||||
const elementIsFixed = getComputedStyle(element).position === 'fixed';
|
||||
let currentNode = elementIsFixed ? getParentNode(element) : element;
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
const computedStyle = getComputedStyle(currentNode);
|
||||
const currentNodeIsContaining = isContainingBlock(currentNode);
|
||||
if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
|
||||
currentContainingBlockComputedStyle = null;
|
||||
}
|
||||
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
|
||||
if (shouldDropCurrentNode) {
|
||||
// Drop non-containing blocks.
|
||||
result = result.filter(ancestor => ancestor !== currentNode);
|
||||
} else {
|
||||
// Record last containing block for next iteration.
|
||||
currentContainingBlockComputedStyle = computedStyle;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
cache.set(element, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Gets the maximum area that the element is visible in due to any number of
|
||||
// clipping ancestors.
|
||||
function getClippingRect(_ref) {
|
||||
let {
|
||||
element,
|
||||
boundary,
|
||||
rootBoundary,
|
||||
strategy
|
||||
} = _ref;
|
||||
const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
|
||||
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
|
||||
const firstClippingAncestor = clippingAncestors[0];
|
||||
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
|
||||
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
|
||||
accRect.top = max(rect.top, accRect.top);
|
||||
accRect.right = min(rect.right, accRect.right);
|
||||
accRect.bottom = min(rect.bottom, accRect.bottom);
|
||||
accRect.left = max(rect.left, accRect.left);
|
||||
return accRect;
|
||||
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
|
||||
return {
|
||||
width: clippingRect.right - clippingRect.left,
|
||||
height: clippingRect.bottom - clippingRect.top,
|
||||
x: clippingRect.left,
|
||||
y: clippingRect.top
|
||||
};
|
||||
}
|
||||
|
||||
function getDimensions(element) {
|
||||
const {
|
||||
width,
|
||||
height
|
||||
} = getCssDimensions(element);
|
||||
return {
|
||||
width,
|
||||
height
|
||||
};
|
||||
}
|
||||
|
||||
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const isFixed = strategy === 'fixed';
|
||||
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
const offsets = createCoords(0);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isOffsetParentAnElement) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
} else if (documentElement) {
|
||||
offsets.x = getWindowScrollBarX(documentElement);
|
||||
}
|
||||
}
|
||||
const x = rect.left + scroll.scrollLeft - offsets.x;
|
||||
const y = rect.top + scroll.scrollTop - offsets.y;
|
||||
return {
|
||||
x,
|
||||
y,
|
||||
width: rect.width,
|
||||
height: rect.height
|
||||
};
|
||||
}
|
||||
|
||||
function isStaticPositioned(element) {
|
||||
return getComputedStyle(element).position === 'static';
|
||||
}
|
||||
|
||||
function getTrueOffsetParent(element, polyfill) {
|
||||
if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
|
||||
return null;
|
||||
}
|
||||
if (polyfill) {
|
||||
return polyfill(element);
|
||||
}
|
||||
return element.offsetParent;
|
||||
}
|
||||
|
||||
// Gets the closest ancestor positioned element. Handles some edge cases,
|
||||
// such as table ancestors and cross browser bugs.
|
||||
function getOffsetParent(element, polyfill) {
|
||||
const win = getWindow(element);
|
||||
if (isTopLayer(element)) {
|
||||
return win;
|
||||
}
|
||||
if (!isHTMLElement(element)) {
|
||||
let svgOffsetParent = getParentNode(element);
|
||||
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
|
||||
if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
|
||||
return svgOffsetParent;
|
||||
}
|
||||
svgOffsetParent = getParentNode(svgOffsetParent);
|
||||
}
|
||||
return win;
|
||||
}
|
||||
let offsetParent = getTrueOffsetParent(element, polyfill);
|
||||
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
|
||||
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
|
||||
}
|
||||
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
|
||||
return win;
|
||||
}
|
||||
return offsetParent || getContainingBlock(element) || win;
|
||||
}
|
||||
|
||||
const getElementRects = async function (data) {
|
||||
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
|
||||
const getDimensionsFn = this.getDimensions;
|
||||
const floatingDimensions = await getDimensionsFn(data.floating);
|
||||
return {
|
||||
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
|
||||
floating: {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: floatingDimensions.width,
|
||||
height: floatingDimensions.height
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function isRTL(element) {
|
||||
return getComputedStyle(element).direction === 'rtl';
|
||||
}
|
||||
|
||||
const platform = {
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect,
|
||||
getDocumentElement,
|
||||
getClippingRect,
|
||||
getOffsetParent,
|
||||
getElementRects,
|
||||
getClientRects,
|
||||
getDimensions,
|
||||
getScale,
|
||||
isElement,
|
||||
isRTL
|
||||
};
|
||||
|
||||
// https://samthor.au/2021/observing-dom/
|
||||
function observeMove(element, onMove) {
|
||||
let io = null;
|
||||
let timeoutId;
|
||||
const root = getDocumentElement(element);
|
||||
function cleanup() {
|
||||
var _io;
|
||||
clearTimeout(timeoutId);
|
||||
(_io = io) == null || _io.disconnect();
|
||||
io = null;
|
||||
}
|
||||
function refresh(skip, threshold) {
|
||||
if (skip === void 0) {
|
||||
skip = false;
|
||||
}
|
||||
if (threshold === void 0) {
|
||||
threshold = 1;
|
||||
}
|
||||
cleanup();
|
||||
const {
|
||||
left,
|
||||
top,
|
||||
width,
|
||||
height
|
||||
} = element.getBoundingClientRect();
|
||||
if (!skip) {
|
||||
onMove();
|
||||
}
|
||||
if (!width || !height) {
|
||||
return;
|
||||
}
|
||||
const insetTop = floor(top);
|
||||
const insetRight = floor(root.clientWidth - (left + width));
|
||||
const insetBottom = floor(root.clientHeight - (top + height));
|
||||
const insetLeft = floor(left);
|
||||
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
||||
const options = {
|
||||
rootMargin,
|
||||
threshold: max(0, min(1, threshold)) || 1
|
||||
};
|
||||
let isFirstUpdate = true;
|
||||
function handleObserve(entries) {
|
||||
const ratio = entries[0].intersectionRatio;
|
||||
if (ratio !== threshold) {
|
||||
if (!isFirstUpdate) {
|
||||
return refresh();
|
||||
}
|
||||
if (!ratio) {
|
||||
// If the reference is clipped, the ratio is 0. Throttle the refresh
|
||||
// to prevent an infinite loop of updates.
|
||||
timeoutId = setTimeout(() => {
|
||||
refresh(false, 1e-7);
|
||||
}, 1000);
|
||||
} else {
|
||||
refresh(false, ratio);
|
||||
}
|
||||
}
|
||||
isFirstUpdate = false;
|
||||
}
|
||||
|
||||
// Older browsers don't support a `document` as the root and will throw an
|
||||
// error.
|
||||
try {
|
||||
io = new IntersectionObserver(handleObserve, {
|
||||
...options,
|
||||
// Handle <iframe>s
|
||||
root: root.ownerDocument
|
||||
});
|
||||
} catch (e) {
|
||||
io = new IntersectionObserver(handleObserve, options);
|
||||
}
|
||||
io.observe(element);
|
||||
}
|
||||
refresh(true);
|
||||
return cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
function autoUpdate(reference, floating, update, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
ancestorScroll = true,
|
||||
ancestorResize = true,
|
||||
elementResize = typeof ResizeObserver === 'function',
|
||||
layoutShift = typeof IntersectionObserver === 'function',
|
||||
animationFrame = false
|
||||
} = options;
|
||||
const referenceEl = unwrapElement(reference);
|
||||
const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.addEventListener('scroll', update, {
|
||||
passive: true
|
||||
});
|
||||
ancestorResize && ancestor.addEventListener('resize', update);
|
||||
});
|
||||
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
|
||||
let reobserveFrame = -1;
|
||||
let resizeObserver = null;
|
||||
if (elementResize) {
|
||||
resizeObserver = new ResizeObserver(_ref => {
|
||||
let [firstEntry] = _ref;
|
||||
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
|
||||
// Prevent update loops when using the `size` middleware.
|
||||
// https://github.com/floating-ui/floating-ui/issues/1740
|
||||
resizeObserver.unobserve(floating);
|
||||
cancelAnimationFrame(reobserveFrame);
|
||||
reobserveFrame = requestAnimationFrame(() => {
|
||||
var _resizeObserver;
|
||||
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
||||
});
|
||||
}
|
||||
update();
|
||||
});
|
||||
if (referenceEl && !animationFrame) {
|
||||
resizeObserver.observe(referenceEl);
|
||||
}
|
||||
resizeObserver.observe(floating);
|
||||
}
|
||||
let frameId;
|
||||
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
|
||||
if (animationFrame) {
|
||||
frameLoop();
|
||||
}
|
||||
function frameLoop() {
|
||||
const nextRefRect = getBoundingClientRect(reference);
|
||||
if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
|
||||
update();
|
||||
}
|
||||
prevRefRect = nextRefRect;
|
||||
frameId = requestAnimationFrame(frameLoop);
|
||||
}
|
||||
update();
|
||||
return () => {
|
||||
var _resizeObserver2;
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.removeEventListener('scroll', update);
|
||||
ancestorResize && ancestor.removeEventListener('resize', update);
|
||||
});
|
||||
cleanupIo == null || cleanupIo();
|
||||
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
|
||||
resizeObserver = null;
|
||||
if (animationFrame) {
|
||||
cancelAnimationFrame(frameId);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
const detectOverflow = detectOverflow$1;
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
const offset = offset$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
const autoPlacement = autoPlacement$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
const shift = shift$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
const flip = flip$1;
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
const size = size$1;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
const hide = hide$1;
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = arrow$1;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
const inline = inline$1;
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
const limitShift = limitShift$1;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
const computePosition = (reference, floating, options) => {
|
||||
// This caches the expensive `getClippingElementAncestors` function so that
|
||||
// multiple lifecycle resets re-use the same result. It only lives for a
|
||||
// single call. If other functions become expensive, we can add them as well.
|
||||
const cache = new Map();
|
||||
const mergedOptions = {
|
||||
platform,
|
||||
...options
|
||||
};
|
||||
const platformWithCache = {
|
||||
...mergedOptions.platform,
|
||||
_c: cache
|
||||
};
|
||||
return computePosition$1(reference, floating, {
|
||||
...mergedOptions,
|
||||
platform: platformWithCache
|
||||
});
|
||||
};
|
||||
|
||||
export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };
|
||||
+715
@@ -0,0 +1,715 @@
|
||||
import { rectToClientRect, detectOverflow as detectOverflow$1, offset as offset$1, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';
|
||||
import { round, createCoords, max, min, floor } from '@floating-ui/utils';
|
||||
import { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';
|
||||
export { getOverflowAncestors } from '@floating-ui/utils/dom';
|
||||
|
||||
function getCssDimensions(element) {
|
||||
const css = getComputedStyle(element);
|
||||
// In testing environments, the `width` and `height` properties are empty
|
||||
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
|
||||
let width = parseFloat(css.width) || 0;
|
||||
let height = parseFloat(css.height) || 0;
|
||||
const hasOffset = isHTMLElement(element);
|
||||
const offsetWidth = hasOffset ? element.offsetWidth : width;
|
||||
const offsetHeight = hasOffset ? element.offsetHeight : height;
|
||||
const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
|
||||
if (shouldFallback) {
|
||||
width = offsetWidth;
|
||||
height = offsetHeight;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
$: shouldFallback
|
||||
};
|
||||
}
|
||||
|
||||
function unwrapElement(element) {
|
||||
return !isElement(element) ? element.contextElement : element;
|
||||
}
|
||||
|
||||
function getScale(element) {
|
||||
const domElement = unwrapElement(element);
|
||||
if (!isHTMLElement(domElement)) {
|
||||
return createCoords(1);
|
||||
}
|
||||
const rect = domElement.getBoundingClientRect();
|
||||
const {
|
||||
width,
|
||||
height,
|
||||
$
|
||||
} = getCssDimensions(domElement);
|
||||
let x = ($ ? round(rect.width) : rect.width) / width;
|
||||
let y = ($ ? round(rect.height) : rect.height) / height;
|
||||
|
||||
// 0, NaN, or Infinity should always fallback to 1.
|
||||
|
||||
if (!x || !Number.isFinite(x)) {
|
||||
x = 1;
|
||||
}
|
||||
if (!y || !Number.isFinite(y)) {
|
||||
y = 1;
|
||||
}
|
||||
return {
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
const noOffsets = /*#__PURE__*/createCoords(0);
|
||||
function getVisualOffsets(element) {
|
||||
const win = getWindow(element);
|
||||
if (!isWebKit() || !win.visualViewport) {
|
||||
return noOffsets;
|
||||
}
|
||||
return {
|
||||
x: win.visualViewport.offsetLeft,
|
||||
y: win.visualViewport.offsetTop
|
||||
};
|
||||
}
|
||||
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
|
||||
if (isFixed === void 0) {
|
||||
isFixed = false;
|
||||
}
|
||||
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
|
||||
return false;
|
||||
}
|
||||
return isFixed;
|
||||
}
|
||||
|
||||
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
|
||||
if (includeScale === void 0) {
|
||||
includeScale = false;
|
||||
}
|
||||
if (isFixedStrategy === void 0) {
|
||||
isFixedStrategy = false;
|
||||
}
|
||||
const clientRect = element.getBoundingClientRect();
|
||||
const domElement = unwrapElement(element);
|
||||
let scale = createCoords(1);
|
||||
if (includeScale) {
|
||||
if (offsetParent) {
|
||||
if (isElement(offsetParent)) {
|
||||
scale = getScale(offsetParent);
|
||||
}
|
||||
} else {
|
||||
scale = getScale(element);
|
||||
}
|
||||
}
|
||||
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
|
||||
let x = (clientRect.left + visualOffsets.x) / scale.x;
|
||||
let y = (clientRect.top + visualOffsets.y) / scale.y;
|
||||
let width = clientRect.width / scale.x;
|
||||
let height = clientRect.height / scale.y;
|
||||
if (domElement) {
|
||||
const win = getWindow(domElement);
|
||||
const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
|
||||
let currentWin = win;
|
||||
let currentIFrame = currentWin.frameElement;
|
||||
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
|
||||
const iframeScale = getScale(currentIFrame);
|
||||
const iframeRect = currentIFrame.getBoundingClientRect();
|
||||
const css = getComputedStyle(currentIFrame);
|
||||
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
|
||||
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
|
||||
x *= iframeScale.x;
|
||||
y *= iframeScale.y;
|
||||
width *= iframeScale.x;
|
||||
height *= iframeScale.y;
|
||||
x += left;
|
||||
y += top;
|
||||
currentWin = getWindow(currentIFrame);
|
||||
currentIFrame = currentWin.frameElement;
|
||||
}
|
||||
}
|
||||
return rectToClientRect({
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
});
|
||||
}
|
||||
|
||||
const topLayerSelectors = [':popover-open', ':modal'];
|
||||
function isTopLayer(element) {
|
||||
return topLayerSelectors.some(selector => {
|
||||
try {
|
||||
return element.matches(selector);
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
|
||||
let {
|
||||
elements,
|
||||
rect,
|
||||
offsetParent,
|
||||
strategy
|
||||
} = _ref;
|
||||
const isFixed = strategy === 'fixed';
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const topLayer = elements ? isTopLayer(elements.floating) : false;
|
||||
if (offsetParent === documentElement || topLayer && isFixed) {
|
||||
return rect;
|
||||
}
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
let scale = createCoords(1);
|
||||
const offsets = createCoords(0);
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isHTMLElement(offsetParent)) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent);
|
||||
scale = getScale(offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width: rect.width * scale.x,
|
||||
height: rect.height * scale.y,
|
||||
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
|
||||
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
|
||||
};
|
||||
}
|
||||
|
||||
function getClientRects(element) {
|
||||
return Array.from(element.getClientRects());
|
||||
}
|
||||
|
||||
function getWindowScrollBarX(element) {
|
||||
// If <html> has a CSS width greater than the viewport, then this will be
|
||||
// incorrect for RTL.
|
||||
return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
|
||||
}
|
||||
|
||||
// Gets the entire size of the scrollable document area, even extending outside
|
||||
// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
|
||||
function getDocumentRect(element) {
|
||||
const html = getDocumentElement(element);
|
||||
const scroll = getNodeScroll(element);
|
||||
const body = element.ownerDocument.body;
|
||||
const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
||||
const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
||||
let x = -scroll.scrollLeft + getWindowScrollBarX(element);
|
||||
const y = -scroll.scrollTop;
|
||||
if (getComputedStyle(body).direction === 'rtl') {
|
||||
x += max(html.clientWidth, body.clientWidth) - width;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
function getViewportRect(element, strategy) {
|
||||
const win = getWindow(element);
|
||||
const html = getDocumentElement(element);
|
||||
const visualViewport = win.visualViewport;
|
||||
let width = html.clientWidth;
|
||||
let height = html.clientHeight;
|
||||
let x = 0;
|
||||
let y = 0;
|
||||
if (visualViewport) {
|
||||
width = visualViewport.width;
|
||||
height = visualViewport.height;
|
||||
const visualViewportBased = isWebKit();
|
||||
if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
|
||||
x = visualViewport.offsetLeft;
|
||||
y = visualViewport.offsetTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
// Returns the inner client rect, subtracting scrollbars if present.
|
||||
function getInnerBoundingClientRect(element, strategy) {
|
||||
const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
|
||||
const top = clientRect.top + element.clientTop;
|
||||
const left = clientRect.left + element.clientLeft;
|
||||
const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
|
||||
const width = element.clientWidth * scale.x;
|
||||
const height = element.clientHeight * scale.y;
|
||||
const x = left * scale.x;
|
||||
const y = top * scale.y;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
|
||||
let rect;
|
||||
if (clippingAncestor === 'viewport') {
|
||||
rect = getViewportRect(element, strategy);
|
||||
} else if (clippingAncestor === 'document') {
|
||||
rect = getDocumentRect(getDocumentElement(element));
|
||||
} else if (isElement(clippingAncestor)) {
|
||||
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
|
||||
} else {
|
||||
const visualOffsets = getVisualOffsets(element);
|
||||
rect = {
|
||||
...clippingAncestor,
|
||||
x: clippingAncestor.x - visualOffsets.x,
|
||||
y: clippingAncestor.y - visualOffsets.y
|
||||
};
|
||||
}
|
||||
return rectToClientRect(rect);
|
||||
}
|
||||
function hasFixedPositionAncestor(element, stopNode) {
|
||||
const parentNode = getParentNode(element);
|
||||
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
|
||||
return false;
|
||||
}
|
||||
return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
|
||||
}
|
||||
|
||||
// A "clipping ancestor" is an `overflow` element with the characteristic of
|
||||
// clipping (or hiding) child elements. This returns all clipping ancestors
|
||||
// of the given element up the tree.
|
||||
function getClippingElementAncestors(element, cache) {
|
||||
const cachedResult = cache.get(element);
|
||||
if (cachedResult) {
|
||||
return cachedResult;
|
||||
}
|
||||
let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
|
||||
let currentContainingBlockComputedStyle = null;
|
||||
const elementIsFixed = getComputedStyle(element).position === 'fixed';
|
||||
let currentNode = elementIsFixed ? getParentNode(element) : element;
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
const computedStyle = getComputedStyle(currentNode);
|
||||
const currentNodeIsContaining = isContainingBlock(currentNode);
|
||||
if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
|
||||
currentContainingBlockComputedStyle = null;
|
||||
}
|
||||
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
|
||||
if (shouldDropCurrentNode) {
|
||||
// Drop non-containing blocks.
|
||||
result = result.filter(ancestor => ancestor !== currentNode);
|
||||
} else {
|
||||
// Record last containing block for next iteration.
|
||||
currentContainingBlockComputedStyle = computedStyle;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
cache.set(element, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Gets the maximum area that the element is visible in due to any number of
|
||||
// clipping ancestors.
|
||||
function getClippingRect(_ref) {
|
||||
let {
|
||||
element,
|
||||
boundary,
|
||||
rootBoundary,
|
||||
strategy
|
||||
} = _ref;
|
||||
const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
|
||||
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
|
||||
const firstClippingAncestor = clippingAncestors[0];
|
||||
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
|
||||
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
|
||||
accRect.top = max(rect.top, accRect.top);
|
||||
accRect.right = min(rect.right, accRect.right);
|
||||
accRect.bottom = min(rect.bottom, accRect.bottom);
|
||||
accRect.left = max(rect.left, accRect.left);
|
||||
return accRect;
|
||||
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
|
||||
return {
|
||||
width: clippingRect.right - clippingRect.left,
|
||||
height: clippingRect.bottom - clippingRect.top,
|
||||
x: clippingRect.left,
|
||||
y: clippingRect.top
|
||||
};
|
||||
}
|
||||
|
||||
function getDimensions(element) {
|
||||
const {
|
||||
width,
|
||||
height
|
||||
} = getCssDimensions(element);
|
||||
return {
|
||||
width,
|
||||
height
|
||||
};
|
||||
}
|
||||
|
||||
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const isFixed = strategy === 'fixed';
|
||||
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
const offsets = createCoords(0);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isOffsetParentAnElement) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
} else if (documentElement) {
|
||||
offsets.x = getWindowScrollBarX(documentElement);
|
||||
}
|
||||
}
|
||||
const x = rect.left + scroll.scrollLeft - offsets.x;
|
||||
const y = rect.top + scroll.scrollTop - offsets.y;
|
||||
return {
|
||||
x,
|
||||
y,
|
||||
width: rect.width,
|
||||
height: rect.height
|
||||
};
|
||||
}
|
||||
|
||||
function isStaticPositioned(element) {
|
||||
return getComputedStyle(element).position === 'static';
|
||||
}
|
||||
|
||||
function getTrueOffsetParent(element, polyfill) {
|
||||
if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
|
||||
return null;
|
||||
}
|
||||
if (polyfill) {
|
||||
return polyfill(element);
|
||||
}
|
||||
return element.offsetParent;
|
||||
}
|
||||
|
||||
// Gets the closest ancestor positioned element. Handles some edge cases,
|
||||
// such as table ancestors and cross browser bugs.
|
||||
function getOffsetParent(element, polyfill) {
|
||||
const win = getWindow(element);
|
||||
if (isTopLayer(element)) {
|
||||
return win;
|
||||
}
|
||||
if (!isHTMLElement(element)) {
|
||||
let svgOffsetParent = getParentNode(element);
|
||||
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
|
||||
if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
|
||||
return svgOffsetParent;
|
||||
}
|
||||
svgOffsetParent = getParentNode(svgOffsetParent);
|
||||
}
|
||||
return win;
|
||||
}
|
||||
let offsetParent = getTrueOffsetParent(element, polyfill);
|
||||
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
|
||||
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
|
||||
}
|
||||
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
|
||||
return win;
|
||||
}
|
||||
return offsetParent || getContainingBlock(element) || win;
|
||||
}
|
||||
|
||||
const getElementRects = async function (data) {
|
||||
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
|
||||
const getDimensionsFn = this.getDimensions;
|
||||
const floatingDimensions = await getDimensionsFn(data.floating);
|
||||
return {
|
||||
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
|
||||
floating: {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: floatingDimensions.width,
|
||||
height: floatingDimensions.height
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function isRTL(element) {
|
||||
return getComputedStyle(element).direction === 'rtl';
|
||||
}
|
||||
|
||||
const platform = {
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect,
|
||||
getDocumentElement,
|
||||
getClippingRect,
|
||||
getOffsetParent,
|
||||
getElementRects,
|
||||
getClientRects,
|
||||
getDimensions,
|
||||
getScale,
|
||||
isElement,
|
||||
isRTL
|
||||
};
|
||||
|
||||
// https://samthor.au/2021/observing-dom/
|
||||
function observeMove(element, onMove) {
|
||||
let io = null;
|
||||
let timeoutId;
|
||||
const root = getDocumentElement(element);
|
||||
function cleanup() {
|
||||
var _io;
|
||||
clearTimeout(timeoutId);
|
||||
(_io = io) == null || _io.disconnect();
|
||||
io = null;
|
||||
}
|
||||
function refresh(skip, threshold) {
|
||||
if (skip === void 0) {
|
||||
skip = false;
|
||||
}
|
||||
if (threshold === void 0) {
|
||||
threshold = 1;
|
||||
}
|
||||
cleanup();
|
||||
const {
|
||||
left,
|
||||
top,
|
||||
width,
|
||||
height
|
||||
} = element.getBoundingClientRect();
|
||||
if (!skip) {
|
||||
onMove();
|
||||
}
|
||||
if (!width || !height) {
|
||||
return;
|
||||
}
|
||||
const insetTop = floor(top);
|
||||
const insetRight = floor(root.clientWidth - (left + width));
|
||||
const insetBottom = floor(root.clientHeight - (top + height));
|
||||
const insetLeft = floor(left);
|
||||
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
||||
const options = {
|
||||
rootMargin,
|
||||
threshold: max(0, min(1, threshold)) || 1
|
||||
};
|
||||
let isFirstUpdate = true;
|
||||
function handleObserve(entries) {
|
||||
const ratio = entries[0].intersectionRatio;
|
||||
if (ratio !== threshold) {
|
||||
if (!isFirstUpdate) {
|
||||
return refresh();
|
||||
}
|
||||
if (!ratio) {
|
||||
// If the reference is clipped, the ratio is 0. Throttle the refresh
|
||||
// to prevent an infinite loop of updates.
|
||||
timeoutId = setTimeout(() => {
|
||||
refresh(false, 1e-7);
|
||||
}, 1000);
|
||||
} else {
|
||||
refresh(false, ratio);
|
||||
}
|
||||
}
|
||||
isFirstUpdate = false;
|
||||
}
|
||||
|
||||
// Older browsers don't support a `document` as the root and will throw an
|
||||
// error.
|
||||
try {
|
||||
io = new IntersectionObserver(handleObserve, {
|
||||
...options,
|
||||
// Handle <iframe>s
|
||||
root: root.ownerDocument
|
||||
});
|
||||
} catch (e) {
|
||||
io = new IntersectionObserver(handleObserve, options);
|
||||
}
|
||||
io.observe(element);
|
||||
}
|
||||
refresh(true);
|
||||
return cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
function autoUpdate(reference, floating, update, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
ancestorScroll = true,
|
||||
ancestorResize = true,
|
||||
elementResize = typeof ResizeObserver === 'function',
|
||||
layoutShift = typeof IntersectionObserver === 'function',
|
||||
animationFrame = false
|
||||
} = options;
|
||||
const referenceEl = unwrapElement(reference);
|
||||
const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.addEventListener('scroll', update, {
|
||||
passive: true
|
||||
});
|
||||
ancestorResize && ancestor.addEventListener('resize', update);
|
||||
});
|
||||
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
|
||||
let reobserveFrame = -1;
|
||||
let resizeObserver = null;
|
||||
if (elementResize) {
|
||||
resizeObserver = new ResizeObserver(_ref => {
|
||||
let [firstEntry] = _ref;
|
||||
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
|
||||
// Prevent update loops when using the `size` middleware.
|
||||
// https://github.com/floating-ui/floating-ui/issues/1740
|
||||
resizeObserver.unobserve(floating);
|
||||
cancelAnimationFrame(reobserveFrame);
|
||||
reobserveFrame = requestAnimationFrame(() => {
|
||||
var _resizeObserver;
|
||||
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
||||
});
|
||||
}
|
||||
update();
|
||||
});
|
||||
if (referenceEl && !animationFrame) {
|
||||
resizeObserver.observe(referenceEl);
|
||||
}
|
||||
resizeObserver.observe(floating);
|
||||
}
|
||||
let frameId;
|
||||
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
|
||||
if (animationFrame) {
|
||||
frameLoop();
|
||||
}
|
||||
function frameLoop() {
|
||||
const nextRefRect = getBoundingClientRect(reference);
|
||||
if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
|
||||
update();
|
||||
}
|
||||
prevRefRect = nextRefRect;
|
||||
frameId = requestAnimationFrame(frameLoop);
|
||||
}
|
||||
update();
|
||||
return () => {
|
||||
var _resizeObserver2;
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.removeEventListener('scroll', update);
|
||||
ancestorResize && ancestor.removeEventListener('resize', update);
|
||||
});
|
||||
cleanupIo == null || cleanupIo();
|
||||
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
|
||||
resizeObserver = null;
|
||||
if (animationFrame) {
|
||||
cancelAnimationFrame(frameId);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
const detectOverflow = detectOverflow$1;
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
const offset = offset$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
const autoPlacement = autoPlacement$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
const shift = shift$1;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
const flip = flip$1;
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
const size = size$1;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
const hide = hide$1;
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = arrow$1;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
const inline = inline$1;
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
const limitShift = limitShift$1;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
const computePosition = (reference, floating, options) => {
|
||||
// This caches the expensive `getClippingElementAncestors` function so that
|
||||
// multiple lifecycle resets re-use the same result. It only lives for a
|
||||
// single call. If other functions become expensive, we can add them as well.
|
||||
const cache = new Map();
|
||||
const mergedOptions = {
|
||||
platform,
|
||||
...options
|
||||
};
|
||||
const platformWithCache = {
|
||||
...mergedOptions.platform,
|
||||
_c: cache
|
||||
};
|
||||
return computePosition$1(reference, floating, {
|
||||
...mergedOptions,
|
||||
platform: platformWithCache
|
||||
});
|
||||
};
|
||||
|
||||
export { arrow, autoPlacement, autoUpdate, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, platform, shift, size };
|
||||
+871
@@ -0,0 +1,871 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@floating-ui/core')) :
|
||||
typeof define === 'function' && define.amd ? define(['exports', '@floating-ui/core'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIDOM = {}, global.FloatingUICore));
|
||||
})(this, (function (exports, core) { 'use strict';
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
|
||||
const min = Math.min;
|
||||
const max = Math.max;
|
||||
const round = Math.round;
|
||||
const floor = Math.floor;
|
||||
const createCoords = v => ({
|
||||
x: v,
|
||||
y: v
|
||||
});
|
||||
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
function getCssDimensions(element) {
|
||||
const css = getComputedStyle(element);
|
||||
// In testing environments, the `width` and `height` properties are empty
|
||||
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
|
||||
let width = parseFloat(css.width) || 0;
|
||||
let height = parseFloat(css.height) || 0;
|
||||
const hasOffset = isHTMLElement(element);
|
||||
const offsetWidth = hasOffset ? element.offsetWidth : width;
|
||||
const offsetHeight = hasOffset ? element.offsetHeight : height;
|
||||
const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
|
||||
if (shouldFallback) {
|
||||
width = offsetWidth;
|
||||
height = offsetHeight;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
$: shouldFallback
|
||||
};
|
||||
}
|
||||
|
||||
function unwrapElement(element) {
|
||||
return !isElement(element) ? element.contextElement : element;
|
||||
}
|
||||
|
||||
function getScale(element) {
|
||||
const domElement = unwrapElement(element);
|
||||
if (!isHTMLElement(domElement)) {
|
||||
return createCoords(1);
|
||||
}
|
||||
const rect = domElement.getBoundingClientRect();
|
||||
const {
|
||||
width,
|
||||
height,
|
||||
$
|
||||
} = getCssDimensions(domElement);
|
||||
let x = ($ ? round(rect.width) : rect.width) / width;
|
||||
let y = ($ ? round(rect.height) : rect.height) / height;
|
||||
|
||||
// 0, NaN, or Infinity should always fallback to 1.
|
||||
|
||||
if (!x || !Number.isFinite(x)) {
|
||||
x = 1;
|
||||
}
|
||||
if (!y || !Number.isFinite(y)) {
|
||||
y = 1;
|
||||
}
|
||||
return {
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
const noOffsets = /*#__PURE__*/createCoords(0);
|
||||
function getVisualOffsets(element) {
|
||||
const win = getWindow(element);
|
||||
if (!isWebKit() || !win.visualViewport) {
|
||||
return noOffsets;
|
||||
}
|
||||
return {
|
||||
x: win.visualViewport.offsetLeft,
|
||||
y: win.visualViewport.offsetTop
|
||||
};
|
||||
}
|
||||
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
|
||||
if (isFixed === void 0) {
|
||||
isFixed = false;
|
||||
}
|
||||
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
|
||||
return false;
|
||||
}
|
||||
return isFixed;
|
||||
}
|
||||
|
||||
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
|
||||
if (includeScale === void 0) {
|
||||
includeScale = false;
|
||||
}
|
||||
if (isFixedStrategy === void 0) {
|
||||
isFixedStrategy = false;
|
||||
}
|
||||
const clientRect = element.getBoundingClientRect();
|
||||
const domElement = unwrapElement(element);
|
||||
let scale = createCoords(1);
|
||||
if (includeScale) {
|
||||
if (offsetParent) {
|
||||
if (isElement(offsetParent)) {
|
||||
scale = getScale(offsetParent);
|
||||
}
|
||||
} else {
|
||||
scale = getScale(element);
|
||||
}
|
||||
}
|
||||
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
|
||||
let x = (clientRect.left + visualOffsets.x) / scale.x;
|
||||
let y = (clientRect.top + visualOffsets.y) / scale.y;
|
||||
let width = clientRect.width / scale.x;
|
||||
let height = clientRect.height / scale.y;
|
||||
if (domElement) {
|
||||
const win = getWindow(domElement);
|
||||
const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
|
||||
let currentWin = win;
|
||||
let currentIFrame = currentWin.frameElement;
|
||||
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
|
||||
const iframeScale = getScale(currentIFrame);
|
||||
const iframeRect = currentIFrame.getBoundingClientRect();
|
||||
const css = getComputedStyle(currentIFrame);
|
||||
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
|
||||
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
|
||||
x *= iframeScale.x;
|
||||
y *= iframeScale.y;
|
||||
width *= iframeScale.x;
|
||||
height *= iframeScale.y;
|
||||
x += left;
|
||||
y += top;
|
||||
currentWin = getWindow(currentIFrame);
|
||||
currentIFrame = currentWin.frameElement;
|
||||
}
|
||||
}
|
||||
return core.rectToClientRect({
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
});
|
||||
}
|
||||
|
||||
const topLayerSelectors = [':popover-open', ':modal'];
|
||||
function isTopLayer(element) {
|
||||
return topLayerSelectors.some(selector => {
|
||||
try {
|
||||
return element.matches(selector);
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
|
||||
let {
|
||||
elements,
|
||||
rect,
|
||||
offsetParent,
|
||||
strategy
|
||||
} = _ref;
|
||||
const isFixed = strategy === 'fixed';
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const topLayer = elements ? isTopLayer(elements.floating) : false;
|
||||
if (offsetParent === documentElement || topLayer && isFixed) {
|
||||
return rect;
|
||||
}
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
let scale = createCoords(1);
|
||||
const offsets = createCoords(0);
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isHTMLElement(offsetParent)) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent);
|
||||
scale = getScale(offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width: rect.width * scale.x,
|
||||
height: rect.height * scale.y,
|
||||
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
|
||||
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
|
||||
};
|
||||
}
|
||||
|
||||
function getClientRects(element) {
|
||||
return Array.from(element.getClientRects());
|
||||
}
|
||||
|
||||
function getWindowScrollBarX(element) {
|
||||
// If <html> has a CSS width greater than the viewport, then this will be
|
||||
// incorrect for RTL.
|
||||
return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
|
||||
}
|
||||
|
||||
// Gets the entire size of the scrollable document area, even extending outside
|
||||
// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
|
||||
function getDocumentRect(element) {
|
||||
const html = getDocumentElement(element);
|
||||
const scroll = getNodeScroll(element);
|
||||
const body = element.ownerDocument.body;
|
||||
const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
|
||||
const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
|
||||
let x = -scroll.scrollLeft + getWindowScrollBarX(element);
|
||||
const y = -scroll.scrollTop;
|
||||
if (getComputedStyle(body).direction === 'rtl') {
|
||||
x += max(html.clientWidth, body.clientWidth) - width;
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
function getViewportRect(element, strategy) {
|
||||
const win = getWindow(element);
|
||||
const html = getDocumentElement(element);
|
||||
const visualViewport = win.visualViewport;
|
||||
let width = html.clientWidth;
|
||||
let height = html.clientHeight;
|
||||
let x = 0;
|
||||
let y = 0;
|
||||
if (visualViewport) {
|
||||
width = visualViewport.width;
|
||||
height = visualViewport.height;
|
||||
const visualViewportBased = isWebKit();
|
||||
if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
|
||||
x = visualViewport.offsetLeft;
|
||||
y = visualViewport.offsetTop;
|
||||
}
|
||||
}
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
// Returns the inner client rect, subtracting scrollbars if present.
|
||||
function getInnerBoundingClientRect(element, strategy) {
|
||||
const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
|
||||
const top = clientRect.top + element.clientTop;
|
||||
const left = clientRect.left + element.clientLeft;
|
||||
const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
|
||||
const width = element.clientWidth * scale.x;
|
||||
const height = element.clientHeight * scale.y;
|
||||
const x = left * scale.x;
|
||||
const y = top * scale.y;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
|
||||
let rect;
|
||||
if (clippingAncestor === 'viewport') {
|
||||
rect = getViewportRect(element, strategy);
|
||||
} else if (clippingAncestor === 'document') {
|
||||
rect = getDocumentRect(getDocumentElement(element));
|
||||
} else if (isElement(clippingAncestor)) {
|
||||
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
|
||||
} else {
|
||||
const visualOffsets = getVisualOffsets(element);
|
||||
rect = {
|
||||
...clippingAncestor,
|
||||
x: clippingAncestor.x - visualOffsets.x,
|
||||
y: clippingAncestor.y - visualOffsets.y
|
||||
};
|
||||
}
|
||||
return core.rectToClientRect(rect);
|
||||
}
|
||||
function hasFixedPositionAncestor(element, stopNode) {
|
||||
const parentNode = getParentNode(element);
|
||||
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
|
||||
return false;
|
||||
}
|
||||
return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
|
||||
}
|
||||
|
||||
// A "clipping ancestor" is an `overflow` element with the characteristic of
|
||||
// clipping (or hiding) child elements. This returns all clipping ancestors
|
||||
// of the given element up the tree.
|
||||
function getClippingElementAncestors(element, cache) {
|
||||
const cachedResult = cache.get(element);
|
||||
if (cachedResult) {
|
||||
return cachedResult;
|
||||
}
|
||||
let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
|
||||
let currentContainingBlockComputedStyle = null;
|
||||
const elementIsFixed = getComputedStyle(element).position === 'fixed';
|
||||
let currentNode = elementIsFixed ? getParentNode(element) : element;
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
const computedStyle = getComputedStyle(currentNode);
|
||||
const currentNodeIsContaining = isContainingBlock(currentNode);
|
||||
if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
|
||||
currentContainingBlockComputedStyle = null;
|
||||
}
|
||||
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
|
||||
if (shouldDropCurrentNode) {
|
||||
// Drop non-containing blocks.
|
||||
result = result.filter(ancestor => ancestor !== currentNode);
|
||||
} else {
|
||||
// Record last containing block for next iteration.
|
||||
currentContainingBlockComputedStyle = computedStyle;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
cache.set(element, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Gets the maximum area that the element is visible in due to any number of
|
||||
// clipping ancestors.
|
||||
function getClippingRect(_ref) {
|
||||
let {
|
||||
element,
|
||||
boundary,
|
||||
rootBoundary,
|
||||
strategy
|
||||
} = _ref;
|
||||
const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
|
||||
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
|
||||
const firstClippingAncestor = clippingAncestors[0];
|
||||
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
|
||||
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
|
||||
accRect.top = max(rect.top, accRect.top);
|
||||
accRect.right = min(rect.right, accRect.right);
|
||||
accRect.bottom = min(rect.bottom, accRect.bottom);
|
||||
accRect.left = max(rect.left, accRect.left);
|
||||
return accRect;
|
||||
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
|
||||
return {
|
||||
width: clippingRect.right - clippingRect.left,
|
||||
height: clippingRect.bottom - clippingRect.top,
|
||||
x: clippingRect.left,
|
||||
y: clippingRect.top
|
||||
};
|
||||
}
|
||||
|
||||
function getDimensions(element) {
|
||||
const {
|
||||
width,
|
||||
height
|
||||
} = getCssDimensions(element);
|
||||
return {
|
||||
width,
|
||||
height
|
||||
};
|
||||
}
|
||||
|
||||
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
|
||||
const isOffsetParentAnElement = isHTMLElement(offsetParent);
|
||||
const documentElement = getDocumentElement(offsetParent);
|
||||
const isFixed = strategy === 'fixed';
|
||||
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
|
||||
let scroll = {
|
||||
scrollLeft: 0,
|
||||
scrollTop: 0
|
||||
};
|
||||
const offsets = createCoords(0);
|
||||
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
|
||||
if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
|
||||
scroll = getNodeScroll(offsetParent);
|
||||
}
|
||||
if (isOffsetParentAnElement) {
|
||||
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
|
||||
offsets.x = offsetRect.x + offsetParent.clientLeft;
|
||||
offsets.y = offsetRect.y + offsetParent.clientTop;
|
||||
} else if (documentElement) {
|
||||
offsets.x = getWindowScrollBarX(documentElement);
|
||||
}
|
||||
}
|
||||
const x = rect.left + scroll.scrollLeft - offsets.x;
|
||||
const y = rect.top + scroll.scrollTop - offsets.y;
|
||||
return {
|
||||
x,
|
||||
y,
|
||||
width: rect.width,
|
||||
height: rect.height
|
||||
};
|
||||
}
|
||||
|
||||
function isStaticPositioned(element) {
|
||||
return getComputedStyle(element).position === 'static';
|
||||
}
|
||||
|
||||
function getTrueOffsetParent(element, polyfill) {
|
||||
if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
|
||||
return null;
|
||||
}
|
||||
if (polyfill) {
|
||||
return polyfill(element);
|
||||
}
|
||||
return element.offsetParent;
|
||||
}
|
||||
|
||||
// Gets the closest ancestor positioned element. Handles some edge cases,
|
||||
// such as table ancestors and cross browser bugs.
|
||||
function getOffsetParent(element, polyfill) {
|
||||
const win = getWindow(element);
|
||||
if (isTopLayer(element)) {
|
||||
return win;
|
||||
}
|
||||
if (!isHTMLElement(element)) {
|
||||
let svgOffsetParent = getParentNode(element);
|
||||
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
|
||||
if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
|
||||
return svgOffsetParent;
|
||||
}
|
||||
svgOffsetParent = getParentNode(svgOffsetParent);
|
||||
}
|
||||
return win;
|
||||
}
|
||||
let offsetParent = getTrueOffsetParent(element, polyfill);
|
||||
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
|
||||
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
|
||||
}
|
||||
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
|
||||
return win;
|
||||
}
|
||||
return offsetParent || getContainingBlock(element) || win;
|
||||
}
|
||||
|
||||
const getElementRects = async function (data) {
|
||||
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
|
||||
const getDimensionsFn = this.getDimensions;
|
||||
const floatingDimensions = await getDimensionsFn(data.floating);
|
||||
return {
|
||||
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
|
||||
floating: {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: floatingDimensions.width,
|
||||
height: floatingDimensions.height
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
function isRTL(element) {
|
||||
return getComputedStyle(element).direction === 'rtl';
|
||||
}
|
||||
|
||||
const platform = {
|
||||
convertOffsetParentRelativeRectToViewportRelativeRect,
|
||||
getDocumentElement,
|
||||
getClippingRect,
|
||||
getOffsetParent,
|
||||
getElementRects,
|
||||
getClientRects,
|
||||
getDimensions,
|
||||
getScale,
|
||||
isElement,
|
||||
isRTL
|
||||
};
|
||||
|
||||
// https://samthor.au/2021/observing-dom/
|
||||
function observeMove(element, onMove) {
|
||||
let io = null;
|
||||
let timeoutId;
|
||||
const root = getDocumentElement(element);
|
||||
function cleanup() {
|
||||
var _io;
|
||||
clearTimeout(timeoutId);
|
||||
(_io = io) == null || _io.disconnect();
|
||||
io = null;
|
||||
}
|
||||
function refresh(skip, threshold) {
|
||||
if (skip === void 0) {
|
||||
skip = false;
|
||||
}
|
||||
if (threshold === void 0) {
|
||||
threshold = 1;
|
||||
}
|
||||
cleanup();
|
||||
const {
|
||||
left,
|
||||
top,
|
||||
width,
|
||||
height
|
||||
} = element.getBoundingClientRect();
|
||||
if (!skip) {
|
||||
onMove();
|
||||
}
|
||||
if (!width || !height) {
|
||||
return;
|
||||
}
|
||||
const insetTop = floor(top);
|
||||
const insetRight = floor(root.clientWidth - (left + width));
|
||||
const insetBottom = floor(root.clientHeight - (top + height));
|
||||
const insetLeft = floor(left);
|
||||
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
|
||||
const options = {
|
||||
rootMargin,
|
||||
threshold: max(0, min(1, threshold)) || 1
|
||||
};
|
||||
let isFirstUpdate = true;
|
||||
function handleObserve(entries) {
|
||||
const ratio = entries[0].intersectionRatio;
|
||||
if (ratio !== threshold) {
|
||||
if (!isFirstUpdate) {
|
||||
return refresh();
|
||||
}
|
||||
if (!ratio) {
|
||||
// If the reference is clipped, the ratio is 0. Throttle the refresh
|
||||
// to prevent an infinite loop of updates.
|
||||
timeoutId = setTimeout(() => {
|
||||
refresh(false, 1e-7);
|
||||
}, 1000);
|
||||
} else {
|
||||
refresh(false, ratio);
|
||||
}
|
||||
}
|
||||
isFirstUpdate = false;
|
||||
}
|
||||
|
||||
// Older browsers don't support a `document` as the root and will throw an
|
||||
// error.
|
||||
try {
|
||||
io = new IntersectionObserver(handleObserve, {
|
||||
...options,
|
||||
// Handle <iframe>s
|
||||
root: root.ownerDocument
|
||||
});
|
||||
} catch (e) {
|
||||
io = new IntersectionObserver(handleObserve, options);
|
||||
}
|
||||
io.observe(element);
|
||||
}
|
||||
refresh(true);
|
||||
return cleanup;
|
||||
}
|
||||
|
||||
/**
|
||||
* Automatically updates the position of the floating element when necessary.
|
||||
* Should only be called when the floating element is mounted on the DOM or
|
||||
* visible on the screen.
|
||||
* @returns cleanup function that should be invoked when the floating element is
|
||||
* removed from the DOM or hidden from the screen.
|
||||
* @see https://floating-ui.com/docs/autoUpdate
|
||||
*/
|
||||
function autoUpdate(reference, floating, update, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
ancestorScroll = true,
|
||||
ancestorResize = true,
|
||||
elementResize = typeof ResizeObserver === 'function',
|
||||
layoutShift = typeof IntersectionObserver === 'function',
|
||||
animationFrame = false
|
||||
} = options;
|
||||
const referenceEl = unwrapElement(reference);
|
||||
const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.addEventListener('scroll', update, {
|
||||
passive: true
|
||||
});
|
||||
ancestorResize && ancestor.addEventListener('resize', update);
|
||||
});
|
||||
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
|
||||
let reobserveFrame = -1;
|
||||
let resizeObserver = null;
|
||||
if (elementResize) {
|
||||
resizeObserver = new ResizeObserver(_ref => {
|
||||
let [firstEntry] = _ref;
|
||||
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
|
||||
// Prevent update loops when using the `size` middleware.
|
||||
// https://github.com/floating-ui/floating-ui/issues/1740
|
||||
resizeObserver.unobserve(floating);
|
||||
cancelAnimationFrame(reobserveFrame);
|
||||
reobserveFrame = requestAnimationFrame(() => {
|
||||
var _resizeObserver;
|
||||
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
|
||||
});
|
||||
}
|
||||
update();
|
||||
});
|
||||
if (referenceEl && !animationFrame) {
|
||||
resizeObserver.observe(referenceEl);
|
||||
}
|
||||
resizeObserver.observe(floating);
|
||||
}
|
||||
let frameId;
|
||||
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
|
||||
if (animationFrame) {
|
||||
frameLoop();
|
||||
}
|
||||
function frameLoop() {
|
||||
const nextRefRect = getBoundingClientRect(reference);
|
||||
if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
|
||||
update();
|
||||
}
|
||||
prevRefRect = nextRefRect;
|
||||
frameId = requestAnimationFrame(frameLoop);
|
||||
}
|
||||
update();
|
||||
return () => {
|
||||
var _resizeObserver2;
|
||||
ancestors.forEach(ancestor => {
|
||||
ancestorScroll && ancestor.removeEventListener('scroll', update);
|
||||
ancestorResize && ancestor.removeEventListener('resize', update);
|
||||
});
|
||||
cleanupIo == null || cleanupIo();
|
||||
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
|
||||
resizeObserver = null;
|
||||
if (animationFrame) {
|
||||
cancelAnimationFrame(frameId);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves with an object of overflow side offsets that determine how much the
|
||||
* element is overflowing a given clipping boundary on each side.
|
||||
* - positive = overflowing the boundary by that number of pixels
|
||||
* - negative = how many pixels left before it will overflow
|
||||
* - 0 = lies flush with the boundary
|
||||
* @see https://floating-ui.com/docs/detectOverflow
|
||||
*/
|
||||
const detectOverflow = core.detectOverflow;
|
||||
|
||||
/**
|
||||
* Modifies the placement by translating the floating element along the
|
||||
* specified axes.
|
||||
* A number (shorthand for `mainAxis` or distance), or an axes configuration
|
||||
* object may be passed.
|
||||
* @see https://floating-ui.com/docs/offset
|
||||
*/
|
||||
const offset = core.offset;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by choosing the placement
|
||||
* that has the most space available automatically, without needing to specify a
|
||||
* preferred placement. Alternative to `flip`.
|
||||
* @see https://floating-ui.com/docs/autoPlacement
|
||||
*/
|
||||
const autoPlacement = core.autoPlacement;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by shifting it in order to
|
||||
* keep it in view when it will overflow the clipping boundary.
|
||||
* @see https://floating-ui.com/docs/shift
|
||||
*/
|
||||
const shift = core.shift;
|
||||
|
||||
/**
|
||||
* Optimizes the visibility of the floating element by flipping the `placement`
|
||||
* in order to keep it in view when the preferred placement(s) will overflow the
|
||||
* clipping boundary. Alternative to `autoPlacement`.
|
||||
* @see https://floating-ui.com/docs/flip
|
||||
*/
|
||||
const flip = core.flip;
|
||||
|
||||
/**
|
||||
* Provides data that allows you to change the size of the floating element —
|
||||
* for instance, prevent it from overflowing the clipping boundary or match the
|
||||
* width of the reference element.
|
||||
* @see https://floating-ui.com/docs/size
|
||||
*/
|
||||
const size = core.size;
|
||||
|
||||
/**
|
||||
* Provides data to hide the floating element in applicable situations, such as
|
||||
* when it is not in the same clipping context as the reference element.
|
||||
* @see https://floating-ui.com/docs/hide
|
||||
*/
|
||||
const hide = core.hide;
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = core.arrow;
|
||||
|
||||
/**
|
||||
* Provides improved positioning for inline reference elements that can span
|
||||
* over multiple lines, such as hyperlinks or range selections.
|
||||
* @see https://floating-ui.com/docs/inline
|
||||
*/
|
||||
const inline = core.inline;
|
||||
|
||||
/**
|
||||
* Built-in `limiter` that will stop `shift()` at a certain point.
|
||||
*/
|
||||
const limitShift = core.limitShift;
|
||||
|
||||
/**
|
||||
* Computes the `x` and `y` coordinates that will place the floating element
|
||||
* next to a given reference element.
|
||||
*/
|
||||
const computePosition = (reference, floating, options) => {
|
||||
// This caches the expensive `getClippingElementAncestors` function so that
|
||||
// multiple lifecycle resets re-use the same result. It only lives for a
|
||||
// single call. If other functions become expensive, we can add them as well.
|
||||
const cache = new Map();
|
||||
const mergedOptions = {
|
||||
platform,
|
||||
...options
|
||||
};
|
||||
const platformWithCache = {
|
||||
...mergedOptions.platform,
|
||||
_c: cache
|
||||
};
|
||||
return core.computePosition(reference, floating, {
|
||||
...mergedOptions,
|
||||
platform: platformWithCache
|
||||
});
|
||||
};
|
||||
|
||||
exports.arrow = arrow;
|
||||
exports.autoPlacement = autoPlacement;
|
||||
exports.autoUpdate = autoUpdate;
|
||||
exports.computePosition = computePosition;
|
||||
exports.detectOverflow = detectOverflow;
|
||||
exports.flip = flip;
|
||||
exports.getOverflowAncestors = getOverflowAncestors;
|
||||
exports.hide = hide;
|
||||
exports.inline = inline;
|
||||
exports.limitShift = limitShift;
|
||||
exports.offset = offset;
|
||||
exports.platform = platform;
|
||||
exports.shift = shift;
|
||||
exports.size = size;
|
||||
|
||||
}));
|
||||
+1
@@ -0,0 +1 @@
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("@floating-ui/core")):"function"==typeof define&&define.amd?define(["exports","@floating-ui/core"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).FloatingUIDOM={},t.FloatingUICore)}(this,(function(t,e){"use strict";const n=Math.min,o=Math.max,i=Math.round,r=Math.floor,c=t=>({x:t,y:t});function l(t){return u(t)?(t.nodeName||"").toLowerCase():"#document"}function s(t){var e;return(null==t||null==(e=t.ownerDocument)?void 0:e.defaultView)||window}function f(t){var e;return null==(e=(u(t)?t.ownerDocument:t.document)||window.document)?void 0:e.documentElement}function u(t){return t instanceof Node||t instanceof s(t).Node}function a(t){return t instanceof Element||t instanceof s(t).Element}function d(t){return t instanceof HTMLElement||t instanceof s(t).HTMLElement}function h(t){return"undefined"!=typeof ShadowRoot&&(t instanceof ShadowRoot||t instanceof s(t).ShadowRoot)}function p(t){const{overflow:e,overflowX:n,overflowY:o,display:i}=v(t);return/auto|scroll|overlay|hidden|clip/.test(e+o+n)&&!["inline","contents"].includes(i)}function m(t){return["table","td","th"].includes(l(t))}function g(t){const e=y(),n=v(t);return"none"!==n.transform||"none"!==n.perspective||!!n.containerType&&"normal"!==n.containerType||!e&&!!n.backdropFilter&&"none"!==n.backdropFilter||!e&&!!n.filter&&"none"!==n.filter||["transform","perspective","filter"].some((t=>(n.willChange||"").includes(t)))||["paint","layout","strict","content"].some((t=>(n.contain||"").includes(t)))}function y(){return!("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function w(t){return["html","body","#document"].includes(l(t))}function v(t){return s(t).getComputedStyle(t)}function x(t){return a(t)?{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}:{scrollLeft:t.pageXOffset,scrollTop:t.pageYOffset}}function b(t){if("html"===l(t))return t;const e=t.assignedSlot||t.parentNode||h(t)&&t.host||f(t);return h(e)?e.host:e}function T(t){const e=b(t);return w(e)?t.ownerDocument?t.ownerDocument.body:t.body:d(e)&&p(e)?e:T(e)}function L(t,e,n){var o;void 0===e&&(e=[]),void 0===n&&(n=!0);const i=T(t),r=i===(null==(o=t.ownerDocument)?void 0:o.body),c=s(i);return r?e.concat(c,c.visualViewport||[],p(i)?i:[],c.frameElement&&n?L(c.frameElement):[]):e.concat(i,L(i,[],n))}function R(t){const e=v(t);let n=parseFloat(e.width)||0,o=parseFloat(e.height)||0;const r=d(t),c=r?t.offsetWidth:n,l=r?t.offsetHeight:o,s=i(n)!==c||i(o)!==l;return s&&(n=c,o=l),{width:n,height:o,$:s}}function E(t){return a(t)?t:t.contextElement}function C(t){const e=E(t);if(!d(e))return c(1);const n=e.getBoundingClientRect(),{width:o,height:r,$:l}=R(e);let s=(l?i(n.width):n.width)/o,f=(l?i(n.height):n.height)/r;return s&&Number.isFinite(s)||(s=1),f&&Number.isFinite(f)||(f=1),{x:s,y:f}}const S=c(0);function F(t){const e=s(t);return y()&&e.visualViewport?{x:e.visualViewport.offsetLeft,y:e.visualViewport.offsetTop}:S}function O(t,n,o,i){void 0===n&&(n=!1),void 0===o&&(o=!1);const r=t.getBoundingClientRect(),l=E(t);let f=c(1);n&&(i?a(i)&&(f=C(i)):f=C(t));const u=function(t,e,n){return void 0===e&&(e=!1),!(!n||e&&n!==s(t))&&e}(l,o,i)?F(l):c(0);let d=(r.left+u.x)/f.x,h=(r.top+u.y)/f.y,p=r.width/f.x,m=r.height/f.y;if(l){const t=s(l),e=i&&a(i)?s(i):i;let n=t,o=n.frameElement;for(;o&&i&&e!==n;){const t=C(o),e=o.getBoundingClientRect(),i=v(o),r=e.left+(o.clientLeft+parseFloat(i.paddingLeft))*t.x,c=e.top+(o.clientTop+parseFloat(i.paddingTop))*t.y;d*=t.x,h*=t.y,p*=t.x,m*=t.y,d+=r,h+=c,n=s(o),o=n.frameElement}}return e.rectToClientRect({width:p,height:m,x:d,y:h})}const D=[":popover-open",":modal"];function H(t){return D.some((e=>{try{return t.matches(e)}catch(t){return!1}}))}function W(t){return O(f(t)).left+x(t).scrollLeft}function M(t,n,i){let r;if("viewport"===n)r=function(t,e){const n=s(t),o=f(t),i=n.visualViewport;let r=o.clientWidth,c=o.clientHeight,l=0,u=0;if(i){r=i.width,c=i.height;const t=y();(!t||t&&"fixed"===e)&&(l=i.offsetLeft,u=i.offsetTop)}return{width:r,height:c,x:l,y:u}}(t,i);else if("document"===n)r=function(t){const e=f(t),n=x(t),i=t.ownerDocument.body,r=o(e.scrollWidth,e.clientWidth,i.scrollWidth,i.clientWidth),c=o(e.scrollHeight,e.clientHeight,i.scrollHeight,i.clientHeight);let l=-n.scrollLeft+W(t);const s=-n.scrollTop;return"rtl"===v(i).direction&&(l+=o(e.clientWidth,i.clientWidth)-r),{width:r,height:c,x:l,y:s}}(f(t));else if(a(n))r=function(t,e){const n=O(t,!0,"fixed"===e),o=n.top+t.clientTop,i=n.left+t.clientLeft,r=d(t)?C(t):c(1);return{width:t.clientWidth*r.x,height:t.clientHeight*r.y,x:i*r.x,y:o*r.y}}(n,i);else{const e=F(t);r={...n,x:n.x-e.x,y:n.y-e.y}}return e.rectToClientRect(r)}function P(t,e){const n=b(t);return!(n===e||!a(n)||w(n))&&("fixed"===v(n).position||P(n,e))}function z(t,e,n){const o=d(e),i=f(e),r="fixed"===n,s=O(t,!0,r,e);let u={scrollLeft:0,scrollTop:0};const a=c(0);if(o||!o&&!r)if(("body"!==l(e)||p(i))&&(u=x(e)),o){const t=O(e,!0,r,e);a.x=t.x+e.clientLeft,Line truncated
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
{
|
||||
"name": "@floating-ui/dom",
|
||||
"version": "1.6.5",
|
||||
"description": "Floating UI for the web",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "./dist/floating-ui.dom.umd.js",
|
||||
"module": "./dist/floating-ui.dom.esm.js",
|
||||
"unpkg": "./dist/floating-ui.dom.umd.min.js",
|
||||
"types": "./dist/floating-ui.dom.d.ts",
|
||||
"exports": {
|
||||
"./package.json": "./package.json",
|
||||
".": {
|
||||
"import": {
|
||||
"types": "./dist/floating-ui.dom.d.mts",
|
||||
"default": "./dist/floating-ui.dom.mjs"
|
||||
},
|
||||
"types": "./dist/floating-ui.dom.d.ts",
|
||||
"module": "./dist/floating-ui.dom.esm.js",
|
||||
"default": "./dist/floating-ui.dom.umd.js"
|
||||
}
|
||||
},
|
||||
"sideEffects": false,
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"author": "atomiks",
|
||||
"license": "MIT",
|
||||
"bugs": "https://github.com/floating-ui/floating-ui",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/floating-ui/floating-ui.git",
|
||||
"directory": "packages/dom"
|
||||
},
|
||||
"homepage": "https://floating-ui.com",
|
||||
"keywords": [
|
||||
"tooltip",
|
||||
"popover",
|
||||
"dropdown",
|
||||
"menu",
|
||||
"popup",
|
||||
"positioning"
|
||||
],
|
||||
"dependencies": {
|
||||
"@floating-ui/core": "^1.0.0",
|
||||
"@floating-ui/utils": "^0.2.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/react": "^18.2.46",
|
||||
"@types/react-dom": "^18.2.18",
|
||||
"@vitejs/plugin-react": "^4.2.1",
|
||||
"react": "^18.2.0",
|
||||
"react-dom": "^18.2.0",
|
||||
"react-router-dom": "^6.21.1",
|
||||
"config": "0.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint .",
|
||||
"format": "prettier --write .",
|
||||
"clean": "rimraf dist out-tsc test-results",
|
||||
"dev": "vite",
|
||||
"build": "rollup -c",
|
||||
"build:api": "build-api --tsc tsconfig.lib.json",
|
||||
"test": "vitest run",
|
||||
"test:watch": "vitest watch",
|
||||
"publint": "publint",
|
||||
"playwright": "playwright test ./test/functional",
|
||||
"typecheck": "tsc -b"
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2021-present Floating UI contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
# @floating-ui/react-dom
|
||||
|
||||
This is the library to use Floating UI with React DOM.
|
||||
+258
@@ -0,0 +1,258 @@
|
||||
import { AlignedPlacement } from '@floating-ui/dom';
|
||||
import { Alignment } from '@floating-ui/dom';
|
||||
import { autoPlacement } from '@floating-ui/dom';
|
||||
import { AutoPlacementOptions } from '@floating-ui/dom';
|
||||
import { autoUpdate } from '@floating-ui/dom';
|
||||
import { AutoUpdateOptions } from '@floating-ui/dom';
|
||||
import { Axis } from '@floating-ui/dom';
|
||||
import { Boundary } from '@floating-ui/dom';
|
||||
import { ClientRectObject } from '@floating-ui/dom';
|
||||
import { computePosition } from '@floating-ui/dom';
|
||||
import { ComputePositionConfig } from '@floating-ui/dom';
|
||||
import { ComputePositionReturn } from '@floating-ui/dom';
|
||||
import { Coords } from '@floating-ui/dom';
|
||||
import type { Derivable } from '@floating-ui/dom';
|
||||
import { detectOverflow } from '@floating-ui/dom';
|
||||
import { DetectOverflowOptions } from '@floating-ui/dom';
|
||||
import { Dimensions } from '@floating-ui/dom';
|
||||
import { ElementContext } from '@floating-ui/dom';
|
||||
import { ElementRects } from '@floating-ui/dom';
|
||||
import { Elements } from '@floating-ui/dom';
|
||||
import { flip } from '@floating-ui/dom';
|
||||
import { FlipOptions } from '@floating-ui/dom';
|
||||
import { FloatingElement } from '@floating-ui/dom';
|
||||
import { getOverflowAncestors } from '@floating-ui/dom';
|
||||
import { hide } from '@floating-ui/dom';
|
||||
import { HideOptions } from '@floating-ui/dom';
|
||||
import { inline } from '@floating-ui/dom';
|
||||
import { InlineOptions } from '@floating-ui/dom';
|
||||
import { Length } from '@floating-ui/dom';
|
||||
import { limitShift } from '@floating-ui/dom';
|
||||
import { Middleware } from '@floating-ui/dom';
|
||||
import { MiddlewareArguments } from '@floating-ui/dom';
|
||||
import { MiddlewareData } from '@floating-ui/dom';
|
||||
import { MiddlewareReturn } from '@floating-ui/dom';
|
||||
import { MiddlewareState } from '@floating-ui/dom';
|
||||
import { NodeScroll } from '@floating-ui/dom';
|
||||
import { offset } from '@floating-ui/dom';
|
||||
import { OffsetOptions } from '@floating-ui/dom';
|
||||
import { Padding } from '@floating-ui/dom';
|
||||
import { Placement } from '@floating-ui/dom';
|
||||
import { Platform } from '@floating-ui/dom';
|
||||
import { platform } from '@floating-ui/dom';
|
||||
import type * as React from 'react';
|
||||
import { Rect } from '@floating-ui/dom';
|
||||
import { ReferenceElement } from '@floating-ui/dom';
|
||||
import { RootBoundary } from '@floating-ui/dom';
|
||||
import { shift } from '@floating-ui/dom';
|
||||
import { ShiftOptions } from '@floating-ui/dom';
|
||||
import { Side } from '@floating-ui/dom';
|
||||
import { SideObject } from '@floating-ui/dom';
|
||||
import { size } from '@floating-ui/dom';
|
||||
import { SizeOptions } from '@floating-ui/dom';
|
||||
import { Strategy } from '@floating-ui/dom';
|
||||
import { VirtualElement } from '@floating-ui/dom';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* This wraps the core `arrow` middleware to allow React refs as the element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare interface ArrowOptions {
|
||||
/**
|
||||
* The arrow element to be positioned.
|
||||
* @default undefined
|
||||
*/
|
||||
element: React.MutableRefObject<Element | null> | Element | null;
|
||||
/**
|
||||
* The padding between the arrow element and the floating element edges.
|
||||
* Useful when the floating element has rounded corners.
|
||||
* @default 0
|
||||
*/
|
||||
padding?: Padding;
|
||||
}
|
||||
|
||||
export { autoPlacement }
|
||||
|
||||
export { AutoPlacementOptions }
|
||||
|
||||
export { autoUpdate }
|
||||
|
||||
export { AutoUpdateOptions }
|
||||
|
||||
export { Axis }
|
||||
|
||||
export { Boundary }
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
export { computePosition }
|
||||
|
||||
export { ComputePositionConfig }
|
||||
|
||||
export { ComputePositionReturn }
|
||||
|
||||
export { Coords }
|
||||
|
||||
export { detectOverflow }
|
||||
|
||||
export { DetectOverflowOptions }
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export { ElementContext }
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export { Elements }
|
||||
|
||||
export { flip }
|
||||
|
||||
export { FlipOptions }
|
||||
|
||||
export { FloatingElement }
|
||||
|
||||
export { getOverflowAncestors }
|
||||
|
||||
export { hide }
|
||||
|
||||
export { HideOptions }
|
||||
|
||||
export { inline }
|
||||
|
||||
export { InlineOptions }
|
||||
|
||||
export { Length }
|
||||
|
||||
export { limitShift }
|
||||
|
||||
export { Middleware }
|
||||
|
||||
export { MiddlewareArguments }
|
||||
|
||||
export { MiddlewareData }
|
||||
|
||||
export { MiddlewareReturn }
|
||||
|
||||
export { MiddlewareState }
|
||||
|
||||
export { NodeScroll }
|
||||
|
||||
export { offset }
|
||||
|
||||
export { OffsetOptions }
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
export { Platform }
|
||||
|
||||
export { platform }
|
||||
|
||||
declare type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
|
||||
export { Rect }
|
||||
|
||||
export { ReferenceElement }
|
||||
|
||||
export declare type ReferenceType = Element | VirtualElement;
|
||||
|
||||
export { RootBoundary }
|
||||
|
||||
export { shift }
|
||||
|
||||
export { ShiftOptions }
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
export { size }
|
||||
|
||||
export { SizeOptions }
|
||||
|
||||
export { Strategy }
|
||||
|
||||
/**
|
||||
* Provides data to position a floating element.
|
||||
* @see https://floating-ui.com/docs/useFloating
|
||||
*/
|
||||
export declare function useFloating<RT extends ReferenceType = ReferenceType>(options?: UseFloatingOptions): UseFloatingReturn<RT>;
|
||||
|
||||
export declare type UseFloatingData = Prettify<ComputePositionReturn & {
|
||||
isPositioned: boolean;
|
||||
}>;
|
||||
|
||||
export declare type UseFloatingOptions<RT extends ReferenceType = ReferenceType> = Prettify<Partial<ComputePositionConfig> & {
|
||||
/**
|
||||
* A callback invoked when both the reference and floating elements are
|
||||
* mounted, and cleaned up when either is unmounted. This is useful for
|
||||
* setting up event listeners (e.g. pass `autoUpdate`).
|
||||
*/
|
||||
whileElementsMounted?: (reference: RT, floating: HTMLElement, update: () => void) => () => void;
|
||||
elements?: {
|
||||
reference?: RT | null;
|
||||
floating?: HTMLElement | null;
|
||||
};
|
||||
/**
|
||||
* The `open` state of the floating element to synchronize with the
|
||||
* `isPositioned` value.
|
||||
*/
|
||||
open?: boolean;
|
||||
/**
|
||||
* Whether to use `transform` for positioning instead of `top` and `left`
|
||||
* (layout) in the `floatingStyles` object.
|
||||
*/
|
||||
transform?: boolean;
|
||||
}>;
|
||||
|
||||
export declare type UseFloatingReturn<RT extends ReferenceType = ReferenceType> = Prettify<UseFloatingData & {
|
||||
/**
|
||||
* Update the position of the floating element, re-rendering the component
|
||||
* if required.
|
||||
*/
|
||||
update: () => void;
|
||||
/**
|
||||
* Pre-configured positioning styles to apply to the floating element.
|
||||
*/
|
||||
floatingStyles: React.CSSProperties;
|
||||
/**
|
||||
* Object containing the reference and floating refs and reactive setters.
|
||||
*/
|
||||
refs: {
|
||||
/**
|
||||
* A React ref to the reference element.
|
||||
*/
|
||||
reference: React.MutableRefObject<RT | null>;
|
||||
/**
|
||||
* A React ref to the floating element.
|
||||
*/
|
||||
floating: React.MutableRefObject<HTMLElement | null>;
|
||||
/**
|
||||
* A callback to set the reference element (reactive).
|
||||
*/
|
||||
setReference: (node: RT | null) => void;
|
||||
/**
|
||||
* A callback to set the floating element (reactive).
|
||||
*/
|
||||
setFloating: (node: HTMLElement | null) => void;
|
||||
};
|
||||
elements: {
|
||||
reference: RT | null;
|
||||
floating: HTMLElement | null;
|
||||
};
|
||||
}>;
|
||||
|
||||
export { VirtualElement }
|
||||
|
||||
export { }
|
||||
+258
@@ -0,0 +1,258 @@
|
||||
import { AlignedPlacement } from '@floating-ui/dom';
|
||||
import { Alignment } from '@floating-ui/dom';
|
||||
import { autoPlacement } from '@floating-ui/dom';
|
||||
import { AutoPlacementOptions } from '@floating-ui/dom';
|
||||
import { autoUpdate } from '@floating-ui/dom';
|
||||
import { AutoUpdateOptions } from '@floating-ui/dom';
|
||||
import { Axis } from '@floating-ui/dom';
|
||||
import { Boundary } from '@floating-ui/dom';
|
||||
import { ClientRectObject } from '@floating-ui/dom';
|
||||
import { computePosition } from '@floating-ui/dom';
|
||||
import { ComputePositionConfig } from '@floating-ui/dom';
|
||||
import { ComputePositionReturn } from '@floating-ui/dom';
|
||||
import { Coords } from '@floating-ui/dom';
|
||||
import type { Derivable } from '@floating-ui/dom';
|
||||
import { detectOverflow } from '@floating-ui/dom';
|
||||
import { DetectOverflowOptions } from '@floating-ui/dom';
|
||||
import { Dimensions } from '@floating-ui/dom';
|
||||
import { ElementContext } from '@floating-ui/dom';
|
||||
import { ElementRects } from '@floating-ui/dom';
|
||||
import { Elements } from '@floating-ui/dom';
|
||||
import { flip } from '@floating-ui/dom';
|
||||
import { FlipOptions } from '@floating-ui/dom';
|
||||
import { FloatingElement } from '@floating-ui/dom';
|
||||
import { getOverflowAncestors } from '@floating-ui/dom';
|
||||
import { hide } from '@floating-ui/dom';
|
||||
import { HideOptions } from '@floating-ui/dom';
|
||||
import { inline } from '@floating-ui/dom';
|
||||
import { InlineOptions } from '@floating-ui/dom';
|
||||
import { Length } from '@floating-ui/dom';
|
||||
import { limitShift } from '@floating-ui/dom';
|
||||
import { Middleware } from '@floating-ui/dom';
|
||||
import { MiddlewareArguments } from '@floating-ui/dom';
|
||||
import { MiddlewareData } from '@floating-ui/dom';
|
||||
import { MiddlewareReturn } from '@floating-ui/dom';
|
||||
import { MiddlewareState } from '@floating-ui/dom';
|
||||
import { NodeScroll } from '@floating-ui/dom';
|
||||
import { offset } from '@floating-ui/dom';
|
||||
import { OffsetOptions } from '@floating-ui/dom';
|
||||
import { Padding } from '@floating-ui/dom';
|
||||
import { Placement } from '@floating-ui/dom';
|
||||
import { Platform } from '@floating-ui/dom';
|
||||
import { platform } from '@floating-ui/dom';
|
||||
import type * as React from 'react';
|
||||
import { Rect } from '@floating-ui/dom';
|
||||
import { ReferenceElement } from '@floating-ui/dom';
|
||||
import { RootBoundary } from '@floating-ui/dom';
|
||||
import { shift } from '@floating-ui/dom';
|
||||
import { ShiftOptions } from '@floating-ui/dom';
|
||||
import { Side } from '@floating-ui/dom';
|
||||
import { SideObject } from '@floating-ui/dom';
|
||||
import { size } from '@floating-ui/dom';
|
||||
import { SizeOptions } from '@floating-ui/dom';
|
||||
import { Strategy } from '@floating-ui/dom';
|
||||
import { VirtualElement } from '@floating-ui/dom';
|
||||
|
||||
export { AlignedPlacement }
|
||||
|
||||
export { Alignment }
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* This wraps the core `arrow` middleware to allow React refs as the element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
export declare const arrow: (options: ArrowOptions | Derivable<ArrowOptions>) => Middleware;
|
||||
|
||||
export declare interface ArrowOptions {
|
||||
/**
|
||||
* The arrow element to be positioned.
|
||||
* @default undefined
|
||||
*/
|
||||
element: React.MutableRefObject<Element | null> | Element | null;
|
||||
/**
|
||||
* The padding between the arrow element and the floating element edges.
|
||||
* Useful when the floating element has rounded corners.
|
||||
* @default 0
|
||||
*/
|
||||
padding?: Padding;
|
||||
}
|
||||
|
||||
export { autoPlacement }
|
||||
|
||||
export { AutoPlacementOptions }
|
||||
|
||||
export { autoUpdate }
|
||||
|
||||
export { AutoUpdateOptions }
|
||||
|
||||
export { Axis }
|
||||
|
||||
export { Boundary }
|
||||
|
||||
export { ClientRectObject }
|
||||
|
||||
export { computePosition }
|
||||
|
||||
export { ComputePositionConfig }
|
||||
|
||||
export { ComputePositionReturn }
|
||||
|
||||
export { Coords }
|
||||
|
||||
export { detectOverflow }
|
||||
|
||||
export { DetectOverflowOptions }
|
||||
|
||||
export { Dimensions }
|
||||
|
||||
export { ElementContext }
|
||||
|
||||
export { ElementRects }
|
||||
|
||||
export { Elements }
|
||||
|
||||
export { flip }
|
||||
|
||||
export { FlipOptions }
|
||||
|
||||
export { FloatingElement }
|
||||
|
||||
export { getOverflowAncestors }
|
||||
|
||||
export { hide }
|
||||
|
||||
export { HideOptions }
|
||||
|
||||
export { inline }
|
||||
|
||||
export { InlineOptions }
|
||||
|
||||
export { Length }
|
||||
|
||||
export { limitShift }
|
||||
|
||||
export { Middleware }
|
||||
|
||||
export { MiddlewareArguments }
|
||||
|
||||
export { MiddlewareData }
|
||||
|
||||
export { MiddlewareReturn }
|
||||
|
||||
export { MiddlewareState }
|
||||
|
||||
export { NodeScroll }
|
||||
|
||||
export { offset }
|
||||
|
||||
export { OffsetOptions }
|
||||
|
||||
export { Padding }
|
||||
|
||||
export { Placement }
|
||||
|
||||
export { Platform }
|
||||
|
||||
export { platform }
|
||||
|
||||
declare type Prettify<T> = {
|
||||
[K in keyof T]: T[K];
|
||||
} & {};
|
||||
|
||||
export { Rect }
|
||||
|
||||
export { ReferenceElement }
|
||||
|
||||
export declare type ReferenceType = Element | VirtualElement;
|
||||
|
||||
export { RootBoundary }
|
||||
|
||||
export { shift }
|
||||
|
||||
export { ShiftOptions }
|
||||
|
||||
export { Side }
|
||||
|
||||
export { SideObject }
|
||||
|
||||
export { size }
|
||||
|
||||
export { SizeOptions }
|
||||
|
||||
export { Strategy }
|
||||
|
||||
/**
|
||||
* Provides data to position a floating element.
|
||||
* @see https://floating-ui.com/docs/useFloating
|
||||
*/
|
||||
export declare function useFloating<RT extends ReferenceType = ReferenceType>(options?: UseFloatingOptions): UseFloatingReturn<RT>;
|
||||
|
||||
export declare type UseFloatingData = Prettify<ComputePositionReturn & {
|
||||
isPositioned: boolean;
|
||||
}>;
|
||||
|
||||
export declare type UseFloatingOptions<RT extends ReferenceType = ReferenceType> = Prettify<Partial<ComputePositionConfig> & {
|
||||
/**
|
||||
* A callback invoked when both the reference and floating elements are
|
||||
* mounted, and cleaned up when either is unmounted. This is useful for
|
||||
* setting up event listeners (e.g. pass `autoUpdate`).
|
||||
*/
|
||||
whileElementsMounted?: (reference: RT, floating: HTMLElement, update: () => void) => () => void;
|
||||
elements?: {
|
||||
reference?: RT | null;
|
||||
floating?: HTMLElement | null;
|
||||
};
|
||||
/**
|
||||
* The `open` state of the floating element to synchronize with the
|
||||
* `isPositioned` value.
|
||||
*/
|
||||
open?: boolean;
|
||||
/**
|
||||
* Whether to use `transform` for positioning instead of `top` and `left`
|
||||
* (layout) in the `floatingStyles` object.
|
||||
*/
|
||||
transform?: boolean;
|
||||
}>;
|
||||
|
||||
export declare type UseFloatingReturn<RT extends ReferenceType = ReferenceType> = Prettify<UseFloatingData & {
|
||||
/**
|
||||
* Update the position of the floating element, re-rendering the component
|
||||
* if required.
|
||||
*/
|
||||
update: () => void;
|
||||
/**
|
||||
* Pre-configured positioning styles to apply to the floating element.
|
||||
*/
|
||||
floatingStyles: React.CSSProperties;
|
||||
/**
|
||||
* Object containing the reference and floating refs and reactive setters.
|
||||
*/
|
||||
refs: {
|
||||
/**
|
||||
* A React ref to the reference element.
|
||||
*/
|
||||
reference: React.MutableRefObject<RT | null>;
|
||||
/**
|
||||
* A React ref to the floating element.
|
||||
*/
|
||||
floating: React.MutableRefObject<HTMLElement | null>;
|
||||
/**
|
||||
* A callback to set the reference element (reactive).
|
||||
*/
|
||||
setReference: (node: RT | null) => void;
|
||||
/**
|
||||
* A callback to set the floating element (reactive).
|
||||
*/
|
||||
setFloating: (node: HTMLElement | null) => void;
|
||||
};
|
||||
elements: {
|
||||
reference: RT | null;
|
||||
floating: HTMLElement | null;
|
||||
};
|
||||
}>;
|
||||
|
||||
export { VirtualElement }
|
||||
|
||||
export { }
|
||||
+269
@@ -0,0 +1,269 @@
|
||||
import { arrow as arrow$1, computePosition } from '@floating-ui/dom';
|
||||
export { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';
|
||||
import * as React from 'react';
|
||||
import { useLayoutEffect, useEffect } from 'react';
|
||||
import * as ReactDOM from 'react-dom';
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* This wraps the core `arrow` middleware to allow React refs as the element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = options => {
|
||||
function isRef(value) {
|
||||
return {}.hasOwnProperty.call(value, 'current');
|
||||
}
|
||||
return {
|
||||
name: 'arrow',
|
||||
options,
|
||||
fn(state) {
|
||||
const {
|
||||
element,
|
||||
padding
|
||||
} = typeof options === 'function' ? options(state) : options;
|
||||
if (element && isRef(element)) {
|
||||
if (element.current != null) {
|
||||
return arrow$1({
|
||||
element: element.current,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
if (element) {
|
||||
return arrow$1({
|
||||
element,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
var index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;
|
||||
|
||||
// Fork of `fast-deep-equal` that only does the comparisons we need and compares
|
||||
// functions
|
||||
function deepEqual(a, b) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (typeof a !== typeof b) {
|
||||
return false;
|
||||
}
|
||||
if (typeof a === 'function' && a.toString() === b.toString()) {
|
||||
return true;
|
||||
}
|
||||
let length;
|
||||
let i;
|
||||
let keys;
|
||||
if (a && b && typeof a === 'object') {
|
||||
if (Array.isArray(a)) {
|
||||
length = a.length;
|
||||
if (length !== b.length) return false;
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!deepEqual(a[i], b[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
keys = Object.keys(a);
|
||||
length = keys.length;
|
||||
if (length !== Object.keys(b).length) {
|
||||
return false;
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!{}.hasOwnProperty.call(b, keys[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
const key = keys[i];
|
||||
if (key === '_owner' && a.$$typeof) {
|
||||
continue;
|
||||
}
|
||||
if (!deepEqual(a[key], b[key])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return a !== a && b !== b;
|
||||
}
|
||||
|
||||
function getDPR(element) {
|
||||
if (typeof window === 'undefined') {
|
||||
return 1;
|
||||
}
|
||||
const win = element.ownerDocument.defaultView || window;
|
||||
return win.devicePixelRatio || 1;
|
||||
}
|
||||
|
||||
function roundByDPR(element, value) {
|
||||
const dpr = getDPR(element);
|
||||
return Math.round(value * dpr) / dpr;
|
||||
}
|
||||
|
||||
function useLatestRef(value) {
|
||||
const ref = React.useRef(value);
|
||||
index(() => {
|
||||
ref.current = value;
|
||||
});
|
||||
return ref;
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides data to position a floating element.
|
||||
* @see https://floating-ui.com/docs/useFloating
|
||||
*/
|
||||
function useFloating(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
placement = 'bottom',
|
||||
strategy = 'absolute',
|
||||
middleware = [],
|
||||
platform,
|
||||
elements: {
|
||||
reference: externalReference,
|
||||
floating: externalFloating
|
||||
} = {},
|
||||
transform = true,
|
||||
whileElementsMounted,
|
||||
open
|
||||
} = options;
|
||||
const [data, setData] = React.useState({
|
||||
x: 0,
|
||||
y: 0,
|
||||
strategy,
|
||||
placement,
|
||||
middlewareData: {},
|
||||
isPositioned: false
|
||||
});
|
||||
const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);
|
||||
if (!deepEqual(latestMiddleware, middleware)) {
|
||||
setLatestMiddleware(middleware);
|
||||
}
|
||||
const [_reference, _setReference] = React.useState(null);
|
||||
const [_floating, _setFloating] = React.useState(null);
|
||||
const setReference = React.useCallback(node => {
|
||||
if (node !== referenceRef.current) {
|
||||
referenceRef.current = node;
|
||||
_setReference(node);
|
||||
}
|
||||
}, []);
|
||||
const setFloating = React.useCallback(node => {
|
||||
if (node !== floatingRef.current) {
|
||||
floatingRef.current = node;
|
||||
_setFloating(node);
|
||||
}
|
||||
}, []);
|
||||
const referenceEl = externalReference || _reference;
|
||||
const floatingEl = externalFloating || _floating;
|
||||
const referenceRef = React.useRef(null);
|
||||
const floatingRef = React.useRef(null);
|
||||
const dataRef = React.useRef(data);
|
||||
const hasWhileElementsMounted = whileElementsMounted != null;
|
||||
const whileElementsMountedRef = useLatestRef(whileElementsMounted);
|
||||
const platformRef = useLatestRef(platform);
|
||||
const update = React.useCallback(() => {
|
||||
if (!referenceRef.current || !floatingRef.current) {
|
||||
return;
|
||||
}
|
||||
const config = {
|
||||
placement,
|
||||
strategy,
|
||||
middleware: latestMiddleware
|
||||
};
|
||||
if (platformRef.current) {
|
||||
config.platform = platformRef.current;
|
||||
}
|
||||
computePosition(referenceRef.current, floatingRef.current, config).then(data => {
|
||||
const fullData = {
|
||||
...data,
|
||||
isPositioned: true
|
||||
};
|
||||
if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
|
||||
dataRef.current = fullData;
|
||||
ReactDOM.flushSync(() => {
|
||||
setData(fullData);
|
||||
});
|
||||
}
|
||||
});
|
||||
}, [latestMiddleware, placement, strategy, platformRef]);
|
||||
index(() => {
|
||||
if (open === false && dataRef.current.isPositioned) {
|
||||
dataRef.current.isPositioned = false;
|
||||
setData(data => ({
|
||||
...data,
|
||||
isPositioned: false
|
||||
}));
|
||||
}
|
||||
}, [open]);
|
||||
const isMountedRef = React.useRef(false);
|
||||
index(() => {
|
||||
isMountedRef.current = true;
|
||||
return () => {
|
||||
isMountedRef.current = false;
|
||||
};
|
||||
}, []);
|
||||
index(() => {
|
||||
if (referenceEl) referenceRef.current = referenceEl;
|
||||
if (floatingEl) floatingRef.current = floatingEl;
|
||||
if (referenceEl && floatingEl) {
|
||||
if (whileElementsMountedRef.current) {
|
||||
return whileElementsMountedRef.current(referenceEl, floatingEl, update);
|
||||
}
|
||||
update();
|
||||
}
|
||||
}, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
|
||||
const refs = React.useMemo(() => ({
|
||||
reference: referenceRef,
|
||||
floating: floatingRef,
|
||||
setReference,
|
||||
setFloating
|
||||
}), [setReference, setFloating]);
|
||||
const elements = React.useMemo(() => ({
|
||||
reference: referenceEl,
|
||||
floating: floatingEl
|
||||
}), [referenceEl, floatingEl]);
|
||||
const floatingStyles = React.useMemo(() => {
|
||||
const initialStyles = {
|
||||
position: strategy,
|
||||
left: 0,
|
||||
top: 0
|
||||
};
|
||||
if (!elements.floating) {
|
||||
return initialStyles;
|
||||
}
|
||||
const x = roundByDPR(elements.floating, data.x);
|
||||
const y = roundByDPR(elements.floating, data.y);
|
||||
if (transform) {
|
||||
return {
|
||||
...initialStyles,
|
||||
transform: "translate(" + x + "px, " + y + "px)",
|
||||
...(getDPR(elements.floating) >= 1.5 && {
|
||||
willChange: 'transform'
|
||||
})
|
||||
};
|
||||
}
|
||||
return {
|
||||
position: strategy,
|
||||
left: x,
|
||||
top: y
|
||||
};
|
||||
}, [strategy, transform, elements.floating, data.x, data.y]);
|
||||
return React.useMemo(() => ({
|
||||
...data,
|
||||
update,
|
||||
refs,
|
||||
elements,
|
||||
floatingStyles
|
||||
}), [data, update, refs, elements, floatingStyles]);
|
||||
}
|
||||
|
||||
export { arrow, useFloating };
|
||||
+269
@@ -0,0 +1,269 @@
|
||||
import { arrow as arrow$1, computePosition } from '@floating-ui/dom';
|
||||
export { autoPlacement, autoUpdate, computePosition, detectOverflow, flip, getOverflowAncestors, hide, inline, limitShift, offset, platform, shift, size } from '@floating-ui/dom';
|
||||
import * as React from 'react';
|
||||
import { useLayoutEffect, useEffect } from 'react';
|
||||
import * as ReactDOM from 'react-dom';
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* This wraps the core `arrow` middleware to allow React refs as the element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = options => {
|
||||
function isRef(value) {
|
||||
return {}.hasOwnProperty.call(value, 'current');
|
||||
}
|
||||
return {
|
||||
name: 'arrow',
|
||||
options,
|
||||
fn(state) {
|
||||
const {
|
||||
element,
|
||||
padding
|
||||
} = typeof options === 'function' ? options(state) : options;
|
||||
if (element && isRef(element)) {
|
||||
if (element.current != null) {
|
||||
return arrow$1({
|
||||
element: element.current,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
if (element) {
|
||||
return arrow$1({
|
||||
element,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
var index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;
|
||||
|
||||
// Fork of `fast-deep-equal` that only does the comparisons we need and compares
|
||||
// functions
|
||||
function deepEqual(a, b) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (typeof a !== typeof b) {
|
||||
return false;
|
||||
}
|
||||
if (typeof a === 'function' && a.toString() === b.toString()) {
|
||||
return true;
|
||||
}
|
||||
let length;
|
||||
let i;
|
||||
let keys;
|
||||
if (a && b && typeof a === 'object') {
|
||||
if (Array.isArray(a)) {
|
||||
length = a.length;
|
||||
if (length !== b.length) return false;
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!deepEqual(a[i], b[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
keys = Object.keys(a);
|
||||
length = keys.length;
|
||||
if (length !== Object.keys(b).length) {
|
||||
return false;
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!{}.hasOwnProperty.call(b, keys[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
const key = keys[i];
|
||||
if (key === '_owner' && a.$$typeof) {
|
||||
continue;
|
||||
}
|
||||
if (!deepEqual(a[key], b[key])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return a !== a && b !== b;
|
||||
}
|
||||
|
||||
function getDPR(element) {
|
||||
if (typeof window === 'undefined') {
|
||||
return 1;
|
||||
}
|
||||
const win = element.ownerDocument.defaultView || window;
|
||||
return win.devicePixelRatio || 1;
|
||||
}
|
||||
|
||||
function roundByDPR(element, value) {
|
||||
const dpr = getDPR(element);
|
||||
return Math.round(value * dpr) / dpr;
|
||||
}
|
||||
|
||||
function useLatestRef(value) {
|
||||
const ref = React.useRef(value);
|
||||
index(() => {
|
||||
ref.current = value;
|
||||
});
|
||||
return ref;
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides data to position a floating element.
|
||||
* @see https://floating-ui.com/docs/useFloating
|
||||
*/
|
||||
function useFloating(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
placement = 'bottom',
|
||||
strategy = 'absolute',
|
||||
middleware = [],
|
||||
platform,
|
||||
elements: {
|
||||
reference: externalReference,
|
||||
floating: externalFloating
|
||||
} = {},
|
||||
transform = true,
|
||||
whileElementsMounted,
|
||||
open
|
||||
} = options;
|
||||
const [data, setData] = React.useState({
|
||||
x: 0,
|
||||
y: 0,
|
||||
strategy,
|
||||
placement,
|
||||
middlewareData: {},
|
||||
isPositioned: false
|
||||
});
|
||||
const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);
|
||||
if (!deepEqual(latestMiddleware, middleware)) {
|
||||
setLatestMiddleware(middleware);
|
||||
}
|
||||
const [_reference, _setReference] = React.useState(null);
|
||||
const [_floating, _setFloating] = React.useState(null);
|
||||
const setReference = React.useCallback(node => {
|
||||
if (node !== referenceRef.current) {
|
||||
referenceRef.current = node;
|
||||
_setReference(node);
|
||||
}
|
||||
}, []);
|
||||
const setFloating = React.useCallback(node => {
|
||||
if (node !== floatingRef.current) {
|
||||
floatingRef.current = node;
|
||||
_setFloating(node);
|
||||
}
|
||||
}, []);
|
||||
const referenceEl = externalReference || _reference;
|
||||
const floatingEl = externalFloating || _floating;
|
||||
const referenceRef = React.useRef(null);
|
||||
const floatingRef = React.useRef(null);
|
||||
const dataRef = React.useRef(data);
|
||||
const hasWhileElementsMounted = whileElementsMounted != null;
|
||||
const whileElementsMountedRef = useLatestRef(whileElementsMounted);
|
||||
const platformRef = useLatestRef(platform);
|
||||
const update = React.useCallback(() => {
|
||||
if (!referenceRef.current || !floatingRef.current) {
|
||||
return;
|
||||
}
|
||||
const config = {
|
||||
placement,
|
||||
strategy,
|
||||
middleware: latestMiddleware
|
||||
};
|
||||
if (platformRef.current) {
|
||||
config.platform = platformRef.current;
|
||||
}
|
||||
computePosition(referenceRef.current, floatingRef.current, config).then(data => {
|
||||
const fullData = {
|
||||
...data,
|
||||
isPositioned: true
|
||||
};
|
||||
if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
|
||||
dataRef.current = fullData;
|
||||
ReactDOM.flushSync(() => {
|
||||
setData(fullData);
|
||||
});
|
||||
}
|
||||
});
|
||||
}, [latestMiddleware, placement, strategy, platformRef]);
|
||||
index(() => {
|
||||
if (open === false && dataRef.current.isPositioned) {
|
||||
dataRef.current.isPositioned = false;
|
||||
setData(data => ({
|
||||
...data,
|
||||
isPositioned: false
|
||||
}));
|
||||
}
|
||||
}, [open]);
|
||||
const isMountedRef = React.useRef(false);
|
||||
index(() => {
|
||||
isMountedRef.current = true;
|
||||
return () => {
|
||||
isMountedRef.current = false;
|
||||
};
|
||||
}, []);
|
||||
index(() => {
|
||||
if (referenceEl) referenceRef.current = referenceEl;
|
||||
if (floatingEl) floatingRef.current = floatingEl;
|
||||
if (referenceEl && floatingEl) {
|
||||
if (whileElementsMountedRef.current) {
|
||||
return whileElementsMountedRef.current(referenceEl, floatingEl, update);
|
||||
}
|
||||
update();
|
||||
}
|
||||
}, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
|
||||
const refs = React.useMemo(() => ({
|
||||
reference: referenceRef,
|
||||
floating: floatingRef,
|
||||
setReference,
|
||||
setFloating
|
||||
}), [setReference, setFloating]);
|
||||
const elements = React.useMemo(() => ({
|
||||
reference: referenceEl,
|
||||
floating: floatingEl
|
||||
}), [referenceEl, floatingEl]);
|
||||
const floatingStyles = React.useMemo(() => {
|
||||
const initialStyles = {
|
||||
position: strategy,
|
||||
left: 0,
|
||||
top: 0
|
||||
};
|
||||
if (!elements.floating) {
|
||||
return initialStyles;
|
||||
}
|
||||
const x = roundByDPR(elements.floating, data.x);
|
||||
const y = roundByDPR(elements.floating, data.y);
|
||||
if (transform) {
|
||||
return {
|
||||
...initialStyles,
|
||||
transform: "translate(" + x + "px, " + y + "px)",
|
||||
...(getDPR(elements.floating) >= 1.5 && {
|
||||
willChange: 'transform'
|
||||
})
|
||||
};
|
||||
}
|
||||
return {
|
||||
position: strategy,
|
||||
left: x,
|
||||
top: y
|
||||
};
|
||||
}, [strategy, transform, elements.floating, data.x, data.y]);
|
||||
return React.useMemo(() => ({
|
||||
...data,
|
||||
update,
|
||||
refs,
|
||||
elements,
|
||||
floatingStyles
|
||||
}), [data, update, refs, elements, floatingStyles]);
|
||||
}
|
||||
|
||||
export { arrow, useFloating };
|
||||
+344
@@ -0,0 +1,344 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@floating-ui/dom'), require('react'), require('react-dom')) :
|
||||
typeof define === 'function' && define.amd ? define(['exports', '@floating-ui/dom', 'react', 'react-dom'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIReactDOM = {}, global.FloatingUIDOM, global.React, global.ReactDOM));
|
||||
})(this, (function (exports, dom, React, ReactDOM) { 'use strict';
|
||||
|
||||
function _interopNamespaceDefault(e) {
|
||||
var n = Object.create(null);
|
||||
if (e) {
|
||||
Object.keys(e).forEach(function (k) {
|
||||
if (k !== 'default') {
|
||||
var d = Object.getOwnPropertyDescriptor(e, k);
|
||||
Object.defineProperty(n, k, d.get ? d : {
|
||||
enumerable: true,
|
||||
get: function () { return e[k]; }
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
n.default = e;
|
||||
return Object.freeze(n);
|
||||
}
|
||||
|
||||
var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
|
||||
var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);
|
||||
|
||||
/**
|
||||
* Provides data to position an inner element of the floating element so that it
|
||||
* appears centered to the reference element.
|
||||
* This wraps the core `arrow` middleware to allow React refs as the element.
|
||||
* @see https://floating-ui.com/docs/arrow
|
||||
*/
|
||||
const arrow = options => {
|
||||
function isRef(value) {
|
||||
return {}.hasOwnProperty.call(value, 'current');
|
||||
}
|
||||
return {
|
||||
name: 'arrow',
|
||||
options,
|
||||
fn(state) {
|
||||
const {
|
||||
element,
|
||||
padding
|
||||
} = typeof options === 'function' ? options(state) : options;
|
||||
if (element && isRef(element)) {
|
||||
if (element.current != null) {
|
||||
return dom.arrow({
|
||||
element: element.current,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
if (element) {
|
||||
return dom.arrow({
|
||||
element,
|
||||
padding
|
||||
}).fn(state);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
var index = typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect;
|
||||
|
||||
// Fork of `fast-deep-equal` that only does the comparisons we need and compares
|
||||
// functions
|
||||
function deepEqual(a, b) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (typeof a !== typeof b) {
|
||||
return false;
|
||||
}
|
||||
if (typeof a === 'function' && a.toString() === b.toString()) {
|
||||
return true;
|
||||
}
|
||||
let length;
|
||||
let i;
|
||||
let keys;
|
||||
if (a && b && typeof a === 'object') {
|
||||
if (Array.isArray(a)) {
|
||||
length = a.length;
|
||||
if (length !== b.length) return false;
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!deepEqual(a[i], b[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
keys = Object.keys(a);
|
||||
length = keys.length;
|
||||
if (length !== Object.keys(b).length) {
|
||||
return false;
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
if (!{}.hasOwnProperty.call(b, keys[i])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (i = length; i-- !== 0;) {
|
||||
const key = keys[i];
|
||||
if (key === '_owner' && a.$$typeof) {
|
||||
continue;
|
||||
}
|
||||
if (!deepEqual(a[key], b[key])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return a !== a && b !== b;
|
||||
}
|
||||
|
||||
function getDPR(element) {
|
||||
if (typeof window === 'undefined') {
|
||||
return 1;
|
||||
}
|
||||
const win = element.ownerDocument.defaultView || window;
|
||||
return win.devicePixelRatio || 1;
|
||||
}
|
||||
|
||||
function roundByDPR(element, value) {
|
||||
const dpr = getDPR(element);
|
||||
return Math.round(value * dpr) / dpr;
|
||||
}
|
||||
|
||||
function useLatestRef(value) {
|
||||
const ref = React__namespace.useRef(value);
|
||||
index(() => {
|
||||
ref.current = value;
|
||||
});
|
||||
return ref;
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides data to position a floating element.
|
||||
* @see https://floating-ui.com/docs/useFloating
|
||||
*/
|
||||
function useFloating(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
const {
|
||||
placement = 'bottom',
|
||||
strategy = 'absolute',
|
||||
middleware = [],
|
||||
platform,
|
||||
elements: {
|
||||
reference: externalReference,
|
||||
floating: externalFloating
|
||||
} = {},
|
||||
transform = true,
|
||||
whileElementsMounted,
|
||||
open
|
||||
} = options;
|
||||
const [data, setData] = React__namespace.useState({
|
||||
x: 0,
|
||||
y: 0,
|
||||
strategy,
|
||||
placement,
|
||||
middlewareData: {},
|
||||
isPositioned: false
|
||||
});
|
||||
const [latestMiddleware, setLatestMiddleware] = React__namespace.useState(middleware);
|
||||
if (!deepEqual(latestMiddleware, middleware)) {
|
||||
setLatestMiddleware(middleware);
|
||||
}
|
||||
const [_reference, _setReference] = React__namespace.useState(null);
|
||||
const [_floating, _setFloating] = React__namespace.useState(null);
|
||||
const setReference = React__namespace.useCallback(node => {
|
||||
if (node !== referenceRef.current) {
|
||||
referenceRef.current = node;
|
||||
_setReference(node);
|
||||
}
|
||||
}, []);
|
||||
const setFloating = React__namespace.useCallback(node => {
|
||||
if (node !== floatingRef.current) {
|
||||
floatingRef.current = node;
|
||||
_setFloating(node);
|
||||
}
|
||||
}, []);
|
||||
const referenceEl = externalReference || _reference;
|
||||
const floatingEl = externalFloating || _floating;
|
||||
const referenceRef = React__namespace.useRef(null);
|
||||
const floatingRef = React__namespace.useRef(null);
|
||||
const dataRef = React__namespace.useRef(data);
|
||||
const hasWhileElementsMounted = whileElementsMounted != null;
|
||||
const whileElementsMountedRef = useLatestRef(whileElementsMounted);
|
||||
const platformRef = useLatestRef(platform);
|
||||
const update = React__namespace.useCallback(() => {
|
||||
if (!referenceRef.current || !floatingRef.current) {
|
||||
return;
|
||||
}
|
||||
const config = {
|
||||
placement,
|
||||
strategy,
|
||||
middleware: latestMiddleware
|
||||
};
|
||||
if (platformRef.current) {
|
||||
config.platform = platformRef.current;
|
||||
}
|
||||
dom.computePosition(referenceRef.current, floatingRef.current, config).then(data => {
|
||||
const fullData = {
|
||||
...data,
|
||||
isPositioned: true
|
||||
};
|
||||
if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
|
||||
dataRef.current = fullData;
|
||||
ReactDOM__namespace.flushSync(() => {
|
||||
setData(fullData);
|
||||
});
|
||||
}
|
||||
});
|
||||
}, [latestMiddleware, placement, strategy, platformRef]);
|
||||
index(() => {
|
||||
if (open === false && dataRef.current.isPositioned) {
|
||||
dataRef.current.isPositioned = false;
|
||||
setData(data => ({
|
||||
...data,
|
||||
isPositioned: false
|
||||
}));
|
||||
}
|
||||
}, [open]);
|
||||
const isMountedRef = React__namespace.useRef(false);
|
||||
index(() => {
|
||||
isMountedRef.current = true;
|
||||
return () => {
|
||||
isMountedRef.current = false;
|
||||
};
|
||||
}, []);
|
||||
index(() => {
|
||||
if (referenceEl) referenceRef.current = referenceEl;
|
||||
if (floatingEl) floatingRef.current = floatingEl;
|
||||
if (referenceEl && floatingEl) {
|
||||
if (whileElementsMountedRef.current) {
|
||||
return whileElementsMountedRef.current(referenceEl, floatingEl, update);
|
||||
}
|
||||
update();
|
||||
}
|
||||
}, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
|
||||
const refs = React__namespace.useMemo(() => ({
|
||||
reference: referenceRef,
|
||||
floating: floatingRef,
|
||||
setReference,
|
||||
setFloating
|
||||
}), [setReference, setFloating]);
|
||||
const elements = React__namespace.useMemo(() => ({
|
||||
reference: referenceEl,
|
||||
floating: floatingEl
|
||||
}), [referenceEl, floatingEl]);
|
||||
const floatingStyles = React__namespace.useMemo(() => {
|
||||
const initialStyles = {
|
||||
position: strategy,
|
||||
left: 0,
|
||||
top: 0
|
||||
};
|
||||
if (!elements.floating) {
|
||||
return initialStyles;
|
||||
}
|
||||
const x = roundByDPR(elements.floating, data.x);
|
||||
const y = roundByDPR(elements.floating, data.y);
|
||||
if (transform) {
|
||||
return {
|
||||
...initialStyles,
|
||||
transform: "translate(" + x + "px, " + y + "px)",
|
||||
...(getDPR(elements.floating) >= 1.5 && {
|
||||
willChange: 'transform'
|
||||
})
|
||||
};
|
||||
}
|
||||
return {
|
||||
position: strategy,
|
||||
left: x,
|
||||
top: y
|
||||
};
|
||||
}, [strategy, transform, elements.floating, data.x, data.y]);
|
||||
return React__namespace.useMemo(() => ({
|
||||
...data,
|
||||
update,
|
||||
refs,
|
||||
elements,
|
||||
floatingStyles
|
||||
}), [data, update, refs, elements, floatingStyles]);
|
||||
}
|
||||
|
||||
Object.defineProperty(exports, "autoPlacement", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.autoPlacement; }
|
||||
});
|
||||
Object.defineProperty(exports, "autoUpdate", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.autoUpdate; }
|
||||
});
|
||||
Object.defineProperty(exports, "computePosition", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.computePosition; }
|
||||
});
|
||||
Object.defineProperty(exports, "detectOverflow", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.detectOverflow; }
|
||||
});
|
||||
Object.defineProperty(exports, "flip", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.flip; }
|
||||
});
|
||||
Object.defineProperty(exports, "getOverflowAncestors", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.getOverflowAncestors; }
|
||||
});
|
||||
Object.defineProperty(exports, "hide", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.hide; }
|
||||
});
|
||||
Object.defineProperty(exports, "inline", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.inline; }
|
||||
});
|
||||
Object.defineProperty(exports, "limitShift", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.limitShift; }
|
||||
});
|
||||
Object.defineProperty(exports, "offset", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.offset; }
|
||||
});
|
||||
Object.defineProperty(exports, "platform", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.platform; }
|
||||
});
|
||||
Object.defineProperty(exports, "shift", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.shift; }
|
||||
});
|
||||
Object.defineProperty(exports, "size", {
|
||||
enumerable: true,
|
||||
get: function () { return dom.size; }
|
||||
});
|
||||
exports.arrow = arrow;
|
||||
exports.useFloating = useFloating;
|
||||
|
||||
}));
|
||||
+1
@@ -0,0 +1 @@
|
||||
!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@floating-ui/dom"),require("react"),require("react-dom")):"function"==typeof define&&define.amd?define(["exports","@floating-ui/dom","react","react-dom"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).FloatingUIReactDOM={},e.FloatingUIDOM,e.React,e.ReactDOM)}(this,(function(e,t,n,r){"use strict";function o(e){var t=Object.create(null);return e&&Object.keys(e).forEach((function(n){if("default"!==n){var r=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,r.get?r:{enumerable:!0,get:function(){return e[n]}})}})),t.default=e,Object.freeze(t)}var u=o(n),i=o(r);var f="undefined"!=typeof document?n.useLayoutEffect:n.useEffect;function c(e,t){if(e===t)return!0;if(typeof e!=typeof t)return!1;if("function"==typeof e&&e.toString()===t.toString())return!0;let n,r,o;if(e&&t&&"object"==typeof e){if(Array.isArray(e)){if(n=e.length,n!==t.length)return!1;for(r=n;0!=r--;)if(!c(e[r],t[r]))return!1;return!0}if(o=Object.keys(e),n=o.length,n!==Object.keys(t).length)return!1;for(r=n;0!=r--;)if(!{}.hasOwnProperty.call(t,o[r]))return!1;for(r=n;0!=r--;){const n=o[r];if(("_owner"!==n||!e.$$typeof)&&!c(e[n],t[n]))return!1}return!0}return e!=e&&t!=t}function a(e){if("undefined"==typeof window)return 1;return(e.ownerDocument.defaultView||window).devicePixelRatio||1}function l(e,t){const n=a(e);return Math.round(t*n)/n}function s(e){const t=u.useRef(e);return f((()=>{t.current=e})),t}Object.defineProperty(e,"autoPlacement",{enumerable:!0,get:function(){return t.autoPlacement}}),Object.defineProperty(e,"autoUpdate",{enumerable:!0,get:function(){return t.autoUpdate}}),Object.defineProperty(e,"computePosition",{enumerable:!0,get:function(){return t.computePosition}}),Object.defineProperty(e,"detectOverflow",{enumerable:!0,get:function(){return t.detectOverflow}}),Object.defineProperty(e,"flip",{enumerable:!0,get:function(){return t.flip}}),Object.defineProperty(e,"getOverflowAncestors",{enumerable:!0,get:function(){return t.getOverflowAncestors}}),Object.defineProperty(e,"hide",{enumerable:!0,get:function(){return t.hide}}),Object.defineProperty(e,"inline",{enumerable:!0,get:function(){return t.inline}}),Object.defineProperty(e,"limitShift",{enumerable:!0,get:function(){return t.limitShift}}),Object.defineProperty(e,"offset",{enumerable:!0,get:function(){return t.offset}}),Object.defineProperty(e,"platform",{enumerable:!0,get:function(){return t.platform}}),Object.defineProperty(e,"shift",{enumerable:!0,get:function(){return t.shift}}),Object.defineProperty(e,"size",{enumerable:!0,get:function(){return t.size}}),e.arrow=e=>({name:"arrow",options:e,fn(n){const{element:r,padding:o}="function"==typeof e?e(n):e;return r&&(u=r,{}.hasOwnProperty.call(u,"current"))?null!=r.current?t.arrow({element:r.current,padding:o}).fn(n):{}:r?t.arrow({element:r,padding:o}).fn(n):{};var u}}),e.useFloating=function(e){void 0===e&&(e={});const{placement:n="bottom",strategy:r="absolute",middleware:o=[],platform:d,elements:{reference:p,floating:m}={},transform:g=!0,whileElementsMounted:b,open:y}=e,[O,P]=u.useState({x:0,y:0,strategy:r,placement:n,middlewareData:{},isPositioned:!1}),[w,j]=u.useState(o);c(w,o)||j(o);const[h,v]=u.useState(null),[R,S]=u.useState(null),x=u.useCallback((e=>{e!==A.current&&(A.current=e,v(e))}),[]),M=u.useCallback((e=>{e!==C.current&&(C.current=e,S(e))}),[]),k=p||h,D=m||R,A=u.useRef(null),C=u.useRef(null),E=u.useRef(O),F=null!=b,U=s(b),q=s(d),z=u.useCallback((()=>{if(!A.current||!C.current)return;const e={placement:n,strategy:r,middleware:w};q.current&&(e.platform=q.current),t.computePosition(A.current,C.current,e).then((e=>{const t={...e,isPositioned:!0};I.current&&!c(E.current,t)&&(E.current=t,i.flushSync((()=>{P(t)})))}))}),[w,n,r,q]);f((()=>{!1===y&&E.current.isPositioned&&(E.current.isPositioned=!1,P((e=>({...e,isPositioned:!1}))))}),[y]);const I=u.useRef(!1);f((()=>(I.current=!0,()=>{I.current=!1})),[]),f((()=>{if(k&&(A.current=k),D&&(C.current=D),k&&D){if(U.current)return U.current(k,D,z);z()}}),[k,D,z,U,F]);const T=u.useMemo((()=>({reference:A,floating:C,setReference:x,setFloating:M})),[x,M]),$=u.useMemo((()=>({reference:k,floating:D})),[k,D]),L=u.useMemo((()=>{const e={position:r,left:0,top:0};if(!$.floating)return e;const t=l($.floating,O.x),n=l($.floating,O.y);return g?{...e,transform:"translate("+t+"px, "+n+"px)",...a($.floating)>=1.5&&{willChange:"transform"}}:{position:r,left:t,top:n}}),[r,g,$.floating,O.x,O.y]);return u.useMemo((()=>({...O,update:z,refs:T,elements:$,floatingStyles:L})),[O,z,T,$,L])}}));
|
||||
+77
@@ -0,0 +1,77 @@
|
||||
{
|
||||
"name": "@floating-ui/react-dom",
|
||||
"version": "2.0.9",
|
||||
"description": "Floating UI for React DOM",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "./dist/floating-ui.react-dom.umd.js",
|
||||
"module": "./dist/floating-ui.react-dom.esm.js",
|
||||
"unpkg": "./dist/floating-ui.react-dom.umd.min.js",
|
||||
"types": "./dist/floating-ui.react-dom.d.ts",
|
||||
"exports": {
|
||||
"./package.json": "./package.json",
|
||||
".": {
|
||||
"import": {
|
||||
"types": "./dist/floating-ui.react-dom.d.mts",
|
||||
"default": "./dist/floating-ui.react-dom.mjs"
|
||||
},
|
||||
"types": "./dist/floating-ui.react-dom.d.ts",
|
||||
"module": "./dist/floating-ui.react-dom.esm.js",
|
||||
"default": "./dist/floating-ui.react-dom.umd.js"
|
||||
}
|
||||
},
|
||||
"sideEffects": false,
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"author": "atomiks",
|
||||
"license": "MIT",
|
||||
"bugs": "https://github.com/floating-ui/floating-ui",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/floating-ui/floating-ui.git",
|
||||
"directory": "packages/react-dom"
|
||||
},
|
||||
"homepage": "https://floating-ui.com/docs/react-dom",
|
||||
"keywords": [
|
||||
"tooltip",
|
||||
"popover",
|
||||
"dropdown",
|
||||
"menu",
|
||||
"popup",
|
||||
"positioning",
|
||||
"react",
|
||||
"react-dom"
|
||||
],
|
||||
"peerDependencies": {
|
||||
"react": ">=16.8.0",
|
||||
"react-dom": ">=16.8.0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@floating-ui/dom": "^1.0.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/preset-react": "^7.23.3",
|
||||
"@testing-library/jest-dom": "^6.1.6",
|
||||
"@testing-library/react": "^13.4.0",
|
||||
"@types/react": "^18.2.46",
|
||||
"@types/react-dom": "^18.2.18",
|
||||
"@vitejs/plugin-react": "^4.2.1",
|
||||
"react": "^18.2.0",
|
||||
"react-dom": "^18.2.0",
|
||||
"use-isomorphic-layout-effect": "^1.1.2",
|
||||
"config": "0.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint .",
|
||||
"format": "prettier --write .",
|
||||
"clean": "rimraf dist out-tsc",
|
||||
"test": "vitest run",
|
||||
"test:watch": "vitest watch",
|
||||
"build": "rollup -c",
|
||||
"build:api": "build-api --tsc tsconfig.lib.json",
|
||||
"publint": "publint",
|
||||
"typecheck": "tsc -b"
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2021-present Floating UI contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
# @floating-ui/utils
|
||||
|
||||
Utility functions shared across Floating UI packages. You may use these
|
||||
functions in your own projects, but are subject to breaking changes.
|
||||
+98
@@ -0,0 +1,98 @@
|
||||
export declare type AlignedPlacement = `${Side}-${Alignment}`;
|
||||
|
||||
export declare type Alignment = 'start' | 'end';
|
||||
|
||||
export declare const alignments: Alignment[];
|
||||
|
||||
export declare type Axis = 'x' | 'y';
|
||||
|
||||
export declare function clamp(start: number, value: number, end: number): number;
|
||||
|
||||
export declare type ClientRectObject = Rect & SideObject;
|
||||
|
||||
export declare type Coords = {
|
||||
[key in Axis]: number;
|
||||
};
|
||||
|
||||
export declare const createCoords: (v: number) => {
|
||||
x: number;
|
||||
y: number;
|
||||
};
|
||||
|
||||
export declare type Dimensions = {
|
||||
[key in Length]: number;
|
||||
};
|
||||
|
||||
export declare interface ElementRects {
|
||||
reference: Rect;
|
||||
floating: Rect;
|
||||
}
|
||||
|
||||
export declare function evaluate<T, P>(value: T | ((param: P) => T), param: P): T;
|
||||
|
||||
export declare function expandPaddingObject(padding: Partial<SideObject>): SideObject;
|
||||
|
||||
export declare const floor: (x: number) => number;
|
||||
|
||||
export declare function getAlignment(placement: Placement): Alignment | undefined;
|
||||
|
||||
export declare function getAlignmentAxis(placement: Placement): Axis;
|
||||
|
||||
export declare function getAlignmentSides(placement: Placement, rects: ElementRects, rtl?: boolean): [Side, Side];
|
||||
|
||||
export declare function getAxisLength(axis: Axis): Length;
|
||||
|
||||
export declare function getExpandedPlacements(placement: Placement): Array<Placement>;
|
||||
|
||||
export declare function getOppositeAlignmentPlacement<T extends string>(placement: T): T;
|
||||
|
||||
export declare function getOppositeAxis(axis: Axis): Axis;
|
||||
|
||||
export declare function getOppositeAxisPlacements(placement: Placement, flipAlignment: boolean, direction: 'none' | Alignment, rtl?: boolean): Placement[];
|
||||
|
||||
export declare function getOppositePlacement<T extends string>(placement: T): T;
|
||||
|
||||
export declare function getPaddingObject(padding: Padding): SideObject;
|
||||
|
||||
export declare function getSide(placement: Placement): Side;
|
||||
|
||||
export declare function getSideAxis(placement: Placement): Axis;
|
||||
|
||||
export declare type Length = 'width' | 'height';
|
||||
|
||||
export declare const max: (...values: number[]) => number;
|
||||
|
||||
export declare const min: (...values: number[]) => number;
|
||||
|
||||
export declare type Padding = number | Partial<SideObject>;
|
||||
|
||||
export declare type Placement = Side | AlignedPlacement;
|
||||
|
||||
export declare const placements: Placement[];
|
||||
|
||||
export declare type Rect = Coords & Dimensions;
|
||||
|
||||
export declare function rectToClientRect(rect: Rect): ClientRectObject;
|
||||
|
||||
export declare const round: (x: number) => number;
|
||||
|
||||
export declare type Side = 'top' | 'right' | 'bottom' | 'left';
|
||||
|
||||
export declare type SideObject = {
|
||||
[key in Side]: number;
|
||||
};
|
||||
|
||||
export declare const sides: Side[];
|
||||
|
||||
export declare type Strategy = 'absolute' | 'fixed';
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
export declare type VirtualElement = {
|
||||
getBoundingClientRect(): ClientRectObject;
|
||||
contextElement?: any;
|
||||
};
|
||||
|
||||
export { }
|
||||
+98
@@ -0,0 +1,98 @@
|
||||
export declare type AlignedPlacement = `${Side}-${Alignment}`;
|
||||
|
||||
export declare type Alignment = 'start' | 'end';
|
||||
|
||||
export declare const alignments: Alignment[];
|
||||
|
||||
export declare type Axis = 'x' | 'y';
|
||||
|
||||
export declare function clamp(start: number, value: number, end: number): number;
|
||||
|
||||
export declare type ClientRectObject = Rect & SideObject;
|
||||
|
||||
export declare type Coords = {
|
||||
[key in Axis]: number;
|
||||
};
|
||||
|
||||
export declare const createCoords: (v: number) => {
|
||||
x: number;
|
||||
y: number;
|
||||
};
|
||||
|
||||
export declare type Dimensions = {
|
||||
[key in Length]: number;
|
||||
};
|
||||
|
||||
export declare interface ElementRects {
|
||||
reference: Rect;
|
||||
floating: Rect;
|
||||
}
|
||||
|
||||
export declare function evaluate<T, P>(value: T | ((param: P) => T), param: P): T;
|
||||
|
||||
export declare function expandPaddingObject(padding: Partial<SideObject>): SideObject;
|
||||
|
||||
export declare const floor: (x: number) => number;
|
||||
|
||||
export declare function getAlignment(placement: Placement): Alignment | undefined;
|
||||
|
||||
export declare function getAlignmentAxis(placement: Placement): Axis;
|
||||
|
||||
export declare function getAlignmentSides(placement: Placement, rects: ElementRects, rtl?: boolean): [Side, Side];
|
||||
|
||||
export declare function getAxisLength(axis: Axis): Length;
|
||||
|
||||
export declare function getExpandedPlacements(placement: Placement): Array<Placement>;
|
||||
|
||||
export declare function getOppositeAlignmentPlacement<T extends string>(placement: T): T;
|
||||
|
||||
export declare function getOppositeAxis(axis: Axis): Axis;
|
||||
|
||||
export declare function getOppositeAxisPlacements(placement: Placement, flipAlignment: boolean, direction: 'none' | Alignment, rtl?: boolean): Placement[];
|
||||
|
||||
export declare function getOppositePlacement<T extends string>(placement: T): T;
|
||||
|
||||
export declare function getPaddingObject(padding: Padding): SideObject;
|
||||
|
||||
export declare function getSide(placement: Placement): Side;
|
||||
|
||||
export declare function getSideAxis(placement: Placement): Axis;
|
||||
|
||||
export declare type Length = 'width' | 'height';
|
||||
|
||||
export declare const max: (...values: number[]) => number;
|
||||
|
||||
export declare const min: (...values: number[]) => number;
|
||||
|
||||
export declare type Padding = number | Partial<SideObject>;
|
||||
|
||||
export declare type Placement = Side | AlignedPlacement;
|
||||
|
||||
export declare const placements: Placement[];
|
||||
|
||||
export declare type Rect = Coords & Dimensions;
|
||||
|
||||
export declare function rectToClientRect(rect: Rect): ClientRectObject;
|
||||
|
||||
export declare const round: (x: number) => number;
|
||||
|
||||
export declare type Side = 'top' | 'right' | 'bottom' | 'left';
|
||||
|
||||
export declare type SideObject = {
|
||||
[key in Side]: number;
|
||||
};
|
||||
|
||||
export declare const sides: Side[];
|
||||
|
||||
export declare type Strategy = 'absolute' | 'fixed';
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
export declare type VirtualElement = {
|
||||
getBoundingClientRect(): ClientRectObject;
|
||||
contextElement?: any;
|
||||
};
|
||||
|
||||
export { }
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
|
||||
export { getComputedStyle_2 as getComputedStyle }
|
||||
|
||||
export declare function getContainingBlock(element: Element): HTMLElement | null;
|
||||
|
||||
export declare function getDocumentElement(node: Node | Window): HTMLElement;
|
||||
|
||||
export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
|
||||
|
||||
export declare function getNodeName(node: Node | Window): string;
|
||||
|
||||
export declare function getNodeScroll(element: Element | Window): {
|
||||
scrollLeft: number;
|
||||
scrollTop: number;
|
||||
};
|
||||
|
||||
export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
|
||||
|
||||
export declare function getParentNode(node: Node): Node;
|
||||
|
||||
export declare function getWindow(node: any): typeof window;
|
||||
|
||||
export declare function isContainingBlock(element: Element): boolean;
|
||||
|
||||
export declare function isElement(value: unknown): value is Element;
|
||||
|
||||
export declare function isHTMLElement(value: unknown): value is HTMLElement;
|
||||
|
||||
export declare function isLastTraversableNode(node: Node): boolean;
|
||||
|
||||
export declare function isNode(value: unknown): value is Node;
|
||||
|
||||
export declare function isOverflowElement(element: Element): boolean;
|
||||
|
||||
export declare function isShadowRoot(value: unknown): value is ShadowRoot;
|
||||
|
||||
export declare function isTableElement(element: Element): boolean;
|
||||
|
||||
export declare function isWebKit(): boolean;
|
||||
|
||||
declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
|
||||
|
||||
export { }
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
|
||||
export { getComputedStyle_2 as getComputedStyle }
|
||||
|
||||
export declare function getContainingBlock(element: Element): HTMLElement | null;
|
||||
|
||||
export declare function getDocumentElement(node: Node | Window): HTMLElement;
|
||||
|
||||
export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
|
||||
|
||||
export declare function getNodeName(node: Node | Window): string;
|
||||
|
||||
export declare function getNodeScroll(element: Element | Window): {
|
||||
scrollLeft: number;
|
||||
scrollTop: number;
|
||||
};
|
||||
|
||||
export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
|
||||
|
||||
export declare function getParentNode(node: Node): Node;
|
||||
|
||||
export declare function getWindow(node: any): typeof window;
|
||||
|
||||
export declare function isContainingBlock(element: Element): boolean;
|
||||
|
||||
export declare function isElement(value: unknown): value is Element;
|
||||
|
||||
export declare function isHTMLElement(value: unknown): value is HTMLElement;
|
||||
|
||||
export declare function isLastTraversableNode(node: Node): boolean;
|
||||
|
||||
export declare function isNode(value: unknown): value is Node;
|
||||
|
||||
export declare function isOverflowElement(element: Element): boolean;
|
||||
|
||||
export declare function isShadowRoot(value: unknown): value is ShadowRoot;
|
||||
|
||||
export declare function isTableElement(element: Element): boolean;
|
||||
|
||||
export declare function isWebKit(): boolean;
|
||||
|
||||
declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
|
||||
|
||||
export { }
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
export { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
export { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };
|
||||
+152
@@ -0,0 +1,152 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtilsDOM = {}));
|
||||
})(this, (function (exports) { 'use strict';
|
||||
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
exports.getComputedStyle = getComputedStyle;
|
||||
exports.getContainingBlock = getContainingBlock;
|
||||
exports.getDocumentElement = getDocumentElement;
|
||||
exports.getNearestOverflowAncestor = getNearestOverflowAncestor;
|
||||
exports.getNodeName = getNodeName;
|
||||
exports.getNodeScroll = getNodeScroll;
|
||||
exports.getOverflowAncestors = getOverflowAncestors;
|
||||
exports.getParentNode = getParentNode;
|
||||
exports.getWindow = getWindow;
|
||||
exports.isContainingBlock = isContainingBlock;
|
||||
exports.isElement = isElement;
|
||||
exports.isHTMLElement = isHTMLElement;
|
||||
exports.isLastTraversableNode = isLastTraversableNode;
|
||||
exports.isNode = isNode;
|
||||
exports.isOverflowElement = isOverflowElement;
|
||||
exports.isShadowRoot = isShadowRoot;
|
||||
exports.isTableElement = isTableElement;
|
||||
exports.isWebKit = isWebKit;
|
||||
|
||||
}));
|
||||
+1
@@ -0,0 +1 @@
|
||||
!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).FloatingUIUtilsDOM={})}(this,(function(e){"use strict";function n(e){return r(e)?(e.nodeName||"").toLowerCase():"#document"}function t(e){var n;return(null==e||null==(n=e.ownerDocument)?void 0:n.defaultView)||window}function o(e){var n;return null==(n=(r(e)?e.ownerDocument:e.document)||window.document)?void 0:n.documentElement}function r(e){return e instanceof Node||e instanceof t(e).Node}function i(e){return e instanceof Element||e instanceof t(e).Element}function l(e){return e instanceof HTMLElement||e instanceof t(e).HTMLElement}function c(e){return"undefined"!=typeof ShadowRoot&&(e instanceof ShadowRoot||e instanceof t(e).ShadowRoot)}function u(e){const{overflow:n,overflowX:t,overflowY:o,display:r}=a(e);return/auto|scroll|overlay|hidden|clip/.test(n+o+t)&&!["inline","contents"].includes(r)}function s(e){const n=f(),t=a(e);return"none"!==t.transform||"none"!==t.perspective||!!t.containerType&&"normal"!==t.containerType||!n&&!!t.backdropFilter&&"none"!==t.backdropFilter||!n&&!!t.filter&&"none"!==t.filter||["transform","perspective","filter"].some((e=>(t.willChange||"").includes(e)))||["paint","layout","strict","content"].some((e=>(t.contain||"").includes(e)))}function f(){return!("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function d(e){return["html","body","#document"].includes(n(e))}function a(e){return t(e).getComputedStyle(e)}function m(e){if("html"===n(e))return e;const t=e.assignedSlot||e.parentNode||c(e)&&e.host||o(e);return c(t)?t.host:t}function p(e){const n=m(e);return d(n)?e.ownerDocument?e.ownerDocument.body:e.body:l(n)&&u(n)?n:p(n)}e.getComputedStyle=a,e.getContainingBlock=function(e){let n=m(e);for(;l(n)&&!d(n);){if(s(n))return n;n=m(n)}return null},e.getDocumentElement=o,e.getNearestOverflowAncestor=p,e.getNodeName=n,e.getNodeScroll=function(e){return i(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.pageXOffset,scrollTop:e.pageYOffset}},e.getOverflowAncestors=function e(n,o,r){var i;void 0===o&&(o=[]),void 0===r&&(r=!0);const l=p(n),c=l===(null==(i=n.ownerDocument)?void 0:i.body),s=t(l);return c?o.concat(s,s.visualViewport||[],u(l)?l:[],s.frameElement&&r?e(s.frameElement):[]):o.concat(l,e(l,[],r))},e.getParentNode=m,e.getWindow=t,e.isContainingBlock=s,e.isElement=i,e.isHTMLElement=l,e.isLastTraversableNode=d,e.isNode=r,e.isOverflowElement=u,e.isShadowRoot=c,e.isTableElement=function(e){return["table","td","th"].includes(n(e))},e.isWebKit=f}));
|
||||
+138
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
|
||||
const sides = ['top', 'right', 'bottom', 'left'];
|
||||
const alignments = ['start', 'end'];
|
||||
const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
|
||||
const min = Math.min;
|
||||
const max = Math.max;
|
||||
const round = Math.round;
|
||||
const floor = Math.floor;
|
||||
const createCoords = v => ({
|
||||
x: v,
|
||||
y: v
|
||||
});
|
||||
const oppositeSideMap = {
|
||||
left: 'right',
|
||||
right: 'left',
|
||||
bottom: 'top',
|
||||
top: 'bottom'
|
||||
};
|
||||
const oppositeAlignmentMap = {
|
||||
start: 'end',
|
||||
end: 'start'
|
||||
};
|
||||
function clamp(start, value, end) {
|
||||
return max(start, min(value, end));
|
||||
}
|
||||
function evaluate(value, param) {
|
||||
return typeof value === 'function' ? value(param) : value;
|
||||
}
|
||||
function getSide(placement) {
|
||||
return placement.split('-')[0];
|
||||
}
|
||||
function getAlignment(placement) {
|
||||
return placement.split('-')[1];
|
||||
}
|
||||
function getOppositeAxis(axis) {
|
||||
return axis === 'x' ? 'y' : 'x';
|
||||
}
|
||||
function getAxisLength(axis) {
|
||||
return axis === 'y' ? 'height' : 'width';
|
||||
}
|
||||
function getSideAxis(placement) {
|
||||
return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
|
||||
}
|
||||
function getAlignmentAxis(placement) {
|
||||
return getOppositeAxis(getSideAxis(placement));
|
||||
}
|
||||
function getAlignmentSides(placement, rects, rtl) {
|
||||
if (rtl === void 0) {
|
||||
rtl = false;
|
||||
}
|
||||
const alignment = getAlignment(placement);
|
||||
const alignmentAxis = getAlignmentAxis(placement);
|
||||
const length = getAxisLength(alignmentAxis);
|
||||
let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
|
||||
if (rects.reference[length] > rects.floating[length]) {
|
||||
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
|
||||
}
|
||||
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
|
||||
}
|
||||
function getExpandedPlacements(placement) {
|
||||
const oppositePlacement = getOppositePlacement(placement);
|
||||
return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
|
||||
}
|
||||
function getOppositeAlignmentPlacement(placement) {
|
||||
return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
|
||||
}
|
||||
function getSideList(side, isStart, rtl) {
|
||||
const lr = ['left', 'right'];
|
||||
const rl = ['right', 'left'];
|
||||
const tb = ['top', 'bottom'];
|
||||
const bt = ['bottom', 'top'];
|
||||
switch (side) {
|
||||
case 'top':
|
||||
case 'bottom':
|
||||
if (rtl) return isStart ? rl : lr;
|
||||
return isStart ? lr : rl;
|
||||
case 'left':
|
||||
case 'right':
|
||||
return isStart ? tb : bt;
|
||||
default:
|
||||
return [];
|
||||
}
|
||||
}
|
||||
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
|
||||
const alignment = getAlignment(placement);
|
||||
let list = getSideList(getSide(placement), direction === 'start', rtl);
|
||||
if (alignment) {
|
||||
list = list.map(side => side + "-" + alignment);
|
||||
if (flipAlignment) {
|
||||
list = list.concat(list.map(getOppositeAlignmentPlacement));
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
function getOppositePlacement(placement) {
|
||||
return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
|
||||
}
|
||||
function expandPaddingObject(padding) {
|
||||
return {
|
||||
top: 0,
|
||||
right: 0,
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
...padding
|
||||
};
|
||||
}
|
||||
function getPaddingObject(padding) {
|
||||
return typeof padding !== 'number' ? expandPaddingObject(padding) : {
|
||||
top: padding,
|
||||
right: padding,
|
||||
bottom: padding,
|
||||
left: padding
|
||||
};
|
||||
}
|
||||
function rectToClientRect(rect) {
|
||||
const {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height
|
||||
} = rect;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
top: y,
|
||||
left: x,
|
||||
right: x + width,
|
||||
bottom: y + height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
export { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };
|
||||
+138
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
|
||||
const sides = ['top', 'right', 'bottom', 'left'];
|
||||
const alignments = ['start', 'end'];
|
||||
const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
|
||||
const min = Math.min;
|
||||
const max = Math.max;
|
||||
const round = Math.round;
|
||||
const floor = Math.floor;
|
||||
const createCoords = v => ({
|
||||
x: v,
|
||||
y: v
|
||||
});
|
||||
const oppositeSideMap = {
|
||||
left: 'right',
|
||||
right: 'left',
|
||||
bottom: 'top',
|
||||
top: 'bottom'
|
||||
};
|
||||
const oppositeAlignmentMap = {
|
||||
start: 'end',
|
||||
end: 'start'
|
||||
};
|
||||
function clamp(start, value, end) {
|
||||
return max(start, min(value, end));
|
||||
}
|
||||
function evaluate(value, param) {
|
||||
return typeof value === 'function' ? value(param) : value;
|
||||
}
|
||||
function getSide(placement) {
|
||||
return placement.split('-')[0];
|
||||
}
|
||||
function getAlignment(placement) {
|
||||
return placement.split('-')[1];
|
||||
}
|
||||
function getOppositeAxis(axis) {
|
||||
return axis === 'x' ? 'y' : 'x';
|
||||
}
|
||||
function getAxisLength(axis) {
|
||||
return axis === 'y' ? 'height' : 'width';
|
||||
}
|
||||
function getSideAxis(placement) {
|
||||
return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
|
||||
}
|
||||
function getAlignmentAxis(placement) {
|
||||
return getOppositeAxis(getSideAxis(placement));
|
||||
}
|
||||
function getAlignmentSides(placement, rects, rtl) {
|
||||
if (rtl === void 0) {
|
||||
rtl = false;
|
||||
}
|
||||
const alignment = getAlignment(placement);
|
||||
const alignmentAxis = getAlignmentAxis(placement);
|
||||
const length = getAxisLength(alignmentAxis);
|
||||
let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
|
||||
if (rects.reference[length] > rects.floating[length]) {
|
||||
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
|
||||
}
|
||||
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
|
||||
}
|
||||
function getExpandedPlacements(placement) {
|
||||
const oppositePlacement = getOppositePlacement(placement);
|
||||
return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
|
||||
}
|
||||
function getOppositeAlignmentPlacement(placement) {
|
||||
return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
|
||||
}
|
||||
function getSideList(side, isStart, rtl) {
|
||||
const lr = ['left', 'right'];
|
||||
const rl = ['right', 'left'];
|
||||
const tb = ['top', 'bottom'];
|
||||
const bt = ['bottom', 'top'];
|
||||
switch (side) {
|
||||
case 'top':
|
||||
case 'bottom':
|
||||
if (rtl) return isStart ? rl : lr;
|
||||
return isStart ? lr : rl;
|
||||
case 'left':
|
||||
case 'right':
|
||||
return isStart ? tb : bt;
|
||||
default:
|
||||
return [];
|
||||
}
|
||||
}
|
||||
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
|
||||
const alignment = getAlignment(placement);
|
||||
let list = getSideList(getSide(placement), direction === 'start', rtl);
|
||||
if (alignment) {
|
||||
list = list.map(side => side + "-" + alignment);
|
||||
if (flipAlignment) {
|
||||
list = list.concat(list.map(getOppositeAlignmentPlacement));
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
function getOppositePlacement(placement) {
|
||||
return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
|
||||
}
|
||||
function expandPaddingObject(padding) {
|
||||
return {
|
||||
top: 0,
|
||||
right: 0,
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
...padding
|
||||
};
|
||||
}
|
||||
function getPaddingObject(padding) {
|
||||
return typeof padding !== 'number' ? expandPaddingObject(padding) : {
|
||||
top: padding,
|
||||
right: padding,
|
||||
bottom: padding,
|
||||
left: padding
|
||||
};
|
||||
}
|
||||
function rectToClientRect(rect) {
|
||||
const {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height
|
||||
} = rect;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
top: y,
|
||||
left: x,
|
||||
right: x + width,
|
||||
bottom: y + height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
export { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtils = {}));
|
||||
})(this, (function (exports) { 'use strict';
|
||||
|
||||
/**
|
||||
* Custom positioning reference element.
|
||||
* @see https://floating-ui.com/docs/virtual-elements
|
||||
*/
|
||||
|
||||
const sides = ['top', 'right', 'bottom', 'left'];
|
||||
const alignments = ['start', 'end'];
|
||||
const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
|
||||
const min = Math.min;
|
||||
const max = Math.max;
|
||||
const round = Math.round;
|
||||
const floor = Math.floor;
|
||||
const createCoords = v => ({
|
||||
x: v,
|
||||
y: v
|
||||
});
|
||||
const oppositeSideMap = {
|
||||
left: 'right',
|
||||
right: 'left',
|
||||
bottom: 'top',
|
||||
top: 'bottom'
|
||||
};
|
||||
const oppositeAlignmentMap = {
|
||||
start: 'end',
|
||||
end: 'start'
|
||||
};
|
||||
function clamp(start, value, end) {
|
||||
return max(start, min(value, end));
|
||||
}
|
||||
function evaluate(value, param) {
|
||||
return typeof value === 'function' ? value(param) : value;
|
||||
}
|
||||
function getSide(placement) {
|
||||
return placement.split('-')[0];
|
||||
}
|
||||
function getAlignment(placement) {
|
||||
return placement.split('-')[1];
|
||||
}
|
||||
function getOppositeAxis(axis) {
|
||||
return axis === 'x' ? 'y' : 'x';
|
||||
}
|
||||
function getAxisLength(axis) {
|
||||
return axis === 'y' ? 'height' : 'width';
|
||||
}
|
||||
function getSideAxis(placement) {
|
||||
return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
|
||||
}
|
||||
function getAlignmentAxis(placement) {
|
||||
return getOppositeAxis(getSideAxis(placement));
|
||||
}
|
||||
function getAlignmentSides(placement, rects, rtl) {
|
||||
if (rtl === void 0) {
|
||||
rtl = false;
|
||||
}
|
||||
const alignment = getAlignment(placement);
|
||||
const alignmentAxis = getAlignmentAxis(placement);
|
||||
const length = getAxisLength(alignmentAxis);
|
||||
let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
|
||||
if (rects.reference[length] > rects.floating[length]) {
|
||||
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
|
||||
}
|
||||
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
|
||||
}
|
||||
function getExpandedPlacements(placement) {
|
||||
const oppositePlacement = getOppositePlacement(placement);
|
||||
return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
|
||||
}
|
||||
function getOppositeAlignmentPlacement(placement) {
|
||||
return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
|
||||
}
|
||||
function getSideList(side, isStart, rtl) {
|
||||
const lr = ['left', 'right'];
|
||||
const rl = ['right', 'left'];
|
||||
const tb = ['top', 'bottom'];
|
||||
const bt = ['bottom', 'top'];
|
||||
switch (side) {
|
||||
case 'top':
|
||||
case 'bottom':
|
||||
if (rtl) return isStart ? rl : lr;
|
||||
return isStart ? lr : rl;
|
||||
case 'left':
|
||||
case 'right':
|
||||
return isStart ? tb : bt;
|
||||
default:
|
||||
return [];
|
||||
}
|
||||
}
|
||||
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
|
||||
const alignment = getAlignment(placement);
|
||||
let list = getSideList(getSide(placement), direction === 'start', rtl);
|
||||
if (alignment) {
|
||||
list = list.map(side => side + "-" + alignment);
|
||||
if (flipAlignment) {
|
||||
list = list.concat(list.map(getOppositeAlignmentPlacement));
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
function getOppositePlacement(placement) {
|
||||
return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
|
||||
}
|
||||
function expandPaddingObject(padding) {
|
||||
return {
|
||||
top: 0,
|
||||
right: 0,
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
...padding
|
||||
};
|
||||
}
|
||||
function getPaddingObject(padding) {
|
||||
return typeof padding !== 'number' ? expandPaddingObject(padding) : {
|
||||
top: padding,
|
||||
right: padding,
|
||||
bottom: padding,
|
||||
left: padding
|
||||
};
|
||||
}
|
||||
function rectToClientRect(rect) {
|
||||
const {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height
|
||||
} = rect;
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
top: y,
|
||||
left: x,
|
||||
right: x + width,
|
||||
bottom: y + height,
|
||||
x,
|
||||
y
|
||||
};
|
||||
}
|
||||
|
||||
exports.alignments = alignments;
|
||||
exports.clamp = clamp;
|
||||
exports.createCoords = createCoords;
|
||||
exports.evaluate = evaluate;
|
||||
exports.expandPaddingObject = expandPaddingObject;
|
||||
exports.floor = floor;
|
||||
exports.getAlignment = getAlignment;
|
||||
exports.getAlignmentAxis = getAlignmentAxis;
|
||||
exports.getAlignmentSides = getAlignmentSides;
|
||||
exports.getAxisLength = getAxisLength;
|
||||
exports.getExpandedPlacements = getExpandedPlacements;
|
||||
exports.getOppositeAlignmentPlacement = getOppositeAlignmentPlacement;
|
||||
exports.getOppositeAxis = getOppositeAxis;
|
||||
exports.getOppositeAxisPlacements = getOppositeAxisPlacements;
|
||||
exports.getOppositePlacement = getOppositePlacement;
|
||||
exports.getPaddingObject = getPaddingObject;
|
||||
exports.getSide = getSide;
|
||||
exports.getSideAxis = getSideAxis;
|
||||
exports.max = max;
|
||||
exports.min = min;
|
||||
exports.placements = placements;
|
||||
exports.rectToClientRect = rectToClientRect;
|
||||
exports.round = round;
|
||||
exports.sides = sides;
|
||||
|
||||
}));
|
||||
+1
@@ -0,0 +1 @@
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).FloatingUIUtils={})}(this,(function(t){"use strict";const e=["top","right","bottom","left"],n=["start","end"],o=e.reduce(((t,e)=>t.concat(e,e+"-"+n[0],e+"-"+n[1])),[]),i=Math.min,r=Math.max,c=Math.round,u=Math.floor,f={left:"right",right:"left",bottom:"top",top:"bottom"},s={start:"end",end:"start"};function a(t){return t.split("-")[0]}function l(t){return t.split("-")[1]}function g(t){return"x"===t?"y":"x"}function p(t){return"y"===t?"height":"width"}function d(t){return["top","bottom"].includes(a(t))?"y":"x"}function m(t){return g(d(t))}function h(t){return t.replace(/start|end/g,(t=>s[t]))}function x(t){return t.replace(/left|right|bottom|top/g,(t=>f[t]))}function b(t){return{top:0,right:0,bottom:0,left:0,...t}}t.alignments=n,t.clamp=function(t,e,n){return r(t,i(e,n))},t.createCoords=t=>({x:t,y:t}),t.evaluate=function(t,e){return"function"==typeof t?t(e):t},t.expandPaddingObject=b,t.floor=u,t.getAlignment=l,t.getAlignmentAxis=m,t.getAlignmentSides=function(t,e,n){void 0===n&&(n=!1);const o=l(t),i=m(t),r=p(i);let c="x"===i?o===(n?"end":"start")?"right":"left":"start"===o?"bottom":"top";return e.reference[r]>e.floating[r]&&(c=x(c)),[c,x(c)]},t.getAxisLength=p,t.getExpandedPlacements=function(t){const e=x(t);return[h(t),e,h(e)]},t.getOppositeAlignmentPlacement=h,t.getOppositeAxis=g,t.getOppositeAxisPlacements=function(t,e,n,o){const i=l(t);let r=function(t,e,n){const o=["left","right"],i=["right","left"],r=["top","bottom"],c=["bottom","top"];switch(t){case"top":case"bottom":return n?e?i:o:e?o:i;case"left":case"right":return e?r:c;default:return[]}}(a(t),"start"===n,o);return i&&(r=r.map((t=>t+"-"+i)),e&&(r=r.concat(r.map(h)))),r},t.getOppositePlacement=x,t.getPaddingObject=function(t){return"number"!=typeof t?b(t):{top:t,right:t,bottom:t,left:t}},t.getSide=a,t.getSideAxis=d,t.max=r,t.min=i,t.placements=o,t.rectToClientRect=function(t){const{x:e,y:n,width:o,height:i}=t;return{width:o,height:i,top:n,left:e,right:e+o,bottom:n+i,x:e,y:n}},t.round=c,t.sides=e}));
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
declare function getComputedStyle_2(element: Element): CSSStyleDeclaration;
|
||||
export { getComputedStyle_2 as getComputedStyle }
|
||||
|
||||
export declare function getContainingBlock(element: Element): HTMLElement | null;
|
||||
|
||||
export declare function getDocumentElement(node: Node | Window): HTMLElement;
|
||||
|
||||
export declare function getNearestOverflowAncestor(node: Node): HTMLElement;
|
||||
|
||||
export declare function getNodeName(node: Node | Window): string;
|
||||
|
||||
export declare function getNodeScroll(element: Element | Window): {
|
||||
scrollLeft: number;
|
||||
scrollTop: number;
|
||||
};
|
||||
|
||||
export declare function getOverflowAncestors(node: Node, list?: OverflowAncestors, traverseIframes?: boolean): OverflowAncestors;
|
||||
|
||||
export declare function getParentNode(node: Node): Node;
|
||||
|
||||
export declare function getWindow(node: any): typeof window;
|
||||
|
||||
export declare function isContainingBlock(element: Element): boolean;
|
||||
|
||||
export declare function isElement(value: unknown): value is Element;
|
||||
|
||||
export declare function isHTMLElement(value: unknown): value is HTMLElement;
|
||||
|
||||
export declare function isLastTraversableNode(node: Node): boolean;
|
||||
|
||||
export declare function isNode(value: unknown): value is Node;
|
||||
|
||||
export declare function isOverflowElement(element: Element): boolean;
|
||||
|
||||
export declare function isShadowRoot(value: unknown): value is ShadowRoot;
|
||||
|
||||
export declare function isTableElement(element: Element): boolean;
|
||||
|
||||
export declare function isWebKit(): boolean;
|
||||
|
||||
declare type OverflowAncestors = Array<Element | Window | VisualViewport>;
|
||||
|
||||
export { }
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
export { getComputedStyle, getContainingBlock, getDocumentElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isWebKit };
|
||||
+152
@@ -0,0 +1,152 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FloatingUIUtilsDOM = {}));
|
||||
})(this, (function (exports) { 'use strict';
|
||||
|
||||
function getNodeName(node) {
|
||||
if (isNode(node)) {
|
||||
return (node.nodeName || '').toLowerCase();
|
||||
}
|
||||
// Mocked nodes in testing environments may not be instances of Node. By
|
||||
// returning `#document` an infinite loop won't occur.
|
||||
// https://github.com/floating-ui/floating-ui/issues/2317
|
||||
return '#document';
|
||||
}
|
||||
function getWindow(node) {
|
||||
var _node$ownerDocument;
|
||||
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
|
||||
}
|
||||
function getDocumentElement(node) {
|
||||
var _ref;
|
||||
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
|
||||
}
|
||||
function isNode(value) {
|
||||
return value instanceof Node || value instanceof getWindow(value).Node;
|
||||
}
|
||||
function isElement(value) {
|
||||
return value instanceof Element || value instanceof getWindow(value).Element;
|
||||
}
|
||||
function isHTMLElement(value) {
|
||||
return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
|
||||
}
|
||||
function isShadowRoot(value) {
|
||||
// Browsers without `ShadowRoot` support.
|
||||
if (typeof ShadowRoot === 'undefined') {
|
||||
return false;
|
||||
}
|
||||
return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
|
||||
}
|
||||
function isOverflowElement(element) {
|
||||
const {
|
||||
overflow,
|
||||
overflowX,
|
||||
overflowY,
|
||||
display
|
||||
} = getComputedStyle(element);
|
||||
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
|
||||
}
|
||||
function isTableElement(element) {
|
||||
return ['table', 'td', 'th'].includes(getNodeName(element));
|
||||
}
|
||||
function isContainingBlock(element) {
|
||||
const webkit = isWebKit();
|
||||
const css = getComputedStyle(element);
|
||||
|
||||
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
|
||||
return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
|
||||
}
|
||||
function getContainingBlock(element) {
|
||||
let currentNode = getParentNode(element);
|
||||
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
|
||||
if (isContainingBlock(currentNode)) {
|
||||
return currentNode;
|
||||
}
|
||||
currentNode = getParentNode(currentNode);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
function isWebKit() {
|
||||
if (typeof CSS === 'undefined' || !CSS.supports) return false;
|
||||
return CSS.supports('-webkit-backdrop-filter', 'none');
|
||||
}
|
||||
function isLastTraversableNode(node) {
|
||||
return ['html', 'body', '#document'].includes(getNodeName(node));
|
||||
}
|
||||
function getComputedStyle(element) {
|
||||
return getWindow(element).getComputedStyle(element);
|
||||
}
|
||||
function getNodeScroll(element) {
|
||||
if (isElement(element)) {
|
||||
return {
|
||||
scrollLeft: element.scrollLeft,
|
||||
scrollTop: element.scrollTop
|
||||
};
|
||||
}
|
||||
return {
|
||||
scrollLeft: element.pageXOffset,
|
||||
scrollTop: element.pageYOffset
|
||||
};
|
||||
}
|
||||
function getParentNode(node) {
|
||||
if (getNodeName(node) === 'html') {
|
||||
return node;
|
||||
}
|
||||
const result =
|
||||
// Step into the shadow DOM of the parent of a slotted node.
|
||||
node.assignedSlot ||
|
||||
// DOM Element detected.
|
||||
node.parentNode ||
|
||||
// ShadowRoot detected.
|
||||
isShadowRoot(node) && node.host ||
|
||||
// Fallback.
|
||||
getDocumentElement(node);
|
||||
return isShadowRoot(result) ? result.host : result;
|
||||
}
|
||||
function getNearestOverflowAncestor(node) {
|
||||
const parentNode = getParentNode(node);
|
||||
if (isLastTraversableNode(parentNode)) {
|
||||
return node.ownerDocument ? node.ownerDocument.body : node.body;
|
||||
}
|
||||
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
|
||||
return parentNode;
|
||||
}
|
||||
return getNearestOverflowAncestor(parentNode);
|
||||
}
|
||||
function getOverflowAncestors(node, list, traverseIframes) {
|
||||
var _node$ownerDocument2;
|
||||
if (list === void 0) {
|
||||
list = [];
|
||||
}
|
||||
if (traverseIframes === void 0) {
|
||||
traverseIframes = true;
|
||||
}
|
||||
const scrollableAncestor = getNearestOverflowAncestor(node);
|
||||
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
|
||||
const win = getWindow(scrollableAncestor);
|
||||
if (isBody) {
|
||||
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
|
||||
}
|
||||
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
|
||||
}
|
||||
|
||||
exports.getComputedStyle = getComputedStyle;
|
||||
exports.getContainingBlock = getContainingBlock;
|
||||
exports.getDocumentElement = getDocumentElement;
|
||||
exports.getNearestOverflowAncestor = getNearestOverflowAncestor;
|
||||
exports.getNodeName = getNodeName;
|
||||
exports.getNodeScroll = getNodeScroll;
|
||||
exports.getOverflowAncestors = getOverflowAncestors;
|
||||
exports.getParentNode = getParentNode;
|
||||
exports.getWindow = getWindow;
|
||||
exports.isContainingBlock = isContainingBlock;
|
||||
exports.isElement = isElement;
|
||||
exports.isHTMLElement = isHTMLElement;
|
||||
exports.isLastTraversableNode = isLastTraversableNode;
|
||||
exports.isNode = isNode;
|
||||
exports.isOverflowElement = isOverflowElement;
|
||||
exports.isShadowRoot = isShadowRoot;
|
||||
exports.isTableElement = isTableElement;
|
||||
exports.isWebKit = isWebKit;
|
||||
|
||||
}));
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"sideEffects": false,
|
||||
"main": "floating-ui.utils.dom.umd.js",
|
||||
"module": "floating-ui.utils.dom.esm.js",
|
||||
"types": "floating-ui.utils.dom.d.ts"
|
||||
}
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
{
|
||||
"name": "@floating-ui/utils",
|
||||
"version": "0.2.2",
|
||||
"description": "Utilities for Floating UI",
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"main": "./dist/floating-ui.utils.umd.js",
|
||||
"module": "./dist/floating-ui.utils.esm.js",
|
||||
"types": "./dist/floating-ui.utils.d.ts",
|
||||
"sideEffects": false,
|
||||
"files": [
|
||||
"dist",
|
||||
"dom"
|
||||
],
|
||||
"exports": {
|
||||
"./package.json": "./package.json",
|
||||
".": {
|
||||
"import": {
|
||||
"types": "./dist/floating-ui.utils.d.mts",
|
||||
"default": "./dist/floating-ui.utils.mjs"
|
||||
},
|
||||
"types": "./dist/floating-ui.utils.d.ts",
|
||||
"module": "./dist/floating-ui.utils.esm.js",
|
||||
"default": "./dist/floating-ui.utils.umd.js"
|
||||
},
|
||||
"./dom": {
|
||||
"import": {
|
||||
"types": "./dist/floating-ui.utils.dom.d.mts",
|
||||
"default": "./dist/floating-ui.utils.dom.mjs"
|
||||
},
|
||||
"types": "./dist/floating-ui.utils.dom.d.ts",
|
||||
"module": "./dist/floating-ui.utils.dom.esm.js",
|
||||
"default": "./dist/floating-ui.utils.dom.umd.js"
|
||||
}
|
||||
},
|
||||
"author": "atomiks",
|
||||
"license": "MIT",
|
||||
"bugs": "https://github.com/floating-ui/floating-ui",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/floating-ui/floating-ui.git",
|
||||
"directory": "packages/utils"
|
||||
},
|
||||
"homepage": "https://floating-ui.com",
|
||||
"keywords": [
|
||||
"tooltip",
|
||||
"popover",
|
||||
"dropdown",
|
||||
"menu",
|
||||
"popup",
|
||||
"positioning"
|
||||
],
|
||||
"devDependencies": {
|
||||
"@testing-library/jest-dom": "^6.1.6",
|
||||
"config": "0.0.0"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint .",
|
||||
"format": "prettier --write .",
|
||||
"clean": "rimraf dist out-tsc dom react",
|
||||
"test": "vitest run --globals",
|
||||
"test:watch": "vitest watch --globals",
|
||||
"dev": "rollup -c -w",
|
||||
"build": "rollup -c",
|
||||
"build:api": "build-api --tsc tsconfig.lib.json --aec api-extractor.json --aec api-extractor.dom.json --aec api-extractor.react.json",
|
||||
"publint": "publint",
|
||||
"typecheck": "tsc -b"
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user