@fluentui/react-positioning 9.17.1 → 9.17.2

package/lib-commonjs/middleware/flip.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/flip.ts"],"sourcesContent":["import { flip as baseFlip, Placement } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getBoundary, resolvePositioningShorthand, toFloatingUIPlacement } from '../utils/index';\n\nexport interface FlipMiddlewareOptions extends Pick<PositioningOptions, 'flipBoundary' | 'fallbackPositions'> {\n  hasScrollableElement?: boolean;\n  container: HTMLElement | null;\n  isRtl?: boolean;\n}\n\nexport function flip(options: FlipMiddlewareOptions) {\n  const { hasScrollableElement, flipBoundary, container, fallbackPositions = [], isRtl } = options;\n\n  const fallbackPlacements = fallbackPositions.reduce<Placement[]>((acc, shorthand) => {\n    const { position, align } = resolvePositioningShorthand(shorthand);\n    const placement = toFloatingUIPlacement(align, position, isRtl);\n    if (placement) {\n      acc.push(placement);\n    }\n    return acc;\n  }, []);\n\n  return baseFlip({\n    ...(hasScrollableElement && { boundary: 'clippingAncestors' }),\n    ...(flipBoundary && { altBoundary: true, boundary: getBoundary(container, flipBoundary) }),\n    fallbackStrategy: 'bestFit',\n    ...(fallbackPlacements.length && { fallbackPlacements }),\n  });\n}\n"],"names":["flip","options","hasScrollableElement","flipBoundary","container","fallbackPositions","isRtl","fallbackPlacements","reduce","acc","shorthand","position","align","resolvePositioningShorthand","placement","toFloatingUIPlacement","push","baseFlip","boundary","altBoundary","getBoundary","fallbackStrategy","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUgBA;;;eAAAA;;;qBAV4B;uBAEoC;AAQzE,SAASA,KAAKC,OAA8B;IACjD,MAAM,EAAEC,oBAAoB,EAAEC,YAAY,EAAEC,SAAS,EAAEC,oBAAoB,EAAE,EAAEC,KAAK,EAAE,GAAGL;IAEzF,MAAMM,qBAAqBF,kBAAkBG,MAAM,CAAc,CAACC,KAAKC;QACrE,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGC,IAAAA,kCAA2B,EAACH;QACxD,MAAMI,YAAYC,IAAAA,4BAAqB,EAACH,OAAOD,UAAUL;QACzD,IAAIQ,WAAW;YACbL,IAAIO,IAAI,CAACF;QACX;QACA,OAAOL;IACT,GAAG,EAAE;IAEL,OAAOQ,IAAAA,SAAQ,EAAC;QACd,GAAIf,wBAAwB;YAAEgB,UAAU;QAAoB,CAAC;QAC7D,GAAIf,gBAAgB;YAAEgB,aAAa;YAAMD,UAAUE,IAAAA,kBAAW,EAAChB,WAAWD;QAAc,CAAC;QACzFkB,kBAAkB;QAClB,GAAId,mBAAmBe,MAAM,IAAI;YAAEf;QAAmB,CAAC;IACzD;AACF"}
+{"version":3,"sources":["../src/middleware/flip.ts"],"sourcesContent":["import { flip as baseFlip, Placement } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getBoundary, resolvePositioningShorthand, toFloatingUIPlacement } from '../utils/index';\n\nexport interface FlipMiddlewareOptions extends Pick<PositioningOptions, 'flipBoundary' | 'fallbackPositions'> {\n  hasScrollableElement?: boolean;\n  container: HTMLElement | null;\n  isRtl?: boolean;\n}\n\nexport function flip(options: FlipMiddlewareOptions) {\n  const { hasScrollableElement, flipBoundary, container, fallbackPositions = [], isRtl } = options;\n\n  const fallbackPlacements = fallbackPositions.reduce<Placement[]>((acc, shorthand) => {\n    const { position, align } = resolvePositioningShorthand(shorthand);\n    const placement = toFloatingUIPlacement(align, position, isRtl);\n    if (placement) {\n      acc.push(placement);\n    }\n    return acc;\n  }, []);\n\n  return baseFlip({\n    ...(hasScrollableElement && { boundary: 'clippingAncestors' }),\n    ...(flipBoundary && { altBoundary: true, boundary: getBoundary(container, flipBoundary) }),\n    fallbackStrategy: 'bestFit',\n    ...(fallbackPlacements.length && { fallbackPlacements }),\n  });\n}\n"],"names":["flip","options","hasScrollableElement","flipBoundary","container","fallbackPositions","isRtl","fallbackPlacements","reduce","acc","shorthand","position","align","resolvePositioningShorthand","placement","toFloatingUIPlacement","push","baseFlip","boundary","altBoundary","getBoundary","fallbackStrategy","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUgBA;;;eAAAA;;;qBAV4B;uBAEoC;AAQzE,SAASA,KAAKC,OAA8B;IACjD,MAAM,EAAEC,oBAAoB,EAAEC,YAAY,EAAEC,SAAS,EAAEC,oBAAoB,EAAE,EAAEC,KAAK,EAAE,GAAGL;IAEzF,MAAMM,qBAAqBF,kBAAkBG,MAAM,CAAc,CAACC,KAAKC;QACrE,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGC,IAAAA,kCAAAA,EAA4BH;QACxD,MAAMI,YAAYC,IAAAA,4BAAAA,EAAsBH,OAAOD,UAAUL;QACzD,IAAIQ,WAAW;YACbL,IAAIO,IAAI,CAACF;QACX;QACA,OAAOL;IACT,GAAG,EAAE;IAEL,OAAOQ,IAAAA,SAAAA,EAAS;QACd,GAAIf,wBAAwB;YAAEgB,UAAU;QAAoB,CAAC;QAC7D,GAAIf,gBAAgB;YAAEgB,aAAa;YAAMD,UAAUE,IAAAA,kBAAAA,EAAYhB,WAAWD;QAAc,CAAC;QACzFkB,kBAAkB;QAClB,GAAId,mBAAmBe,MAAM,IAAI;YAAEf;QAAmB,CAAC;IACzD;AACF"}

package/lib-commonjs/middleware/intersecting.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/intersecting.ts"],"sourcesContent":["import type { Middleware } from '@floating-ui/dom';\nimport { detectOverflow } from '@floating-ui/dom';\n\nexport function intersecting(): Middleware {\n  return {\n    name: 'intersectionObserver',\n    fn: async middlewareArguments => {\n      const floatingRect = middlewareArguments.rects.floating;\n      const altOverflow = await detectOverflow(middlewareArguments, { altBoundary: true });\n\n      const isIntersectingTop = altOverflow.top < floatingRect.height && altOverflow.top > 0;\n      const isIntersectingBottom = altOverflow.bottom < floatingRect.height && altOverflow.bottom > 0;\n\n      const isIntersecting = isIntersectingTop || isIntersectingBottom;\n\n      return {\n        data: {\n          intersecting: isIntersecting,\n        },\n      };\n    },\n  };\n}\n"],"names":["intersecting","name","fn","middlewareArguments","floatingRect","rects","floating","altOverflow","detectOverflow","altBoundary","isIntersectingTop","top","height","isIntersectingBottom","bottom","isIntersecting","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;qBAFe;AAExB,SAASA;IACd,OAAO;QACLC,MAAM;QACNC,IAAI,OAAMC;YACR,MAAMC,eAAeD,oBAAoBE,KAAK,CAACC,QAAQ;YACvD,MAAMC,cAAc,MAAMC,IAAAA,mBAAc,EAACL,qBAAqB;gBAAEM,aAAa;YAAK;YAElF,MAAMC,oBAAoBH,YAAYI,GAAG,GAAGP,aAAaQ,MAAM,IAAIL,YAAYI,GAAG,GAAG;YACrF,MAAME,uBAAuBN,YAAYO,MAAM,GAAGV,aAAaQ,MAAM,IAAIL,YAAYO,MAAM,GAAG;YAE9F,MAAMC,iBAAiBL,qBAAqBG;YAE5C,OAAO;gBACLG,MAAM;oBACJhB,cAAce;gBAChB;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/middleware/intersecting.ts"],"sourcesContent":["import type { Middleware } from '@floating-ui/dom';\nimport { detectOverflow } from '@floating-ui/dom';\n\nexport function intersecting(): Middleware {\n  return {\n    name: 'intersectionObserver',\n    fn: async middlewareArguments => {\n      const floatingRect = middlewareArguments.rects.floating;\n      const altOverflow = await detectOverflow(middlewareArguments, { altBoundary: true });\n\n      const isIntersectingTop = altOverflow.top < floatingRect.height && altOverflow.top > 0;\n      const isIntersectingBottom = altOverflow.bottom < floatingRect.height && altOverflow.bottom > 0;\n\n      const isIntersecting = isIntersectingTop || isIntersectingBottom;\n\n      return {\n        data: {\n          intersecting: isIntersecting,\n        },\n      };\n    },\n  };\n}\n"],"names":["intersecting","name","fn","middlewareArguments","floatingRect","rects","floating","altOverflow","detectOverflow","altBoundary","isIntersectingTop","top","height","isIntersectingBottom","bottom","isIntersecting","data"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;qBAFe;AAExB,SAASA;IACd,OAAO;QACLC,MAAM;QACNC,IAAI,OAAMC;YACR,MAAMC,eAAeD,oBAAoBE,KAAK,CAACC,QAAQ;YACvD,MAAMC,cAAc,MAAMC,IAAAA,mBAAAA,EAAeL,qBAAqB;gBAAEM,aAAa;YAAK;YAElF,MAAMC,oBAAoBH,YAAYI,GAAG,GAAGP,aAAaQ,MAAM,IAAIL,YAAYI,GAAG,GAAG;YACrF,MAAME,uBAAuBN,YAAYO,MAAM,GAAGV,aAAaQ,MAAM,IAAIL,YAAYO,MAAM,GAAG;YAE9F,MAAMC,iBAAiBL,qBAAqBG;YAE5C,OAAO;gBACLG,MAAM;oBACJhB,cAAce;gBAChB;YACF;QACF;IACF;AACF"}

package/lib-commonjs/middleware/matchTargetSize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/matchTargetSize.ts"],"sourcesContent":["import type { Middleware } from '@floating-ui/dom';\n\nexport const matchTargetSizeCssVar = '--fui-match-target-size';\n\nexport function matchTargetSize(): Middleware {\n  return {\n    name: 'matchTargetSize',\n    fn: async middlewareArguments => {\n      const {\n        rects: { reference: referenceRect, floating: floatingRect },\n        elements: { floating: floatingElement },\n        middlewareData: { matchTargetSize: { matchTargetSizeAttempt = false } = {} },\n      } = middlewareArguments;\n\n      if (referenceRect.width === floatingRect.width || matchTargetSizeAttempt) {\n        return {};\n      }\n\n      const { width } = referenceRect;\n      floatingElement.style.setProperty(matchTargetSizeCssVar, `${width}px`);\n      if (!floatingElement.style.width) {\n        floatingElement.style.width = `var(${matchTargetSizeCssVar})`;\n      }\n\n      return {\n        data: { matchTargetSizeAttempt: true },\n        reset: {\n          rects: true,\n        },\n      };\n    },\n  };\n}\n"],"names":["matchTargetSize","matchTargetSizeCssVar","name","fn","middlewareArguments","rects","reference","referenceRect","floating","floatingRect","elements","floatingElement","middlewareData","matchTargetSizeAttempt","width","style","setProperty","data","reset"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAIgBA,eAAe;eAAfA;;IAFHC,qBAAqB;eAArBA;;;AAAN,MAAMA,wBAAwB;AAE9B,SAASD;IACd,OAAO;QACLE,MAAM;QACNC,IAAI,OAAMC;YACR,MAAM,EACJC,OAAO,EAAEC,WAAWC,aAAa,EAAEC,UAAUC,YAAY,EAAE,EAC3DC,UAAU,EAAEF,UAAUG,eAAe,EAAE,EACvCC,gBAAgB,EAAEZ,iBAAiB,EAAEa,yBAAyB,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE,EAC7E,GAAGT;YAEJ,IAAIG,cAAcO,KAAK,KAAKL,aAAaK,KAAK,IAAID,wBAAwB;gBACxE,OAAO,CAAC;YACV;YAEA,MAAM,EAAEC,KAAK,EAAE,GAAGP;YAClBI,gBAAgBI,KAAK,CAACC,WAAW,CAACf,uBAAuB,CAAC,EAAEa,MAAM,EAAE,CAAC;YACrE,IAAI,CAACH,gBAAgBI,KAAK,CAACD,KAAK,EAAE;gBAChCH,gBAAgBI,KAAK,CAACD,KAAK,GAAG,CAAC,IAAI,EAAEb,sBAAsB,CAAC,CAAC;YAC/D;YAEA,OAAO;gBACLgB,MAAM;oBAAEJ,wBAAwB;gBAAK;gBACrCK,OAAO;oBACLb,OAAO;gBACT;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/middleware/matchTargetSize.ts"],"sourcesContent":["import type { Middleware } from '@floating-ui/dom';\n\nexport const matchTargetSizeCssVar = '--fui-match-target-size';\n\nexport function matchTargetSize(): Middleware {\n  return {\n    name: 'matchTargetSize',\n    fn: async middlewareArguments => {\n      const {\n        rects: { reference: referenceRect, floating: floatingRect },\n        elements: { floating: floatingElement },\n        middlewareData: { matchTargetSize: { matchTargetSizeAttempt = false } = {} },\n      } = middlewareArguments;\n\n      if (referenceRect.width === floatingRect.width || matchTargetSizeAttempt) {\n        return {};\n      }\n\n      const { width } = referenceRect;\n      floatingElement.style.setProperty(matchTargetSizeCssVar, `${width}px`);\n      if (!floatingElement.style.width) {\n        floatingElement.style.width = `var(${matchTargetSizeCssVar})`;\n      }\n\n      return {\n        data: { matchTargetSizeAttempt: true },\n        reset: {\n          rects: true,\n        },\n      };\n    },\n  };\n}\n"],"names":["matchTargetSize","matchTargetSizeCssVar","name","fn","middlewareArguments","rects","reference","referenceRect","floating","floatingRect","elements","floatingElement","middlewareData","matchTargetSizeAttempt","width","style","setProperty","data","reset"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAIgBA,eAAAA;eAAAA;;IAFHC,qBAAAA;eAAAA;;;AAAN,MAAMA,wBAAwB;AAE9B,SAASD;IACd,OAAO;QACLE,MAAM;QACNC,IAAI,OAAMC;YACR,MAAM,EACJC,OAAO,EAAEC,WAAWC,aAAa,EAAEC,UAAUC,YAAY,EAAE,EAC3DC,UAAU,EAAEF,UAAUG,eAAe,EAAE,EACvCC,gBAAgB,EAAEZ,iBAAiB,EAAEa,yBAAyB,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE,EAC7E,GAAGT;YAEJ,IAAIG,cAAcO,KAAK,KAAKL,aAAaK,KAAK,IAAID,wBAAwB;gBACxE,OAAO,CAAC;YACV;YAEA,MAAM,EAAEC,KAAK,EAAE,GAAGP;YAClBI,gBAAgBI,KAAK,CAACC,WAAW,CAACf,uBAAuB,CAAC,EAAEa,MAAM,EAAE,CAAC;YACrE,IAAI,CAACH,gBAAgBI,KAAK,CAACD,KAAK,EAAE;gBAChCH,gBAAgBI,KAAK,CAACD,KAAK,GAAG,CAAC,IAAI,EAAEb,sBAAsB,CAAC,CAAC;YAC/D;YAEA,OAAO;gBACLgB,MAAM;oBAAEJ,wBAAwB;gBAAK;gBACrCK,OAAO;oBACLb,OAAO;gBACT;YACF;QACF;IACF;AACF"}

package/lib-commonjs/middleware/maxSize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/maxSize.ts"],"sourcesContent":["import { size } from '@floating-ui/dom';\nimport type { Middleware } from '@floating-ui/dom';\nimport type { NormalizedAutoSize, PositioningOptions } from '../types';\nimport { getBoundary } from '../utils/getBoundary';\nimport { toFloatingUIPadding } from '../utils';\nexport interface MaxSizeMiddlewareOptions\n  extends Pick<PositioningOptions, 'overflowBoundary' | 'overflowBoundaryPadding'> {\n  container: HTMLElement | null;\n  isRtl: boolean;\n}\n\n/**\n * floating-ui `size` middleware uses floating element's height/width to calculate available height/width.\n * This middleware only runs once per lifecycle, resetting styles applied by maxSize from previous lifecycle.\n * Then floating element's original size is restored and `size` middleware can calculate available height/width correctly.\n */\nexport const resetMaxSize = (autoSize: NormalizedAutoSize): Middleware => ({\n  name: 'resetMaxSize',\n  fn({ middlewareData, elements }) {\n    if (middlewareData.resetMaxSize?.maxSizeAlreadyReset) {\n      return {};\n    }\n\n    const { applyMaxWidth, applyMaxHeight } = autoSize;\n    if (applyMaxWidth) {\n      elements.floating.style.removeProperty('box-sizing');\n      elements.floating.style.removeProperty('max-width');\n      elements.floating.style.removeProperty('width');\n    }\n    if (applyMaxHeight) {\n      elements.floating.style.removeProperty('box-sizing');\n      elements.floating.style.removeProperty('max-height');\n      elements.floating.style.removeProperty('height');\n    }\n\n    return {\n      data: { maxSizeAlreadyReset: true },\n      reset: { rects: true },\n    };\n  },\n});\n\nexport function maxSize(autoSize: NormalizedAutoSize, options: MaxSizeMiddlewareOptions): Middleware {\n  const { container, overflowBoundary, overflowBoundaryPadding, isRtl } = options;\n  return size({\n    ...(overflowBoundaryPadding && { padding: toFloatingUIPadding(overflowBoundaryPadding, isRtl) }),\n    ...(overflowBoundary && { altBoundary: true, boundary: getBoundary(container, overflowBoundary) }),\n    apply({ availableHeight, availableWidth, elements, rects }) {\n      const applyMaxSizeStyles = (apply: boolean, dimension: 'width' | 'height', availableSize: number) => {\n        if (!apply) {\n          return;\n        }\n\n        elements.floating.style.setProperty('box-sizing', 'border-box');\n        elements.floating.style.setProperty(`max-${dimension}`, `${availableSize}px`);\n\n        if (rects.floating[dimension] > availableSize) {\n          elements.floating.style.setProperty(dimension, `${availableSize}px`);\n\n          const axis = dimension === 'width' ? 'x' : 'y';\n          if (!elements.floating.style.getPropertyValue(`overflow-${axis}`)) {\n            elements.floating.style.setProperty(`overflow-${axis}`, 'auto');\n          }\n        }\n      };\n\n      const { applyMaxWidth, applyMaxHeight } = autoSize;\n      applyMaxSizeStyles(applyMaxWidth, 'width', availableWidth);\n      applyMaxSizeStyles(applyMaxHeight, 'height', availableHeight);\n    },\n  });\n}\n"],"names":["maxSize","resetMaxSize","autoSize","name","fn","middlewareData","elements","maxSizeAlreadyReset","applyMaxWidth","applyMaxHeight","floating","style","removeProperty","data","reset","rects","options","container","overflowBoundary","overflowBoundaryPadding","isRtl","size","padding","toFloatingUIPadding","altBoundary","boundary","getBoundary","apply","availableHeight","availableWidth","applyMaxSizeStyles","dimension","availableSize","setProperty","axis","getPropertyValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA0CgBA,OAAO;eAAPA;;IA1BHC,YAAY;eAAZA;;;qBAhBQ;6BAGO;uBACQ;AAY7B,MAAMA,eAAe,CAACC,WAA8C,CAAA;QACzEC,MAAM;QACNC,IAAG,EAAEC,cAAc,EAAEC,QAAQ,EAAE;gBACzBD;YAAJ,KAAIA,+BAAAA,eAAeJ,YAAY,cAA3BI,mDAAAA,6BAA6BE,mBAAmB,EAAE;gBACpD,OAAO,CAAC;YACV;YAEA,MAAM,EAAEC,aAAa,EAAEC,cAAc,EAAE,GAAGP;YAC1C,IAAIM,eAAe;gBACjBF,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;YACzC;YACA,IAAIH,gBAAgB;gBAClBH,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;YACzC;YAEA,OAAO;gBACLC,MAAM;oBAAEN,qBAAqB;gBAAK;gBAClCO,OAAO;oBAAEC,OAAO;gBAAK;YACvB;QACF;IACF,CAAA;AAEO,SAASf,QAAQE,QAA4B,EAAEc,OAAiC;IACrF,MAAM,EAAEC,SAAS,EAAEC,gBAAgB,EAAEC,uBAAuB,EAAEC,KAAK,EAAE,GAAGJ;IACxE,OAAOK,IAAAA,SAAI,EAAC;QACV,GAAIF,2BAA2B;YAAEG,SAASC,IAAAA,0BAAmB,EAACJ,yBAAyBC;QAAO,CAAC;QAC/F,GAAIF,oBAAoB;YAAEM,aAAa;YAAMC,UAAUC,IAAAA,wBAAW,EAACT,WAAWC;QAAkB,CAAC;QACjGS,OAAM,EAAEC,eAAe,EAAEC,cAAc,EAAEvB,QAAQ,EAAES,KAAK,EAAE;YACxD,MAAMe,qBAAqB,CAACH,OAAgBI,WAA+BC;gBACzE,IAAI,CAACL,OAAO;oBACV;gBACF;gBAEArB,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,cAAc;gBAClD3B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,CAAC,IAAI,EAAEF,UAAU,CAAC,EAAE,CAAC,EAAEC,cAAc,EAAE,CAAC;gBAE5E,IAAIjB,MAAML,QAAQ,CAACqB,UAAU,GAAGC,eAAe;oBAC7C1B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAACF,WAAW,CAAC,EAAEC,cAAc,EAAE,CAAC;oBAEnE,MAAME,OAAOH,cAAc,UAAU,MAAM;oBAC3C,IAAI,CAACzB,SAASI,QAAQ,CAACC,KAAK,CAACwB,gBAAgB,CAAC,CAAC,SAAS,EAAED,KAAK,CAAC,GAAG;wBACjE5B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,CAAC,SAAS,EAAEC,KAAK,CAAC,EAAE;oBAC1D;gBACF;YACF;YAEA,MAAM,EAAE1B,aAAa,EAAEC,cAAc,EAAE,GAAGP;YAC1C4B,mBAAmBtB,eAAe,SAASqB;YAC3CC,mBAAmBrB,gBAAgB,UAAUmB;QAC/C;IACF;AACF"}
+{"version":3,"sources":["../src/middleware/maxSize.ts"],"sourcesContent":["import { size } from '@floating-ui/dom';\nimport type { Middleware } from '@floating-ui/dom';\nimport type { NormalizedAutoSize, PositioningOptions } from '../types';\nimport { getBoundary } from '../utils/getBoundary';\nimport { toFloatingUIPadding } from '../utils';\nexport interface MaxSizeMiddlewareOptions\n  extends Pick<PositioningOptions, 'overflowBoundary' | 'overflowBoundaryPadding'> {\n  container: HTMLElement | null;\n  isRtl: boolean;\n}\n\n/**\n * floating-ui `size` middleware uses floating element's height/width to calculate available height/width.\n * This middleware only runs once per lifecycle, resetting styles applied by maxSize from previous lifecycle.\n * Then floating element's original size is restored and `size` middleware can calculate available height/width correctly.\n */\nexport const resetMaxSize = (autoSize: NormalizedAutoSize): Middleware => ({\n  name: 'resetMaxSize',\n  fn({ middlewareData, elements }) {\n    if (middlewareData.resetMaxSize?.maxSizeAlreadyReset) {\n      return {};\n    }\n\n    const { applyMaxWidth, applyMaxHeight } = autoSize;\n    if (applyMaxWidth) {\n      elements.floating.style.removeProperty('box-sizing');\n      elements.floating.style.removeProperty('max-width');\n      elements.floating.style.removeProperty('width');\n    }\n    if (applyMaxHeight) {\n      elements.floating.style.removeProperty('box-sizing');\n      elements.floating.style.removeProperty('max-height');\n      elements.floating.style.removeProperty('height');\n    }\n\n    return {\n      data: { maxSizeAlreadyReset: true },\n      reset: { rects: true },\n    };\n  },\n});\n\nexport function maxSize(autoSize: NormalizedAutoSize, options: MaxSizeMiddlewareOptions): Middleware {\n  const { container, overflowBoundary, overflowBoundaryPadding, isRtl } = options;\n  return size({\n    ...(overflowBoundaryPadding && { padding: toFloatingUIPadding(overflowBoundaryPadding, isRtl) }),\n    ...(overflowBoundary && { altBoundary: true, boundary: getBoundary(container, overflowBoundary) }),\n    apply({ availableHeight, availableWidth, elements, rects }) {\n      const applyMaxSizeStyles = (apply: boolean, dimension: 'width' | 'height', availableSize: number) => {\n        if (!apply) {\n          return;\n        }\n\n        elements.floating.style.setProperty('box-sizing', 'border-box');\n        elements.floating.style.setProperty(`max-${dimension}`, `${availableSize}px`);\n\n        if (rects.floating[dimension] > availableSize) {\n          elements.floating.style.setProperty(dimension, `${availableSize}px`);\n\n          const axis = dimension === 'width' ? 'x' : 'y';\n          if (!elements.floating.style.getPropertyValue(`overflow-${axis}`)) {\n            elements.floating.style.setProperty(`overflow-${axis}`, 'auto');\n          }\n        }\n      };\n\n      const { applyMaxWidth, applyMaxHeight } = autoSize;\n      applyMaxSizeStyles(applyMaxWidth, 'width', availableWidth);\n      applyMaxSizeStyles(applyMaxHeight, 'height', availableHeight);\n    },\n  });\n}\n"],"names":["maxSize","resetMaxSize","autoSize","name","fn","middlewareData","elements","maxSizeAlreadyReset","applyMaxWidth","applyMaxHeight","floating","style","removeProperty","data","reset","rects","options","container","overflowBoundary","overflowBoundaryPadding","isRtl","size","padding","toFloatingUIPadding","altBoundary","boundary","getBoundary","apply","availableHeight","availableWidth","applyMaxSizeStyles","dimension","availableSize","setProperty","axis","getPropertyValue"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA0CgBA,OAAAA;eAAAA;;IA1BHC,YAAAA;eAAAA;;;qBAhBQ;6BAGO;uBACQ;AAY7B,MAAMA,eAAe,CAACC,WAA8C,CAAA;QACzEC,MAAM;QACNC,IAAG,EAAEC,cAAc,EAAEC,QAAQ,EAAE;gBACzBD;YAAJ,IAAA,AAAIA,CAAAA,+BAAAA,eAAeJ,YAAY,AAAZA,MAAY,QAA3BI,iCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,6BAA6BE,mBAAmB,EAAE;gBACpD,OAAO,CAAC;YACV;YAEA,MAAM,EAAEC,aAAa,EAAEC,cAAc,EAAE,GAAGP;YAC1C,IAAIM,eAAe;gBACjBF,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;YACzC;YACA,IAAIH,gBAAgB;gBAClBH,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;gBACvCN,SAASI,QAAQ,CAACC,KAAK,CAACC,cAAc,CAAC;YACzC;YAEA,OAAO;gBACLC,MAAM;oBAAEN,qBAAqB;gBAAK;gBAClCO,OAAO;oBAAEC,OAAO;gBAAK;YACvB;QACF;IACF,CAAA;AAEO,SAASf,QAAQE,QAA4B,EAAEc,OAAiC;IACrF,MAAM,EAAEC,SAAS,EAAEC,gBAAgB,EAAEC,uBAAuB,EAAEC,KAAK,EAAE,GAAGJ;IACxE,OAAOK,IAAAA,SAAAA,EAAK;QACV,GAAIF,2BAA2B;YAAEG,SAASC,IAAAA,0BAAAA,EAAoBJ,yBAAyBC;QAAO,CAAC;QAC/F,GAAIF,oBAAoB;YAAEM,aAAa;YAAMC,UAAUC,IAAAA,wBAAAA,EAAYT,WAAWC;QAAkB,CAAC;QACjGS,OAAM,EAAEC,eAAe,EAAEC,cAAc,EAAEvB,QAAQ,EAAES,KAAK,EAAE;YACxD,MAAMe,qBAAqB,CAACH,OAAgBI,WAA+BC;gBACzE,IAAI,CAACL,OAAO;oBACV;gBACF;gBAEArB,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,cAAc;gBAClD3B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,CAAC,IAAI,EAAEF,UAAU,CAAC,EAAE,CAAC,EAAEC,cAAc,EAAE,CAAC;gBAE5E,IAAIjB,MAAML,QAAQ,CAACqB,UAAU,GAAGC,eAAe;oBAC7C1B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAACF,WAAW,CAAC,EAAEC,cAAc,EAAE,CAAC;oBAEnE,MAAME,OAAOH,cAAc,UAAU,MAAM;oBAC3C,IAAI,CAACzB,SAASI,QAAQ,CAACC,KAAK,CAACwB,gBAAgB,CAAC,CAAC,SAAS,EAAED,KAAK,CAAC,GAAG;wBACjE5B,SAASI,QAAQ,CAACC,KAAK,CAACsB,WAAW,CAAC,CAAC,SAAS,EAAEC,KAAK,CAAC,EAAE;oBAC1D;gBACF;YACF;YAEA,MAAM,EAAE1B,aAAa,EAAEC,cAAc,EAAE,GAAGP;YAC1C4B,mBAAmBtB,eAAe,SAASqB;YAC3CC,mBAAmBrB,gBAAgB,UAAUmB;QAC/C;IACF;AACF"}

package/lib-commonjs/middleware/offset.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/offset.ts"],"sourcesContent":["import { offset as baseOffset } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getFloatingUIOffset } from '../utils/getFloatingUIOffset';\n\n/**\n * Wraps floating UI offset middleware to transform offset value.\n */\nexport function offset(offsetValue: PositioningOptions['offset']) {\n  const floatingUIOffset = getFloatingUIOffset(offsetValue);\n  return baseOffset(floatingUIOffset);\n}\n"],"names":["offset","offsetValue","floatingUIOffset","getFloatingUIOffset","baseOffset"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BAOgBA;;;eAAAA;;;qBAPqB;qCAED;AAK7B,SAASA,OAAOC,WAAyC;IAC9D,MAAMC,mBAAmBC,IAAAA,wCAAmB,EAACF;IAC7C,OAAOG,IAAAA,WAAU,EAACF;AACpB"}
+{"version":3,"sources":["../src/middleware/offset.ts"],"sourcesContent":["import { offset as baseOffset } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getFloatingUIOffset } from '../utils/getFloatingUIOffset';\n\n/**\n * Wraps floating UI offset middleware to transform offset value.\n */\nexport function offset(offsetValue: PositioningOptions['offset']) {\n  const floatingUIOffset = getFloatingUIOffset(offsetValue);\n  return baseOffset(floatingUIOffset);\n}\n"],"names":["offset","offsetValue","floatingUIOffset","getFloatingUIOffset","baseOffset"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BAOgBA;;;eAAAA;;;qBAPqB;qCAED;AAK7B,SAASA,OAAOC,WAAyC;IAC9D,MAAMC,mBAAmBC,IAAAA,wCAAAA,EAAoBF;IAC7C,OAAOG,IAAAA,WAAAA,EAAWF;AACpB"}

package/lib-commonjs/middleware/shift.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/middleware/shift.ts"],"sourcesContent":["import { shift as baseShift, limitShift } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getBoundary, toFloatingUIPadding } from '../utils/index';\n\nexport interface ShiftMiddlewareOptions\n  extends Pick<PositioningOptions, 'overflowBoundary' | 'overflowBoundaryPadding' | 'shiftToCoverTarget'> {\n  hasScrollableElement?: boolean;\n  disableTether?: PositioningOptions['unstable_disableTether'];\n  container: HTMLElement | null;\n  isRtl: boolean;\n}\n\n/**\n * Wraps the floating UI shift middleware for easier usage of our options\n */\nexport function shift(options: ShiftMiddlewareOptions) {\n  const {\n    hasScrollableElement,\n    shiftToCoverTarget,\n    disableTether,\n    overflowBoundary,\n    container,\n    overflowBoundaryPadding,\n    isRtl,\n  } = options;\n\n  return baseShift({\n    ...(hasScrollableElement && { boundary: 'clippingAncestors' }),\n    ...(shiftToCoverTarget && {\n      crossAxis: true,\n      limiter: limitShift({ crossAxis: true, mainAxis: false }),\n    }),\n    ...(disableTether && {\n      crossAxis: disableTether === 'all',\n      limiter: limitShift({ crossAxis: disableTether !== 'all', mainAxis: false }),\n    }),\n    ...(overflowBoundaryPadding && { padding: toFloatingUIPadding(overflowBoundaryPadding, isRtl) }),\n    ...(overflowBoundary && { altBoundary: true, boundary: getBoundary(container, overflowBoundary) }),\n  });\n}\n"],"names":["shift","options","hasScrollableElement","shiftToCoverTarget","disableTether","overflowBoundary","container","overflowBoundaryPadding","isRtl","baseShift","boundary","crossAxis","limiter","limitShift","mainAxis","padding","toFloatingUIPadding","altBoundary","getBoundary"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAegBA;;;eAAAA;;;qBAf+B;uBAEE;AAa1C,SAASA,MAAMC,OAA+B;IACnD,MAAM,EACJC,oBAAoB,EACpBC,kBAAkB,EAClBC,aAAa,EACbC,gBAAgB,EAChBC,SAAS,EACTC,uBAAuB,EACvBC,KAAK,EACN,GAAGP;IAEJ,OAAOQ,IAAAA,UAAS,EAAC;QACf,GAAIP,wBAAwB;YAAEQ,UAAU;QAAoB,CAAC;QAC7D,GAAIP,sBAAsB;YACxBQ,WAAW;YACXC,SAASC,IAAAA,eAAU,EAAC;gBAAEF,WAAW;gBAAMG,UAAU;YAAM;QACzD,CAAC;QACD,GAAIV,iBAAiB;YACnBO,WAAWP,kBAAkB;YAC7BQ,SAASC,IAAAA,eAAU,EAAC;gBAAEF,WAAWP,kBAAkB;gBAAOU,UAAU;YAAM;QAC5E,CAAC;QACD,GAAIP,2BAA2B;YAAEQ,SAASC,IAAAA,0BAAmB,EAACT,yBAAyBC;QAAO,CAAC;QAC/F,GAAIH,oBAAoB;YAAEY,aAAa;YAAMP,UAAUQ,IAAAA,kBAAW,EAACZ,WAAWD;QAAkB,CAAC;IACnG;AACF"}
+{"version":3,"sources":["../src/middleware/shift.ts"],"sourcesContent":["import { shift as baseShift, limitShift } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { getBoundary, toFloatingUIPadding } from '../utils/index';\n\nexport interface ShiftMiddlewareOptions\n  extends Pick<PositioningOptions, 'overflowBoundary' | 'overflowBoundaryPadding' | 'shiftToCoverTarget'> {\n  hasScrollableElement?: boolean;\n  disableTether?: PositioningOptions['unstable_disableTether'];\n  container: HTMLElement | null;\n  isRtl: boolean;\n}\n\n/**\n * Wraps the floating UI shift middleware for easier usage of our options\n */\nexport function shift(options: ShiftMiddlewareOptions) {\n  const {\n    hasScrollableElement,\n    shiftToCoverTarget,\n    disableTether,\n    overflowBoundary,\n    container,\n    overflowBoundaryPadding,\n    isRtl,\n  } = options;\n\n  return baseShift({\n    ...(hasScrollableElement && { boundary: 'clippingAncestors' }),\n    ...(shiftToCoverTarget && {\n      crossAxis: true,\n      limiter: limitShift({ crossAxis: true, mainAxis: false }),\n    }),\n    ...(disableTether && {\n      crossAxis: disableTether === 'all',\n      limiter: limitShift({ crossAxis: disableTether !== 'all', mainAxis: false }),\n    }),\n    ...(overflowBoundaryPadding && { padding: toFloatingUIPadding(overflowBoundaryPadding, isRtl) }),\n    ...(overflowBoundary && { altBoundary: true, boundary: getBoundary(container, overflowBoundary) }),\n  });\n}\n"],"names":["shift","options","hasScrollableElement","shiftToCoverTarget","disableTether","overflowBoundary","container","overflowBoundaryPadding","isRtl","baseShift","boundary","crossAxis","limiter","limitShift","mainAxis","padding","toFloatingUIPadding","altBoundary","getBoundary"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAegBA;;;eAAAA;;;qBAf+B;uBAEE;AAa1C,SAASA,MAAMC,OAA+B;IACnD,MAAM,EACJC,oBAAoB,EACpBC,kBAAkB,EAClBC,aAAa,EACbC,gBAAgB,EAChBC,SAAS,EACTC,uBAAuB,EACvBC,KAAK,EACN,GAAGP;IAEJ,OAAOQ,IAAAA,UAAAA,EAAU;QACf,GAAIP,wBAAwB;YAAEQ,UAAU;QAAoB,CAAC;QAC7D,GAAIP,sBAAsB;YACxBQ,WAAW;YACXC,SAASC,IAAAA,eAAAA,EAAW;gBAAEF,WAAW;gBAAMG,UAAU;YAAM;QACzD,CAAC;QACD,GAAIV,iBAAiB;YACnBO,WAAWP,kBAAkB;YAC7BQ,SAASC,IAAAA,eAAAA,EAAW;gBAAEF,WAAWP,kBAAkB;gBAAOU,UAAU;YAAM;QAC5E,CAAC;QACD,GAAIP,2BAA2B;YAAEQ,SAASC,IAAAA,0BAAAA,EAAoBT,yBAAyBC;QAAO,CAAC;QAC/F,GAAIH,oBAAoB;YAAEY,aAAa;YAAMP,UAAUQ,IAAAA,kBAAAA,EAAYZ,WAAWD;QAAkB,CAAC;IACnG;AACF"}

package/lib-commonjs/usePositioning.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/usePositioning.ts"],"sourcesContent":["import { canUseDOM, useEventCallback, useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport * as React from 'react';\n\nimport { POSITIONING_END_EVENT } from './constants';\nimport { createPositionManager } from './createPositionManager';\nimport type {\n  PositioningOptions,\n  PositioningProps,\n  PositionManager,\n  TargetElement,\n  UsePositioningReturn,\n} from './types';\nimport { usePositioningOptions } from './usePositioningOptions';\nimport { useCallbackRef, hasAutofocusFilter } from './utils';\n\n/**\n * @internal\n */\nexport function usePositioning(options: PositioningProps & PositioningOptions): UsePositioningReturn {\n  'use no memo';\n\n  const managerRef = React.useRef<PositionManager | null>(null);\n  const targetRef = React.useRef<TargetElement | null>(null);\n  const overrideTargetRef = React.useRef<TargetElement | null>(null);\n  const containerRef = React.useRef<HTMLElement | null>(null);\n  const arrowRef = React.useRef<HTMLElement | null>(null);\n\n  const { enabled = true } = options;\n  const resolvePositioningOptions = usePositioningOptions(options);\n  const updatePositionManager = React.useCallback(() => {\n    if (managerRef.current) {\n      managerRef.current.dispose();\n    }\n    managerRef.current = null;\n\n    const target = overrideTargetRef.current ?? targetRef.current;\n\n    if (enabled && canUseDOM() && target && containerRef.current) {\n      managerRef.current = createPositionManager({\n        container: containerRef.current,\n        target,\n        arrow: arrowRef.current,\n        ...resolvePositioningOptions(containerRef.current, arrowRef.current),\n      });\n    }\n  }, [enabled, resolvePositioningOptions]);\n\n  const setOverrideTarget = useEventCallback((target: TargetElement | null) => {\n    overrideTargetRef.current = target;\n    updatePositionManager();\n  });\n\n  React.useImperativeHandle(\n    options.positioningRef,\n    () => ({\n      updatePosition: () => managerRef.current?.updatePosition(),\n      setTarget: (target: TargetElement | null) => {\n        if (options.target && process.env.NODE_ENV !== 'production') {\n          const err = new Error();\n          // eslint-disable-next-line no-console\n          console.warn('Imperative setTarget should not be used at the same time as target option');\n          // eslint-disable-next-line no-console\n          console.warn(err.stack);\n        }\n\n        setOverrideTarget(target);\n      },\n    }),\n    [options.target, setOverrideTarget],\n  );\n\n  useIsomorphicLayoutEffect(() => {\n    setOverrideTarget(options.target ?? null);\n  }, [options.target, setOverrideTarget]);\n\n  useIsomorphicLayoutEffect(() => {\n    updatePositionManager();\n  }, [updatePositionManager]);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // This checked should run only in development mode\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (containerRef.current) {\n        const contentNode = containerRef.current;\n        const treeWalker = contentNode.ownerDocument?.createTreeWalker(contentNode, NodeFilter.SHOW_ELEMENT, {\n          acceptNode: hasAutofocusFilter,\n        });\n\n        while (treeWalker.nextNode()) {\n          const node = treeWalker.currentNode;\n          // eslint-disable-next-line no-console\n          console.warn('usePositioning():', node);\n          // eslint-disable-next-line no-console\n          console.warn(\n            [\n              'usePositioning(): ^ this node contains \"autoFocus\" prop on a React element. This can break the initial',\n              'positioning of an element and cause a window jump effect. This issue occurs because React polyfills',\n              '\"autoFocus\" behavior to solve inconsistencies between different browsers:',\n              'https://github.com/facebook/react/issues/11851#issuecomment-351787078',\n              '\\n',\n              'However, \".focus()\" in this case occurs before any other React effects will be executed',\n              '(React.useEffect(), componentDidMount(), etc.) and we can not prevent this behavior. If you really',\n              'want to use \"autoFocus\" please add \"position: fixed\" to styles of the element that is wrapped by',\n              '\"Popper\".',\n              `In general, it's not recommended to use \"autoFocus\" as it may break accessibility aspects:`,\n              'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/master/docs/rules/no-autofocus.md',\n              '\\n',\n              'We suggest to use the \"trapFocus\" prop on Fluent components or a catch \"ref\" and then use',\n              '\"ref.current.focus\" in React.useEffect():',\n              'https://reactjs.org/docs/refs-and-the-dom.html#adding-a-ref-to-a-dom-element',\n            ].join(' '),\n          );\n        }\n      }\n      // We run this check once, no need to add deps here\n      // TODO: Should be rework to handle options.enabled and contentRef updates\n    }, []);\n  }\n\n  const setTarget = useCallbackRef<TargetElement>(null, target => {\n    if (targetRef.current !== target) {\n      targetRef.current = target;\n      updatePositionManager();\n    }\n  });\n\n  const onPositioningEnd = useEventCallback(() => options.onPositioningEnd?.());\n  const setContainer = useCallbackRef<HTMLElement | null>(null, container => {\n    if (containerRef.current !== container) {\n      containerRef.current?.removeEventListener(POSITIONING_END_EVENT, onPositioningEnd);\n      container?.addEventListener(POSITIONING_END_EVENT, onPositioningEnd);\n      containerRef.current = container;\n      updatePositionManager();\n    }\n  });\n\n  const setArrow = useCallbackRef<HTMLElement | null>(null, arrow => {\n    if (arrowRef.current !== arrow) {\n      arrowRef.current = arrow;\n      updatePositionManager();\n    }\n  });\n\n  // Let users use callback refs so they feel like 'normal' DOM refs\n  return { targetRef: setTarget, containerRef: setContainer, arrowRef: setArrow };\n}\n"],"names":["usePositioning","options","managerRef","React","useRef","targetRef","overrideTargetRef","containerRef","arrowRef","enabled","resolvePositioningOptions","usePositioningOptions","updatePositionManager","useCallback","current","dispose","target","canUseDOM","createPositionManager","container","arrow","setOverrideTarget","useEventCallback","useImperativeHandle","positioningRef","updatePosition","setTarget","process","env","NODE_ENV","err","Error","console","warn","stack","useIsomorphicLayoutEffect","useEffect","contentNode","treeWalker","ownerDocument","createTreeWalker","NodeFilter","SHOW_ELEMENT","acceptNode","hasAutofocusFilter","nextNode","node","currentNode","join","useCallbackRef","onPositioningEnd","setContainer","removeEventListener","POSITIONING_END_EVENT","addEventListener","setArrow"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/usePositioning.ts"],"sourcesContent":["import { canUseDOM, useEventCallback, useIsomorphicLayoutEffect } from '@fluentui/react-utilities';\nimport * as React from 'react';\n\nimport { POSITIONING_END_EVENT } from './constants';\nimport { createPositionManager } from './createPositionManager';\nimport type {\n  PositioningOptions,\n  PositioningProps,\n  PositionManager,\n  TargetElement,\n  UsePositioningReturn,\n} from './types';\nimport { usePositioningOptions } from './usePositioningOptions';\nimport { useCallbackRef, hasAutofocusFilter } from './utils';\n\n/**\n * @internal\n */\nexport function usePositioning(options: PositioningProps & PositioningOptions): UsePositioningReturn {\n  'use no memo';\n\n  const managerRef = React.useRef<PositionManager | null>(null);\n  const targetRef = React.useRef<TargetElement | null>(null);\n  const overrideTargetRef = React.useRef<TargetElement | null>(null);\n  const containerRef = React.useRef<HTMLElement | null>(null);\n  const arrowRef = React.useRef<HTMLElement | null>(null);\n\n  const { enabled = true } = options;\n  const resolvePositioningOptions = usePositioningOptions(options);\n  const updatePositionManager = React.useCallback(() => {\n    if (managerRef.current) {\n      managerRef.current.dispose();\n    }\n    managerRef.current = null;\n\n    const target = overrideTargetRef.current ?? targetRef.current;\n\n    if (enabled && canUseDOM() && target && containerRef.current) {\n      managerRef.current = createPositionManager({\n        container: containerRef.current,\n        target,\n        arrow: arrowRef.current,\n        ...resolvePositioningOptions(containerRef.current, arrowRef.current),\n      });\n    }\n  }, [enabled, resolvePositioningOptions]);\n\n  const setOverrideTarget = useEventCallback((target: TargetElement | null) => {\n    overrideTargetRef.current = target;\n    updatePositionManager();\n  });\n\n  React.useImperativeHandle(\n    options.positioningRef,\n    () => ({\n      updatePosition: () => managerRef.current?.updatePosition(),\n      setTarget: (target: TargetElement | null) => {\n        if (options.target && process.env.NODE_ENV !== 'production') {\n          const err = new Error();\n          // eslint-disable-next-line no-console\n          console.warn('Imperative setTarget should not be used at the same time as target option');\n          // eslint-disable-next-line no-console\n          console.warn(err.stack);\n        }\n\n        setOverrideTarget(target);\n      },\n    }),\n    [options.target, setOverrideTarget],\n  );\n\n  useIsomorphicLayoutEffect(() => {\n    setOverrideTarget(options.target ?? null);\n  }, [options.target, setOverrideTarget]);\n\n  useIsomorphicLayoutEffect(() => {\n    updatePositionManager();\n  }, [updatePositionManager]);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // This checked should run only in development mode\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(() => {\n      if (containerRef.current) {\n        const contentNode = containerRef.current;\n        const treeWalker = contentNode.ownerDocument?.createTreeWalker(contentNode, NodeFilter.SHOW_ELEMENT, {\n          acceptNode: hasAutofocusFilter,\n        });\n\n        while (treeWalker.nextNode()) {\n          const node = treeWalker.currentNode;\n          // eslint-disable-next-line no-console\n          console.warn('usePositioning():', node);\n          // eslint-disable-next-line no-console\n          console.warn(\n            [\n              'usePositioning(): ^ this node contains \"autoFocus\" prop on a React element. This can break the initial',\n              'positioning of an element and cause a window jump effect. This issue occurs because React polyfills',\n              '\"autoFocus\" behavior to solve inconsistencies between different browsers:',\n              'https://github.com/facebook/react/issues/11851#issuecomment-351787078',\n              '\\n',\n              'However, \".focus()\" in this case occurs before any other React effects will be executed',\n              '(React.useEffect(), componentDidMount(), etc.) and we can not prevent this behavior. If you really',\n              'want to use \"autoFocus\" please add \"position: fixed\" to styles of the element that is wrapped by',\n              '\"Popper\".',\n              `In general, it's not recommended to use \"autoFocus\" as it may break accessibility aspects:`,\n              'https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/master/docs/rules/no-autofocus.md',\n              '\\n',\n              'We suggest to use the \"trapFocus\" prop on Fluent components or a catch \"ref\" and then use',\n              '\"ref.current.focus\" in React.useEffect():',\n              'https://reactjs.org/docs/refs-and-the-dom.html#adding-a-ref-to-a-dom-element',\n            ].join(' '),\n          );\n        }\n      }\n      // We run this check once, no need to add deps here\n      // TODO: Should be rework to handle options.enabled and contentRef updates\n    }, []);\n  }\n\n  const setTarget = useCallbackRef<TargetElement>(null, target => {\n    if (targetRef.current !== target) {\n      targetRef.current = target;\n      updatePositionManager();\n    }\n  });\n\n  const onPositioningEnd = useEventCallback(() => options.onPositioningEnd?.());\n  const setContainer = useCallbackRef<HTMLElement | null>(null, container => {\n    if (containerRef.current !== container) {\n      containerRef.current?.removeEventListener(POSITIONING_END_EVENT, onPositioningEnd);\n      container?.addEventListener(POSITIONING_END_EVENT, onPositioningEnd);\n      containerRef.current = container;\n      updatePositionManager();\n    }\n  });\n\n  const setArrow = useCallbackRef<HTMLElement | null>(null, arrow => {\n    if (arrowRef.current !== arrow) {\n      arrowRef.current = arrow;\n      updatePositionManager();\n    }\n  });\n\n  // Let users use callback refs so they feel like 'normal' DOM refs\n  return { targetRef: setTarget, containerRef: setContainer, arrowRef: setArrow };\n}\n"],"names":["usePositioning","options","managerRef","React","useRef","targetRef","overrideTargetRef","containerRef","arrowRef","enabled","resolvePositioningOptions","usePositioningOptions","updatePositionManager","useCallback","current","dispose","target","canUseDOM","createPositionManager","container","arrow","setOverrideTarget","useEventCallback","useImperativeHandle","positioningRef","updatePosition","setTarget","process","env","NODE_ENV","err","Error","console","warn","stack","useIsomorphicLayoutEffect","useEffect","contentNode","treeWalker","ownerDocument","createTreeWalker","NodeFilter","SHOW_ELEMENT","acceptNode","hasAutofocusFilter","nextNode","node","currentNode","join","useCallbackRef","onPositioningEnd","setContainer","removeEventListener","POSITIONING_END_EVENT","addEventListener","setArrow"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/usePositioningMouseTarget.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/usePositioningMouseTarget.ts"],"sourcesContent":["import * as React from 'react';\nimport { createVirtualElementFromClick } from './createVirtualElementFromClick';\nimport { PositioningVirtualElement, SetVirtualMouseTarget } from './types';\n\n/**\n * @internal\n * A state hook that manages a popper virtual element from mouseevents.\n * Useful for scenarios where a component needs to be positioned by mouse click (e.g. contextmenu)\n * React synthetic events are not persisted by this hook\n *\n * @param initialState - initializes a user provided state similare to useState\n * @returns state and dispatcher for a Popper virtual element that uses native/synthetic mouse events\n */\nexport const usePositioningMouseTarget = (\n  initialState?: PositioningVirtualElement | (() => PositioningVirtualElement),\n) => {\n  const [virtualElement, setVirtualElement] = React.useState<PositioningVirtualElement | undefined>(initialState);\n\n  const setVirtualMouseTarget: SetVirtualMouseTarget = event => {\n    if (event === undefined || event === null) {\n      setVirtualElement(undefined);\n      return;\n    }\n\n    let mouseevent: MouseEvent;\n    if (!(event instanceof MouseEvent)) {\n      mouseevent = event.nativeEvent;\n    } else {\n      mouseevent = event;\n    }\n\n    if (!(mouseevent instanceof MouseEvent) && process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line no-console\n      console.error('usePositioningMouseTarget should only be used with MouseEvent');\n    }\n\n    const contextTarget = createVirtualElementFromClick(mouseevent);\n    setVirtualElement(contextTarget);\n  };\n\n  return [virtualElement, setVirtualMouseTarget] as const;\n};\n"],"names":["usePositioningMouseTarget","initialState","virtualElement","setVirtualElement","React","useState","setVirtualMouseTarget","event","undefined","mouseevent","MouseEvent","nativeEvent","process","env","NODE_ENV","console","error","contextTarget","createVirtualElementFromClick"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaaA;;;eAAAA;;;;iEAbU;+CACuB;AAYvC,MAAMA,4BAA4B,CACvCC;IAEA,MAAM,CAACC,gBAAgBC,kBAAkB,GAAGC,OAAMC,QAAQ,CAAwCJ;IAElG,MAAMK,wBAA+CC,CAAAA;QACnD,IAAIA,UAAUC,aAAaD,UAAU,MAAM;YACzCJ,kBAAkBK;YAClB;QACF;QAEA,IAAIC;QACJ,IAAI,CAAEF,CAAAA,iBAAiBG,UAAS,GAAI;YAClCD,aAAaF,MAAMI,WAAW;QAChC,OAAO;YACLF,aAAaF;QACf;QAEA,IAAI,CAAEE,CAAAA,sBAAsBC,UAAS,KAAME,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YAChF,sCAAsC;YACtCC,QAAQC,KAAK,CAAC;QAChB;QAEA,MAAMC,gBAAgBC,IAAAA,4DAA6B,EAACT;QACpDN,kBAAkBc;IACpB;IAEA,OAAO;QAACf;QAAgBI;KAAsB;AAChD"}
+{"version":3,"sources":["../src/usePositioningMouseTarget.ts"],"sourcesContent":["import * as React from 'react';\nimport { createVirtualElementFromClick } from './createVirtualElementFromClick';\nimport { PositioningVirtualElement, SetVirtualMouseTarget } from './types';\n\n/**\n * @internal\n * A state hook that manages a popper virtual element from mouseevents.\n * Useful for scenarios where a component needs to be positioned by mouse click (e.g. contextmenu)\n * React synthetic events are not persisted by this hook\n *\n * @param initialState - initializes a user provided state similare to useState\n * @returns state and dispatcher for a Popper virtual element that uses native/synthetic mouse events\n */\nexport const usePositioningMouseTarget = (\n  initialState?: PositioningVirtualElement | (() => PositioningVirtualElement),\n) => {\n  const [virtualElement, setVirtualElement] = React.useState<PositioningVirtualElement | undefined>(initialState);\n\n  const setVirtualMouseTarget: SetVirtualMouseTarget = event => {\n    if (event === undefined || event === null) {\n      setVirtualElement(undefined);\n      return;\n    }\n\n    let mouseevent: MouseEvent;\n    if (!(event instanceof MouseEvent)) {\n      mouseevent = event.nativeEvent;\n    } else {\n      mouseevent = event;\n    }\n\n    if (!(mouseevent instanceof MouseEvent) && process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line no-console\n      console.error('usePositioningMouseTarget should only be used with MouseEvent');\n    }\n\n    const contextTarget = createVirtualElementFromClick(mouseevent);\n    setVirtualElement(contextTarget);\n  };\n\n  return [virtualElement, setVirtualMouseTarget] as const;\n};\n"],"names":["usePositioningMouseTarget","initialState","virtualElement","setVirtualElement","React","useState","setVirtualMouseTarget","event","undefined","mouseevent","MouseEvent","nativeEvent","process","env","NODE_ENV","console","error","contextTarget","createVirtualElementFromClick"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaaA;;;eAAAA;;;;iEAbU;+CACuB;AAYvC,MAAMA,4BAA4B,CACvCC;IAEA,MAAM,CAACC,gBAAgBC,kBAAkB,GAAGC,OAAMC,QAAQ,CAAwCJ;IAElG,MAAMK,wBAA+CC,CAAAA;QACnD,IAAIA,UAAUC,aAAaD,UAAU,MAAM;YACzCJ,kBAAkBK;YAClB;QACF;QAEA,IAAIC;QACJ,IAAI,CAAEF,CAAAA,iBAAiBG,UAAAA,GAAa;YAClCD,aAAaF,MAAMI,WAAW;QAChC,OAAO;YACLF,aAAaF;QACf;QAEA,IAAI,CAAEE,CAAAA,sBAAsBC,UAAAA,KAAeE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YAChF,sCAAsC;YACtCC,QAAQC,KAAK,CAAC;QAChB;QAEA,MAAMC,gBAAgBC,IAAAA,4DAAAA,EAA8BT;QACpDN,kBAAkBc;IACpB;IAEA,OAAO;QAACf;QAAgBI;KAAsB;AAChD"}

package/lib-commonjs/usePositioningOptions.js

@@ -23,8 +23,7 @@ const _PositioningConfigurationContext = require("./PositioningConfigurationCont
  * This is redundant and exists only to manage React dependencies properly & avoid leaking individual options to the
  * scope of `usePositioningOptions`.
  */ function usePositioningConfigFn(configFn, options) {
-    const { align, arrowPadding, autoSize, coverTarget, disableUpdateOnResize, flipBoundary, offset, overflowBoundary, pinned, position, // eslint-disable-next-line @typescript-eslint/naming-convention
-    unstable_disableTether, strategy, overflowBoundaryPadding, fallbackPositions, useTransform, matchTargetSize, shiftToCoverTarget } = options;
+    const { align, arrowPadding, autoSize, coverTarget, disableUpdateOnResize, flipBoundary, offset, overflowBoundary, pinned, position, unstable_disableTether, strategy, overflowBoundaryPadding, fallbackPositions, useTransform, matchTargetSize, shiftToCoverTarget } = options;
     return _react.useCallback((container, arrow)=>{
         return configFn({
             container,
@@ -75,13 +74,11 @@ function usePositioningOptions(options) {
     const { dir, targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
     const isRtl = dir === 'rtl';
     const configFn = usePositioningConfigFn((0, _PositioningConfigurationContext.usePositioningConfiguration)(), options);
-    const { // eslint-disable-next-line @typescript-eslint/no-deprecated
-    positionFixed } = options;
+    const { positionFixed } = options;
     return _react.useCallback((container, arrow)=>{
         const hasScrollableElement = (0, _utils.hasScrollParent)(container);
         const optionsAfterEnhancement = configFn(container, arrow);
-        const { autoSize, disableUpdateOnResize, matchTargetSize, offset, coverTarget, flipBoundary, overflowBoundary, useTransform, overflowBoundaryPadding, pinned, position, arrowPadding, strategy, align, fallbackPositions, shiftToCoverTarget, // eslint-disable-next-line @typescript-eslint/naming-convention
-        unstable_disableTether } = optionsAfterEnhancement;
+        const { autoSize, disableUpdateOnResize, matchTargetSize, offset, coverTarget, flipBoundary, overflowBoundary, useTransform, overflowBoundaryPadding, pinned, position, arrowPadding, strategy, align, fallbackPositions, shiftToCoverTarget, unstable_disableTether } = optionsAfterEnhancement;
         const normalizedAutoSize = (0, _utils.normalizeAutoSize)(autoSize);
         const middleware = [
             normalizedAutoSize && (0, _middleware.resetMaxSize)(normalizedAutoSize),

package/lib-commonjs/usePositioningOptions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/usePositioningOptions.ts"],"sourcesContent":["import { devtools } from '@floating-ui/devtools';\nimport { hide as hideMiddleware, arrow as arrowMiddleware } from '@floating-ui/dom';\nimport type { Middleware } from '@floating-ui/dom';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nimport * as React from 'react';\n\nimport {\n  shift as shiftMiddleware,\n  flip as flipMiddleware,\n  coverTarget as coverTargetMiddleware,\n  maxSize as maxSizeMiddleware,\n  resetMaxSize as resetMaxSizeMiddleware,\n  offset as offsetMiddleware,\n  intersecting as intersectingMiddleware,\n  matchTargetSize as matchTargetSizeMiddleware,\n} from './middleware';\nimport type { PositioningConfigurationFn, PositioningConfigurationFnOptions, PositioningOptions } from './types';\nimport { toFloatingUIPlacement, hasScrollParent, normalizeAutoSize } from './utils';\nimport { devtoolsCallback } from './utils/devtools';\nimport { usePositioningConfiguration } from './PositioningConfigurationContext';\n\n/**\n * @internal\n *\n * This is redundant and exists only to manage React dependencies properly & avoid leaking individual options to the\n * scope of `usePositioningOptions`.\n */\nfunction usePositioningConfigFn(\n  configFn: PositioningConfigurationFn,\n  options: PositioningOptions,\n): (container: HTMLElement, arrow: HTMLElement | null) => PositioningConfigurationFnOptions {\n  const {\n    align,\n    arrowPadding,\n    autoSize,\n    coverTarget,\n    disableUpdateOnResize,\n    flipBoundary,\n    offset,\n    overflowBoundary,\n    pinned,\n    position,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    unstable_disableTether,\n    strategy,\n    overflowBoundaryPadding,\n    fallbackPositions,\n    useTransform,\n    matchTargetSize,\n    shiftToCoverTarget,\n  } = options;\n\n  return React.useCallback(\n    (container: HTMLElement, arrow: HTMLElement | null) => {\n      return configFn({\n        container,\n        arrow,\n        options: {\n          autoSize,\n          disableUpdateOnResize,\n          matchTargetSize,\n          offset,\n          strategy,\n          coverTarget,\n          flipBoundary,\n          overflowBoundary,\n          useTransform,\n          overflowBoundaryPadding,\n          pinned,\n          arrowPadding,\n          align,\n          fallbackPositions,\n          shiftToCoverTarget,\n          position,\n          // eslint-disable-next-line @typescript-eslint/naming-convention\n          unstable_disableTether,\n        },\n      });\n    },\n    [\n      autoSize,\n      disableUpdateOnResize,\n      matchTargetSize,\n      offset,\n      strategy,\n      coverTarget,\n      flipBoundary,\n      overflowBoundary,\n      useTransform,\n      overflowBoundaryPadding,\n      pinned,\n      arrowPadding,\n      align,\n      fallbackPositions,\n      shiftToCoverTarget,\n      position,\n      unstable_disableTether,\n      configFn,\n    ],\n  );\n}\n\n/**\n * @internal\n */\nexport function usePositioningOptions(options: PositioningOptions) {\n  const { dir, targetDocument } = useFluent();\n  const isRtl = dir === 'rtl';\n\n  const configFn = usePositioningConfigFn(usePositioningConfiguration(), options);\n  const {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    positionFixed,\n  } = options;\n\n  return React.useCallback(\n    (container: HTMLElement, arrow: HTMLElement | null) => {\n      const hasScrollableElement = hasScrollParent(container);\n\n      const optionsAfterEnhancement = configFn(container, arrow);\n      const {\n        autoSize,\n        disableUpdateOnResize,\n        matchTargetSize,\n        offset,\n        coverTarget,\n        flipBoundary,\n        overflowBoundary,\n        useTransform,\n        overflowBoundaryPadding,\n        pinned,\n        position,\n        arrowPadding,\n        strategy,\n        align,\n        fallbackPositions,\n        shiftToCoverTarget,\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        unstable_disableTether,\n      } = optionsAfterEnhancement;\n      const normalizedAutoSize = normalizeAutoSize(autoSize);\n\n      const middleware = [\n        normalizedAutoSize && resetMaxSizeMiddleware(normalizedAutoSize),\n        matchTargetSize && matchTargetSizeMiddleware(),\n        offset && offsetMiddleware(offset),\n        coverTarget && coverTargetMiddleware(),\n        !pinned && flipMiddleware({ container, flipBoundary, hasScrollableElement, isRtl, fallbackPositions }),\n        shiftMiddleware({\n          container,\n          hasScrollableElement,\n          overflowBoundary,\n          disableTether: unstable_disableTether,\n          overflowBoundaryPadding,\n          isRtl,\n          shiftToCoverTarget,\n        }),\n        normalizedAutoSize &&\n          maxSizeMiddleware(normalizedAutoSize, { container, overflowBoundary, overflowBoundaryPadding, isRtl }),\n        intersectingMiddleware(),\n        arrow && arrowMiddleware({ element: arrow, padding: arrowPadding }),\n        hideMiddleware({ strategy: 'referenceHidden' }),\n        hideMiddleware({ strategy: 'escaped' }),\n        process.env.NODE_ENV !== 'production' &&\n          targetDocument &&\n          devtools(targetDocument, devtoolsCallback(optionsAfterEnhancement)),\n      ].filter(Boolean) as Middleware[];\n\n      const placement = toFloatingUIPlacement(align, position, isRtl);\n\n      return {\n        placement,\n        middleware,\n        strategy: strategy ?? positionFixed ? ('fixed' as const) : ('absolute' as const),\n\n        disableUpdateOnResize,\n        useTransform,\n      };\n    },\n    [configFn, isRtl, targetDocument, positionFixed],\n  );\n}\n"],"names":["usePositioningOptions","usePositioningConfigFn","configFn","options","align","arrowPadding","autoSize","coverTarget","disableUpdateOnResize","flipBoundary","offset","overflowBoundary","pinned","position","unstable_disableTether","strategy","overflowBoundaryPadding","fallbackPositions","useTransform","matchTargetSize","shiftToCoverTarget","React","useCallback","container","arrow","dir","targetDocument","useFluent","isRtl","usePositioningConfiguration","positionFixed","hasScrollableElement","hasScrollParent","optionsAfterEnhancement","normalizedAutoSize","normalizeAutoSize","middleware","resetMaxSizeMiddleware","matchTargetSizeMiddleware","offsetMiddleware","coverTargetMiddleware","flipMiddleware","shiftMiddleware","disableTether","maxSizeMiddleware","intersectingMiddleware","arrowMiddleware","element","padding","hideMiddleware","process","env","NODE_ENV","devtools","devtoolsCallback","filter","Boolean","placement","toFloatingUIPlacement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../src/usePositioningOptions.ts"],"sourcesContent":["import { devtools } from '@floating-ui/devtools';\nimport { hide as hideMiddleware, arrow as arrowMiddleware } from '@floating-ui/dom';\nimport type { Middleware } from '@floating-ui/dom';\nimport { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';\nimport * as React from 'react';\n\nimport {\n  shift as shiftMiddleware,\n  flip as flipMiddleware,\n  coverTarget as coverTargetMiddleware,\n  maxSize as maxSizeMiddleware,\n  resetMaxSize as resetMaxSizeMiddleware,\n  offset as offsetMiddleware,\n  intersecting as intersectingMiddleware,\n  matchTargetSize as matchTargetSizeMiddleware,\n} from './middleware';\nimport type { PositioningConfigurationFn, PositioningConfigurationFnOptions, PositioningOptions } from './types';\nimport { toFloatingUIPlacement, hasScrollParent, normalizeAutoSize } from './utils';\nimport { devtoolsCallback } from './utils/devtools';\nimport { usePositioningConfiguration } from './PositioningConfigurationContext';\n\n/**\n * @internal\n *\n * This is redundant and exists only to manage React dependencies properly & avoid leaking individual options to the\n * scope of `usePositioningOptions`.\n */\nfunction usePositioningConfigFn(\n  configFn: PositioningConfigurationFn,\n  options: PositioningOptions,\n): (container: HTMLElement, arrow: HTMLElement | null) => PositioningConfigurationFnOptions {\n  const {\n    align,\n    arrowPadding,\n    autoSize,\n    coverTarget,\n    disableUpdateOnResize,\n    flipBoundary,\n    offset,\n    overflowBoundary,\n    pinned,\n    position,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    unstable_disableTether,\n    strategy,\n    overflowBoundaryPadding,\n    fallbackPositions,\n    useTransform,\n    matchTargetSize,\n    shiftToCoverTarget,\n  } = options;\n\n  return React.useCallback(\n    (container: HTMLElement, arrow: HTMLElement | null) => {\n      return configFn({\n        container,\n        arrow,\n        options: {\n          autoSize,\n          disableUpdateOnResize,\n          matchTargetSize,\n          offset,\n          strategy,\n          coverTarget,\n          flipBoundary,\n          overflowBoundary,\n          useTransform,\n          overflowBoundaryPadding,\n          pinned,\n          arrowPadding,\n          align,\n          fallbackPositions,\n          shiftToCoverTarget,\n          position,\n          // eslint-disable-next-line @typescript-eslint/naming-convention\n          unstable_disableTether,\n        },\n      });\n    },\n    [\n      autoSize,\n      disableUpdateOnResize,\n      matchTargetSize,\n      offset,\n      strategy,\n      coverTarget,\n      flipBoundary,\n      overflowBoundary,\n      useTransform,\n      overflowBoundaryPadding,\n      pinned,\n      arrowPadding,\n      align,\n      fallbackPositions,\n      shiftToCoverTarget,\n      position,\n      unstable_disableTether,\n      configFn,\n    ],\n  );\n}\n\n/**\n * @internal\n */\nexport function usePositioningOptions(options: PositioningOptions) {\n  const { dir, targetDocument } = useFluent();\n  const isRtl = dir === 'rtl';\n\n  const configFn = usePositioningConfigFn(usePositioningConfiguration(), options);\n  const {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    positionFixed,\n  } = options;\n\n  return React.useCallback(\n    (container: HTMLElement, arrow: HTMLElement | null) => {\n      const hasScrollableElement = hasScrollParent(container);\n\n      const optionsAfterEnhancement = configFn(container, arrow);\n      const {\n        autoSize,\n        disableUpdateOnResize,\n        matchTargetSize,\n        offset,\n        coverTarget,\n        flipBoundary,\n        overflowBoundary,\n        useTransform,\n        overflowBoundaryPadding,\n        pinned,\n        position,\n        arrowPadding,\n        strategy,\n        align,\n        fallbackPositions,\n        shiftToCoverTarget,\n        // eslint-disable-next-line @typescript-eslint/naming-convention\n        unstable_disableTether,\n      } = optionsAfterEnhancement;\n      const normalizedAutoSize = normalizeAutoSize(autoSize);\n\n      const middleware = [\n        normalizedAutoSize && resetMaxSizeMiddleware(normalizedAutoSize),\n        matchTargetSize && matchTargetSizeMiddleware(),\n        offset && offsetMiddleware(offset),\n        coverTarget && coverTargetMiddleware(),\n        !pinned && flipMiddleware({ container, flipBoundary, hasScrollableElement, isRtl, fallbackPositions }),\n        shiftMiddleware({\n          container,\n          hasScrollableElement,\n          overflowBoundary,\n          disableTether: unstable_disableTether,\n          overflowBoundaryPadding,\n          isRtl,\n          shiftToCoverTarget,\n        }),\n        normalizedAutoSize &&\n          maxSizeMiddleware(normalizedAutoSize, { container, overflowBoundary, overflowBoundaryPadding, isRtl }),\n        intersectingMiddleware(),\n        arrow && arrowMiddleware({ element: arrow, padding: arrowPadding }),\n        hideMiddleware({ strategy: 'referenceHidden' }),\n        hideMiddleware({ strategy: 'escaped' }),\n        process.env.NODE_ENV !== 'production' &&\n          targetDocument &&\n          devtools(targetDocument, devtoolsCallback(optionsAfterEnhancement)),\n      ].filter(Boolean) as Middleware[];\n\n      const placement = toFloatingUIPlacement(align, position, isRtl);\n\n      return {\n        placement,\n        middleware,\n        strategy: strategy ?? positionFixed ? ('fixed' as const) : ('absolute' as const),\n\n        disableUpdateOnResize,\n        useTransform,\n      };\n    },\n    [configFn, isRtl, targetDocument, positionFixed],\n  );\n}\n"],"names":["usePositioningOptions","usePositioningConfigFn","configFn","options","align","arrowPadding","autoSize","coverTarget","disableUpdateOnResize","flipBoundary","offset","overflowBoundary","pinned","position","unstable_disableTether","strategy","overflowBoundaryPadding","fallbackPositions","useTransform","matchTargetSize","shiftToCoverTarget","React","useCallback","container","arrow","dir","targetDocument","useFluent","isRtl","usePositioningConfiguration","positionFixed","hasScrollableElement","hasScrollParent","optionsAfterEnhancement","normalizedAutoSize","normalizeAutoSize","middleware","resetMaxSizeMiddleware","matchTargetSizeMiddleware","offsetMiddleware","coverTargetMiddleware","flipMiddleware","shiftMiddleware","disableTether","maxSizeMiddleware","intersectingMiddleware","arrowMiddleware","element","padding","hideMiddleware","process","env","NODE_ENV","devtools","devtoolsCallback","filter","Boolean","placement","toFloatingUIPlacement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/useSafeZoneArea.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useSafeZoneArea", {
+    enumerable: true,
+    get: function() {
+        return useSafeZoneArea;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _reactutilities = require("@fluentui/react-utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _SafeZoneArea = require("./SafeZoneArea");
+const _utils = require("./utils");
+function useSafeZoneArea({ debug = false, disabled = false, onSafeZoneEnter, onSafeZoneMove, onSafeZoneLeave, onSafeZoneTimeout, timeout = 1500 } = {}) {
+    const [stateStore] = _react.useState(_SafeZoneArea.createSafeZoneAreaStateStore);
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const safeZoneAreaRef = _react.useRef(null);
+    const containerRef = _react.useRef(null);
+    const targetRef = _react.useRef(null);
+    const timeoutIdRef = _react.useRef(null);
+    const mouseMoveIdRef = _react.useRef(null);
+    const containerListenerRef = _react.useMemo(()=>{
+        if (disabled) {
+            return ()=>{
+            // do nothing
+            };
+        }
+        let containerEl = null;
+        function onContainerMouseEnter() {
+            const targetWindow = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+            if (!targetWindow) {
+                return;
+            }
+            if (timeoutIdRef.current) {
+                targetWindow.clearTimeout(timeoutIdRef.current);
+                timeoutIdRef.current = null;
+            }
+            stateStore.toggleActive(false);
+        }
+        return (el)=>{
+            if (el === null) {
+                containerEl === null || containerEl === void 0 ? void 0 : containerEl.removeEventListener('mouseenter', onContainerMouseEnter);
+            }
+            containerEl = el;
+            el === null || el === void 0 ? void 0 : el.addEventListener('mouseenter', onContainerMouseEnter);
+        };
+    }, [
+        disabled,
+        stateStore,
+        targetDocument
+    ]);
+    const targetListenerRef = _react.useMemo(()=>{
+        if (disabled) {
+            return ()=>{
+            // do nothing
+            };
+        }
+        let targetEl = null;
+        function onTargetMouseMove(e) {
+            const targetWindow = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+            if (!targetWindow) {
+                return;
+            }
+            if (timeoutIdRef.current) {
+                targetWindow.clearTimeout(timeoutIdRef.current);
+                timeoutIdRef.current = null;
+            }
+            if (!stateStore.isActive()) {
+                stateStore.toggleActive(true);
+            }
+            mouseMoveIdRef.current = targetWindow.requestAnimationFrame(()=>{
+                var _safeZoneAreaRef_current;
+                const containerEl = containerRef.current;
+                if (!containerEl || !targetEl) {
+                    return;
+                }
+                (_safeZoneAreaRef_current = safeZoneAreaRef.current) === null || _safeZoneAreaRef_current === void 0 ? void 0 : _safeZoneAreaRef_current.updateSVG({
+                    containerPlacementSide: (0, _utils.parseFloatingUIPlacement)(containerEl.dataset.popperPlacement).side,
+                    containerRect: containerEl.getBoundingClientRect(),
+                    mouseCoordinates: {
+                        x: e.clientX,
+                        y: e.clientY
+                    },
+                    targetRect: targetEl.getBoundingClientRect()
+                });
+            });
+        }
+        return (el)=>{
+            if (el === null) {
+                const targetWindow = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+                if (targetWindow) {
+                    if (mouseMoveIdRef.current) {
+                        targetWindow.cancelAnimationFrame(mouseMoveIdRef.current);
+                        mouseMoveIdRef.current = null;
+                    }
+                    if (timeoutIdRef.current) {
+                        targetWindow.clearTimeout(timeoutIdRef.current);
+                        timeoutIdRef.current = null;
+                    }
+                }
+                targetEl === null || targetEl === void 0 ? void 0 : targetEl.removeEventListener('mousemove', onTargetMouseMove);
+            }
+            targetEl = el;
+            el === null || el === void 0 ? void 0 : el.addEventListener('mousemove', onTargetMouseMove);
+        };
+    }, [
+        disabled,
+        stateStore,
+        targetDocument
+    ]);
+    const onSvgMouseEnter = (0, _reactutilities.useEventCallback)((e)=>{
+        onSafeZoneEnter === null || onSafeZoneEnter === void 0 ? void 0 : onSafeZoneEnter(e);
+        const targetWindow = targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.defaultView;
+        if (!targetWindow) {
+            return;
+        }
+        if (timeoutIdRef.current) {
+            targetWindow.clearTimeout(timeoutIdRef.current);
+            timeoutIdRef.current = null;
+        }
+        // React 17 still uses pooled synthetic events
+        e.persist();
+        timeoutIdRef.current = targetWindow.setTimeout(()=>{
+            stateStore.toggleActive(false);
+            onSafeZoneTimeout === null || onSafeZoneTimeout === void 0 ? void 0 : onSafeZoneTimeout();
+        }, timeout);
+    });
+    const onSvgMouseMove = (0, _reactutilities.useEventCallback)((e)=>{
+        onSafeZoneMove === null || onSafeZoneMove === void 0 ? void 0 : onSafeZoneMove(e);
+    });
+    const onSvgMouseLeave = (0, _reactutilities.useEventCallback)((e)=>{
+        onSafeZoneLeave === null || onSafeZoneLeave === void 0 ? void 0 : onSafeZoneLeave(e);
+    });
+    return {
+        containerRef: (0, _reactutilities.useMergedRefs)(containerRef, containerListenerRef),
+        targetRef: (0, _reactutilities.useMergedRefs)(targetRef, targetListenerRef),
+        elementToRender: _react.useMemo(()=>disabled ? null : /*#__PURE__*/ _react.createElement(_SafeZoneArea.SafeZoneArea, {
+                debug: debug,
+                onMouseEnter: onSvgMouseEnter,
+                onMouseMove: onSvgMouseMove,
+                onMouseLeave: onSvgMouseLeave,
+                imperativeRef: safeZoneAreaRef,
+                stateStore: stateStore
+            }), [
+            disabled,
+            debug,
+            onSvgMouseEnter,
+            onSvgMouseMove,
+            onSvgMouseLeave,
+            stateStore
+        ])
+    };
+}

package/lib-commonjs/useSafeZoneArea.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/useSafeZoneArea.tsx"],"sourcesContent":["import { useFluent_unstable } from '@fluentui/react-shared-contexts';\nimport { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport type { Placement } from '@floating-ui/dom';\nimport * as React from 'react';\n\nimport { createSafeZoneAreaStateStore, type SafeZoneAreaImperativeHandle, SafeZoneArea } from './SafeZoneArea';\nimport { parseFloatingUIPlacement } from './utils';\n\nexport type SafeBufferAreaOptions = {\n  /** Enables debug mode: makes drawn shapes visible. */\n  debug?: boolean;\n\n  /** Disables the safe zone area. */\n  disabled?: boolean;\n\n  /** The time in milliseconds to wait before clearing the safe zone. */\n  timeout?: number;\n\n  /** Called when the mouse enters the safe zone. */\n  onSafeZoneEnter?: (e: React.MouseEvent) => void;\n\n  /** Called when the mouse moves within the safe zone. */\n  onSafeZoneMove?: (e: React.MouseEvent) => void;\n\n  /** Called when the mouse leaves the safe zone. */\n  onSafeZoneLeave?: (e: React.MouseEvent) => void;\n\n  /** Called when the safe zone times out, even if a cursor is still over a safe zone. */\n  onSafeZoneTimeout?: () => void;\n};\n\nexport function useSafeZoneArea({\n  debug = false,\n  disabled = false,\n\n  onSafeZoneEnter,\n  onSafeZoneMove,\n  onSafeZoneLeave,\n  onSafeZoneTimeout,\n\n  timeout = 1500,\n}: SafeBufferAreaOptions = {}) {\n  const [stateStore] = React.useState(createSafeZoneAreaStateStore);\n  const { targetDocument } = useFluent_unstable();\n\n  const safeZoneAreaRef = React.useRef<SafeZoneAreaImperativeHandle>(null);\n  const containerRef = React.useRef<HTMLElement>(null);\n  const targetRef = React.useRef<HTMLElement>(null);\n\n  const timeoutIdRef = React.useRef<number | null>(null);\n  const mouseMoveIdRef = React.useRef<number | null>(null);\n\n  const containerListenerRef = React.useMemo(() => {\n    if (disabled) {\n      return () => {\n        // do nothing\n      };\n    }\n\n    let containerEl: HTMLElement | null = null;\n\n    function onContainerMouseEnter() {\n      const targetWindow = targetDocument?.defaultView;\n\n      if (!targetWindow) {\n        return;\n      }\n\n      if (timeoutIdRef.current) {\n        targetWindow.clearTimeout(timeoutIdRef.current);\n        timeoutIdRef.current = null;\n      }\n\n      stateStore.toggleActive(false);\n    }\n\n    return (el: HTMLElement | null) => {\n      if (el === null) {\n        containerEl?.removeEventListener('mouseenter', onContainerMouseEnter);\n      }\n\n      containerEl = el;\n      el?.addEventListener('mouseenter', onContainerMouseEnter);\n    };\n  }, [disabled, stateStore, targetDocument]);\n\n  const targetListenerRef = React.useMemo(() => {\n    if (disabled) {\n      return () => {\n        // do nothing\n      };\n    }\n\n    let targetEl: HTMLElement | null = null;\n\n    function onTargetMouseMove(e: MouseEvent) {\n      const targetWindow = targetDocument?.defaultView;\n\n      if (!targetWindow) {\n        return;\n      }\n\n      if (timeoutIdRef.current) {\n        targetWindow.clearTimeout(timeoutIdRef.current);\n        timeoutIdRef.current = null;\n      }\n\n      if (!stateStore.isActive()) {\n        stateStore.toggleActive(true);\n      }\n\n      mouseMoveIdRef.current = targetWindow.requestAnimationFrame(() => {\n        const containerEl = containerRef.current;\n\n        if (!containerEl || !targetEl) {\n          return;\n        }\n\n        safeZoneAreaRef.current?.updateSVG({\n          containerPlacementSide: parseFloatingUIPlacement(containerEl.dataset.popperPlacement as Placement).side,\n          containerRect: containerEl.getBoundingClientRect(),\n          mouseCoordinates: { x: e.clientX, y: e.clientY },\n          targetRect: targetEl.getBoundingClientRect(),\n        });\n      });\n    }\n\n    return (el: HTMLElement | null) => {\n      if (el === null) {\n        const targetWindow = targetDocument?.defaultView;\n\n        if (targetWindow) {\n          if (mouseMoveIdRef.current) {\n            targetWindow.cancelAnimationFrame(mouseMoveIdRef.current);\n            mouseMoveIdRef.current = null;\n          }\n\n          if (timeoutIdRef.current) {\n            targetWindow.clearTimeout(timeoutIdRef.current);\n            timeoutIdRef.current = null;\n          }\n        }\n\n        targetEl?.removeEventListener('mousemove', onTargetMouseMove);\n      }\n\n      targetEl = el;\n      el?.addEventListener('mousemove', onTargetMouseMove);\n    };\n  }, [disabled, stateStore, targetDocument]);\n\n  const onSvgMouseEnter = useEventCallback((e: React.MouseEvent) => {\n    onSafeZoneEnter?.(e);\n\n    const targetWindow = targetDocument?.defaultView;\n\n    if (!targetWindow) {\n      return;\n    }\n\n    if (timeoutIdRef.current) {\n      targetWindow.clearTimeout(timeoutIdRef.current);\n      timeoutIdRef.current = null;\n    }\n\n    // React 17 still uses pooled synthetic events\n    e.persist();\n\n    timeoutIdRef.current = targetWindow.setTimeout(() => {\n      stateStore.toggleActive(false);\n      onSafeZoneTimeout?.();\n    }, timeout);\n  });\n\n  const onSvgMouseMove = useEventCallback((e: React.MouseEvent) => {\n    onSafeZoneMove?.(e);\n  });\n\n  const onSvgMouseLeave = useEventCallback((e: React.MouseEvent) => {\n    onSafeZoneLeave?.(e);\n  });\n\n  return {\n    containerRef: useMergedRefs(containerRef, containerListenerRef),\n    targetRef: useMergedRefs(targetRef, targetListenerRef),\n\n    elementToRender: React.useMemo(\n      () =>\n        disabled ? null : (\n          <SafeZoneArea\n            debug={debug}\n            onMouseEnter={onSvgMouseEnter}\n            onMouseMove={onSvgMouseMove}\n            onMouseLeave={onSvgMouseLeave}\n            imperativeRef={safeZoneAreaRef}\n            stateStore={stateStore}\n          />\n        ),\n      [disabled, debug, onSvgMouseEnter, onSvgMouseMove, onSvgMouseLeave, stateStore],\n    ),\n  };\n}\n"],"names":["useSafeZoneArea","debug","disabled","onSafeZoneEnter","onSafeZoneMove","onSafeZoneLeave","onSafeZoneTimeout","timeout","stateStore","React","useState","createSafeZoneAreaStateStore","targetDocument","useFluent_unstable","safeZoneAreaRef","useRef","containerRef","targetRef","timeoutIdRef","mouseMoveIdRef","containerListenerRef","useMemo","containerEl","onContainerMouseEnter","targetWindow","defaultView","current","clearTimeout","toggleActive","el","removeEventListener","addEventListener","targetListenerRef","targetEl","onTargetMouseMove","e","isActive","requestAnimationFrame","updateSVG","containerPlacementSide","parseFloatingUIPlacement","dataset","popperPlacement","side","containerRect","getBoundingClientRect","mouseCoordinates","x","clientX","y","clientY","targetRect","cancelAnimationFrame","onSvgMouseEnter","useEventCallback","persist","setTimeout","onSvgMouseMove","onSvgMouseLeave","useMergedRefs","elementToRender","createElement","SafeZoneArea","onMouseEnter","onMouseMove","onMouseLeave","imperativeRef"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/utils/devtools.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/devtools.ts"],"sourcesContent":["import type { MiddlewareState } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { isHTMLElement } from '@fluentui/react-utilities';\nimport { listScrollParents } from './listScrollParents';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n\nexport const devtoolsCallback =\n  (options: Pick<PositioningOptions, 'flipBoundary' | 'overflowBoundary'>) => (middlewareState: MiddlewareState) => {\n    const {\n      elements: { floating, reference },\n    } = middlewareState;\n    const scrollParentsSet = new Set<HTMLElement>();\n    if (isHTMLElement(reference)) {\n      listScrollParents(reference).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n    }\n    listScrollParents(floating).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n    const flipBoundaries: HTMLElement[] = Array.isArray(options.flipBoundary)\n      ? options.flipBoundary\n      : isHTMLElement(options.flipBoundary)\n      ? [options.flipBoundary]\n      : [];\n    const overflowBoundaries: HTMLElement[] = Array.isArray(options.overflowBoundary)\n      ? options.overflowBoundary\n      : isHTMLElement(options.overflowBoundary)\n      ? [options.overflowBoundary]\n      : [];\n    return {\n      type: 'FluentUIMiddleware',\n      middlewareState,\n      options,\n      initialPlacement: fromFloatingUIPlacement(middlewareState.initialPlacement),\n      placement: fromFloatingUIPlacement(middlewareState.placement),\n      flipBoundaries,\n      overflowBoundaries,\n      scrollParents: Array.from(scrollParentsSet),\n    } as const;\n  };\n"],"names":["devtoolsCallback","options","middlewareState","elements","floating","reference","scrollParentsSet","Set","isHTMLElement","listScrollParents","forEach","scrollParent","add","flipBoundaries","Array","isArray","flipBoundary","overflowBoundaries","overflowBoundary","type","initialPlacement","fromFloatingUIPlacement","placement","scrollParents","from"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;gCAJiB;mCACI;yCACM;AAEjC,MAAMA,mBACX,CAACC,UAA2E,CAACC;QAC3E,MAAM,EACJC,UAAU,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAClC,GAAGH;QACJ,MAAMI,mBAAmB,IAAIC;QAC7B,IAAIC,IAAAA,6BAAa,EAACH,YAAY;YAC5BI,IAAAA,oCAAiB,EAACJ,WAAWK,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QAC5E;QACAF,IAAAA,oCAAiB,EAACL,UAAUM,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QACzE,MAAME,iBAAgCC,MAAMC,OAAO,CAACd,QAAQe,YAAY,IACpEf,QAAQe,YAAY,GACpBR,IAAAA,6BAAa,EAACP,QAAQe,YAAY,IAClC;YAACf,QAAQe,YAAY;SAAC,GACtB,EAAE;QACN,MAAMC,qBAAoCH,MAAMC,OAAO,CAACd,QAAQiB,gBAAgB,IAC5EjB,QAAQiB,gBAAgB,GACxBV,IAAAA,6BAAa,EAACP,QAAQiB,gBAAgB,IACtC;YAACjB,QAAQiB,gBAAgB;SAAC,GAC1B,EAAE;QACN,OAAO;YACLC,MAAM;YACNjB;YACAD;YACAmB,kBAAkBC,IAAAA,gDAAuB,EAACnB,gBAAgBkB,gBAAgB;YAC1EE,WAAWD,IAAAA,gDAAuB,EAACnB,gBAAgBoB,SAAS;YAC5DT;YACAI;YACAM,eAAeT,MAAMU,IAAI,CAAClB;QAC5B;IACF"}
+{"version":3,"sources":["../src/utils/devtools.ts"],"sourcesContent":["import type { MiddlewareState } from '@floating-ui/dom';\nimport type { PositioningOptions } from '../types';\nimport { isHTMLElement } from '@fluentui/react-utilities';\nimport { listScrollParents } from './listScrollParents';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n\nexport const devtoolsCallback =\n  (options: Pick<PositioningOptions, 'flipBoundary' | 'overflowBoundary'>) => (middlewareState: MiddlewareState) => {\n    const {\n      elements: { floating, reference },\n    } = middlewareState;\n    const scrollParentsSet = new Set<HTMLElement>();\n    if (isHTMLElement(reference)) {\n      listScrollParents(reference).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n    }\n    listScrollParents(floating).forEach(scrollParent => scrollParentsSet.add(scrollParent));\n    const flipBoundaries: HTMLElement[] = Array.isArray(options.flipBoundary)\n      ? options.flipBoundary\n      : isHTMLElement(options.flipBoundary)\n      ? [options.flipBoundary]\n      : [];\n    const overflowBoundaries: HTMLElement[] = Array.isArray(options.overflowBoundary)\n      ? options.overflowBoundary\n      : isHTMLElement(options.overflowBoundary)\n      ? [options.overflowBoundary]\n      : [];\n    return {\n      type: 'FluentUIMiddleware',\n      middlewareState,\n      options,\n      initialPlacement: fromFloatingUIPlacement(middlewareState.initialPlacement),\n      placement: fromFloatingUIPlacement(middlewareState.placement),\n      flipBoundaries,\n      overflowBoundaries,\n      scrollParents: Array.from(scrollParentsSet),\n    } as const;\n  };\n"],"names":["devtoolsCallback","options","middlewareState","elements","floating","reference","scrollParentsSet","Set","isHTMLElement","listScrollParents","forEach","scrollParent","add","flipBoundaries","Array","isArray","flipBoundary","overflowBoundaries","overflowBoundary","type","initialPlacement","fromFloatingUIPlacement","placement","scrollParents","from"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;gCAJiB;mCACI;yCACM;AAEjC,MAAMA,mBACX,CAACC,UAA2E,CAACC;QAC3E,MAAM,EACJC,UAAU,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAClC,GAAGH;QACJ,MAAMI,mBAAmB,IAAIC;QAC7B,IAAIC,IAAAA,6BAAAA,EAAcH,YAAY;YAC5BI,IAAAA,oCAAAA,EAAkBJ,WAAWK,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QAC5E;QACAF,IAAAA,oCAAAA,EAAkBL,UAAUM,OAAO,CAACC,CAAAA,eAAgBL,iBAAiBM,GAAG,CAACD;QACzE,MAAME,iBAAgCC,MAAMC,OAAO,CAACd,QAAQe,YAAY,IACpEf,QAAQe,YAAY,GACpBR,IAAAA,6BAAAA,EAAcP,QAAQe,YAAY,IAClC;YAACf,QAAQe,YAAY;SAAC,GACtB,EAAE;QACN,MAAMC,qBAAoCH,MAAMC,OAAO,CAACd,QAAQiB,gBAAgB,IAC5EjB,QAAQiB,gBAAgB,GACxBV,IAAAA,6BAAAA,EAAcP,QAAQiB,gBAAgB,IACtC;YAACjB,QAAQiB,gBAAgB;SAAC,GAC1B,EAAE;QACN,OAAO;YACLC,MAAM;YACNjB;YACAD;YACAmB,kBAAkBC,IAAAA,gDAAAA,EAAwBnB,gBAAgBkB,gBAAgB;YAC1EE,WAAWD,IAAAA,gDAAAA,EAAwBnB,gBAAgBoB,SAAS;YAC5DT;YACAI;YACAM,eAAeT,MAAMU,IAAI,CAAClB;QAC5B;IACF"}

package/lib-commonjs/utils/fromFloatingUIPlacement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/fromFloatingUIPlacement.ts"],"sourcesContent":["import type { Side, Alignment as FloatingUIAlignment, Placement } from '@floating-ui/dom';\nimport type { Alignment, Position } from '../types';\nimport { parseFloatingUIPlacement } from './parseFloatingUIPlacement';\n\nconst getPositionMap = (): Record<Side, Position> => ({\n  top: 'above',\n  bottom: 'below',\n  right: 'after',\n  left: 'before',\n});\n\n// Floating UI automatically flips alignment\n// https://github.com/floating-ui/floating-ui/issues/1563\nconst getAlignmentMap = (position: Position): Record<FloatingUIAlignment, Alignment> => {\n  if (position === 'above' || position === 'below') {\n    return {\n      start: 'start',\n      end: 'end',\n    };\n  }\n\n  return {\n    start: 'top',\n    end: 'bottom',\n  };\n};\n\n/**\n * Maps Floating UI placement to positioning values\n * @see positioningHelper.test.ts for expected placement values\n */\nexport const fromFloatingUIPlacement = (placement: Placement): { position: Position; alignment?: Alignment } => {\n  const { side, alignment: floatingUIAlignment } = parseFloatingUIPlacement(placement);\n  const position = getPositionMap()[side];\n  const alignment = floatingUIAlignment && getAlignmentMap(position)[floatingUIAlignment];\n\n  return { position, alignment };\n};\n"],"names":["fromFloatingUIPlacement","getPositionMap","top","bottom","right","left","getAlignmentMap","position","start","end","placement","side","alignment","floatingUIAlignment","parseFloatingUIPlacement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA+BaA;;;eAAAA;;;0CA7B4B;AAEzC,MAAMC,iBAAiB,IAA+B,CAAA;QACpDC,KAAK;QACLC,QAAQ;QACRC,OAAO;QACPC,MAAM;IACR,CAAA;AAEA,4CAA4C;AAC5C,yDAAyD;AACzD,MAAMC,kBAAkB,CAACC;IACvB,IAAIA,aAAa,WAAWA,aAAa,SAAS;QAChD,OAAO;YACLC,OAAO;YACPC,KAAK;QACP;IACF;IAEA,OAAO;QACLD,OAAO;QACPC,KAAK;IACP;AACF;AAMO,MAAMT,0BAA0B,CAACU;IACtC,MAAM,EAAEC,IAAI,EAAEC,WAAWC,mBAAmB,EAAE,GAAGC,IAAAA,kDAAwB,EAACJ;IAC1E,MAAMH,WAAWN,gBAAgB,CAACU,KAAK;IACvC,MAAMC,YAAYC,uBAAuBP,gBAAgBC,SAAS,CAACM,oBAAoB;IAEvF,OAAO;QAAEN;QAAUK;IAAU;AAC/B"}
+{"version":3,"sources":["../src/utils/fromFloatingUIPlacement.ts"],"sourcesContent":["import type { Side, Alignment as FloatingUIAlignment, Placement } from '@floating-ui/dom';\nimport type { Alignment, Position } from '../types';\nimport { parseFloatingUIPlacement } from './parseFloatingUIPlacement';\n\nconst getPositionMap = (): Record<Side, Position> => ({\n  top: 'above',\n  bottom: 'below',\n  right: 'after',\n  left: 'before',\n});\n\n// Floating UI automatically flips alignment\n// https://github.com/floating-ui/floating-ui/issues/1563\nconst getAlignmentMap = (position: Position): Record<FloatingUIAlignment, Alignment> => {\n  if (position === 'above' || position === 'below') {\n    return {\n      start: 'start',\n      end: 'end',\n    };\n  }\n\n  return {\n    start: 'top',\n    end: 'bottom',\n  };\n};\n\n/**\n * Maps Floating UI placement to positioning values\n * @see positioningHelper.test.ts for expected placement values\n */\nexport const fromFloatingUIPlacement = (placement: Placement): { position: Position; alignment?: Alignment } => {\n  const { side, alignment: floatingUIAlignment } = parseFloatingUIPlacement(placement);\n  const position = getPositionMap()[side];\n  const alignment = floatingUIAlignment && getAlignmentMap(position)[floatingUIAlignment];\n\n  return { position, alignment };\n};\n"],"names":["fromFloatingUIPlacement","getPositionMap","top","bottom","right","left","getAlignmentMap","position","start","end","placement","side","alignment","floatingUIAlignment","parseFloatingUIPlacement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA+BaA;;;eAAAA;;;0CA7B4B;AAEzC,MAAMC,iBAAiB,IAA+B,CAAA;QACpDC,KAAK;QACLC,QAAQ;QACRC,OAAO;QACPC,MAAM;IACR,CAAA;AAEA,4CAA4C;AAC5C,yDAAyD;AACzD,MAAMC,kBAAkB,CAACC;IACvB,IAAIA,aAAa,WAAWA,aAAa,SAAS;QAChD,OAAO;YACLC,OAAO;YACPC,KAAK;QACP;IACF;IAEA,OAAO;QACLD,OAAO;QACPC,KAAK;IACP;AACF;AAMO,MAAMT,0BAA0B,CAACU;IACtC,MAAM,EAAEC,IAAI,EAAEC,WAAWC,mBAAmB,EAAE,GAAGC,IAAAA,kDAAAA,EAAyBJ;IAC1E,MAAMH,WAAWN,gBAAgB,CAACU,KAAK;IACvC,MAAMC,YAAYC,uBAAuBP,gBAAgBC,SAAS,CAACM,oBAAoB;IAEvF,OAAO;QAAEN;QAAUK;IAAU;AAC/B"}

package/lib-commonjs/utils/getBoundary.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/getBoundary.ts"],"sourcesContent":["import type { Boundary as FloatingUIBoundary } from '@floating-ui/dom';\n\nimport { getScrollParent } from './getScrollParent';\nimport type { PositioningBoundary } from '../types';\n\n/**\n * Allows to mimic a behavior from V1 of Popper and accept `window` and `scrollParent` as strings.\n */\nexport function getBoundary(\n  element: HTMLElement | null,\n  boundary?: PositioningBoundary,\n): FloatingUIBoundary | undefined {\n  if (boundary === 'window') {\n    return element?.ownerDocument!.documentElement;\n  }\n\n  if (boundary === 'clippingParents') {\n    return 'clippingAncestors';\n  }\n\n  if (boundary === 'scrollParent') {\n    let boundariesNode: HTMLElement | undefined = getScrollParent(element);\n\n    if (boundariesNode.nodeName === 'BODY') {\n      boundariesNode = element?.ownerDocument!.documentElement;\n    }\n\n    return boundariesNode;\n  }\n\n  return boundary;\n}\n"],"names":["getBoundary","element","boundary","ownerDocument","documentElement","boundariesNode","getScrollParent","nodeName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;iCANgB;AAMzB,SAASA,YACdC,OAA2B,EAC3BC,QAA8B;IAE9B,IAAIA,aAAa,UAAU;QACzB,OAAOD,oBAAAA,8BAAAA,QAASE,aAAa,CAAEC,eAAe;IAChD;IAEA,IAAIF,aAAa,mBAAmB;QAClC,OAAO;IACT;IAEA,IAAIA,aAAa,gBAAgB;QAC/B,IAAIG,iBAA0CC,IAAAA,gCAAe,EAACL;QAE9D,IAAII,eAAeE,QAAQ,KAAK,QAAQ;YACtCF,iBAAiBJ,oBAAAA,8BAAAA,QAASE,aAAa,CAAEC,eAAe;QAC1D;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}
+{"version":3,"sources":["../src/utils/getBoundary.ts"],"sourcesContent":["import type { Boundary as FloatingUIBoundary } from '@floating-ui/dom';\n\nimport { getScrollParent } from './getScrollParent';\nimport type { PositioningBoundary } from '../types';\n\n/**\n * Allows to mimic a behavior from V1 of Popper and accept `window` and `scrollParent` as strings.\n */\nexport function getBoundary(\n  element: HTMLElement | null,\n  boundary?: PositioningBoundary,\n): FloatingUIBoundary | undefined {\n  if (boundary === 'window') {\n    return element?.ownerDocument!.documentElement;\n  }\n\n  if (boundary === 'clippingParents') {\n    return 'clippingAncestors';\n  }\n\n  if (boundary === 'scrollParent') {\n    let boundariesNode: HTMLElement | undefined = getScrollParent(element);\n\n    if (boundariesNode.nodeName === 'BODY') {\n      boundariesNode = element?.ownerDocument!.documentElement;\n    }\n\n    return boundariesNode;\n  }\n\n  return boundary;\n}\n"],"names":["getBoundary","element","boundary","ownerDocument","documentElement","boundariesNode","getScrollParent","nodeName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQgBA;;;eAAAA;;;iCANgB;AAMzB,SAASA,YACdC,OAA2B,EAC3BC,QAA8B;IAE9B,IAAIA,aAAa,UAAU;QACzB,OAAOD,YAAAA,QAAAA,YAAAA,KAAAA,IAAAA,KAAAA,IAAAA,QAASE,aAAa,CAAEC,eAAe;IAChD;IAEA,IAAIF,aAAa,mBAAmB;QAClC,OAAO;IACT;IAEA,IAAIA,aAAa,gBAAgB;QAC/B,IAAIG,iBAA0CC,IAAAA,gCAAAA,EAAgBL;QAE9D,IAAII,eAAeE,QAAQ,KAAK,QAAQ;YACtCF,iBAAiBJ,YAAAA,QAAAA,YAAAA,KAAAA,IAAAA,KAAAA,IAAAA,QAASE,aAAa,CAAEC,eAAe;QAC1D;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}

package/lib-commonjs/utils/getFloatingUIOffset.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/getFloatingUIOffset.ts"],"sourcesContent":["import type { Offset } from '../types';\nimport type { MiddlewareState } from '@floating-ui/dom';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetValue =\n  | number\n  | {\n      /**\n       * The axis that runs along the side of the floating element.\n       * @default 0\n       */\n      mainAxis?: number;\n      /**\n       * The axis that runs along the alignment of the floating element.\n       * @default 0\n       */\n      crossAxis?: number;\n      /**\n       * When set to a number, overrides the `crossAxis` value for aligned\n       * (non-centered/base) placements and works logically. A positive number\n       * will move the floating element in the direction of the opposite edge\n       * to the one that is aligned, while a negative number the reverse.\n       * @default null\n       */\n      alignmentAxis?: number | null;\n    };\n\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetFunction = (args: MiddlewareState) => FloatingUIOffsetValue;\n\n/**\n * Shim to transform offset values from this library to Floating UI\n * @param rawOffset Offset from this library\n * @returns An offset value compatible with Floating UI\n */\nexport function getFloatingUIOffset(\n  rawOffset: Offset | undefined,\n): FloatingUIOffsetValue | FloatingUIOffsetFunction | undefined {\n  if (!rawOffset) {\n    return rawOffset;\n  }\n\n  if (typeof rawOffset === 'number' || typeof rawOffset === 'object') {\n    return rawOffset;\n  }\n\n  return ({ rects: { floating, reference }, placement }) => {\n    const { position, alignment } = fromFloatingUIPlacement(placement);\n    return rawOffset({ positionedRect: floating, targetRect: reference, position, alignment });\n  };\n}\n"],"names":["getFloatingUIOffset","rawOffset","rects","floating","reference","placement","position","alignment","fromFloatingUIPlacement","positionedRect","targetRect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAuCgBA;;;eAAAA;;;yCArCwB;AAqCjC,SAASA,oBACdC,SAA6B;IAE7B,IAAI,CAACA,WAAW;QACd,OAAOA;IACT;IAEA,IAAI,OAAOA,cAAc,YAAY,OAAOA,cAAc,UAAU;QAClE,OAAOA;IACT;IAEA,OAAO,CAAC,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAAEC,SAAS,EAAE;QACnD,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAE,GAAGC,IAAAA,gDAAuB,EAACH;QACxD,OAAOJ,UAAU;YAAEQ,gBAAgBN;YAAUO,YAAYN;YAAWE;YAAUC;QAAU;IAC1F;AACF"}
+{"version":3,"sources":["../src/utils/getFloatingUIOffset.ts"],"sourcesContent":["import type { Offset } from '../types';\nimport type { MiddlewareState } from '@floating-ui/dom';\nimport { fromFloatingUIPlacement } from './fromFloatingUIPlacement';\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetValue =\n  | number\n  | {\n      /**\n       * The axis that runs along the side of the floating element.\n       * @default 0\n       */\n      mainAxis?: number;\n      /**\n       * The axis that runs along the alignment of the floating element.\n       * @default 0\n       */\n      crossAxis?: number;\n      /**\n       * When set to a number, overrides the `crossAxis` value for aligned\n       * (non-centered/base) placements and works logically. A positive number\n       * will move the floating element in the direction of the opposite edge\n       * to the one that is aligned, while a negative number the reverse.\n       * @default null\n       */\n      alignmentAxis?: number | null;\n    };\n\n/**\n * Type taken from Floating UI since they are not exported\n */\nexport type FloatingUIOffsetFunction = (args: MiddlewareState) => FloatingUIOffsetValue;\n\n/**\n * Shim to transform offset values from this library to Floating UI\n * @param rawOffset Offset from this library\n * @returns An offset value compatible with Floating UI\n */\nexport function getFloatingUIOffset(\n  rawOffset: Offset | undefined,\n): FloatingUIOffsetValue | FloatingUIOffsetFunction | undefined {\n  if (!rawOffset) {\n    return rawOffset;\n  }\n\n  if (typeof rawOffset === 'number' || typeof rawOffset === 'object') {\n    return rawOffset;\n  }\n\n  return ({ rects: { floating, reference }, placement }) => {\n    const { position, alignment } = fromFloatingUIPlacement(placement);\n    return rawOffset({ positionedRect: floating, targetRect: reference, position, alignment });\n  };\n}\n"],"names":["getFloatingUIOffset","rawOffset","rects","floating","reference","placement","position","alignment","fromFloatingUIPlacement","positionedRect","targetRect"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAuCgBA;;;eAAAA;;;yCArCwB;AAqCjC,SAASA,oBACdC,SAA6B;IAE7B,IAAI,CAACA,WAAW;QACd,OAAOA;IACT;IAEA,IAAI,OAAOA,cAAc,YAAY,OAAOA,cAAc,UAAU;QAClE,OAAOA;IACT;IAEA,OAAO,CAAC,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,SAAS,EAAE,EAAEC,SAAS,EAAE;QACnD,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAE,GAAGC,IAAAA,gDAAAA,EAAwBH;QACxD,OAAOJ,UAAU;YAAEQ,gBAAgBN;YAAUO,YAAYN;YAAWE;YAAUC;QAAU;IAC1F;AACF"}

package/lib-commonjs/utils/getReactFiberFromNode.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/getReactFiberFromNode.ts"],"sourcesContent":["import * as React from 'react';\n\n// ========================================================\n// react/packages/shared/ReactTypes.js\n// ========================================================\n\ntype ReactEventResponder<E, C> = {\n  $$typeof: Symbol | number;\n  displayName: string;\n  targetEventTypes: null | string[];\n  rootEventTypes: null | string[];\n  getInitialState: null | ((props: Object) => Object);\n  onEvent: null | ((event: E, context: C, props: Object, state: Object) => void);\n  onRootEvent: null | ((event: E, context: C, props: Object, state: Object) => void);\n  onMount: null | ((context: C, props: Object, state: Object) => void);\n  onUnmount: null | ((context: C, props: Object, state: Object) => void);\n};\n\ntype ReactEventResponderInstance<E, C> = {\n  fiber: Object;\n  props: Object;\n  responder: ReactEventResponder<E, C>;\n  rootEventTypes: null | Set<string>;\n  state: Object;\n};\n\n// ========================================================\n// react/packages/react-reconciler/src/ReactFiberHooks.js\n// ========================================================\n\nexport type HookType =\n  | 'useState'\n  | 'useReducer'\n  | 'useContext'\n  | 'useRef'\n  | 'useEffect'\n  | 'useLayoutEffect'\n  | 'useCallback'\n  | 'useMemo'\n  | 'useImperativeHandle'\n  | 'useDebugValue'\n  | 'useResponder';\n\ntype ReactProviderType<T> = {\n  $$typeof: Symbol | number;\n  _context: ReactContext<T>;\n};\n\ntype ReactContext<T> = {\n  $$typeof: Symbol | number;\n  Consumer: ReactContext<T>;\n  Provider: ReactProviderType<T>;\n\n  _calculateChangedBits: ((a: T, b: T) => number) | null;\n\n  _currentValue: T;\n  _currentValue2: T;\n  _threadCount: number;\n\n  // DEV only\n  _currentRenderer?: Object | null;\n  _currentRenderer2?: Object | null;\n};\n\ntype ContextDependency<T> = {\n  context: ReactContext<T>;\n  observedBits: number;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  next: ContextDependency<any> | null;\n};\n\nenum WorkTag {\n  FunctionComponent = 0,\n  ClassComponent = 1,\n  IndeterminateComponent = 2, // Before we know whether it is function or class\n  HostRoot = 3, // Root of a host tree. Could be nested inside another node.\n  HostPortal = 4, // A subtree. Could be an entry point to a different renderer.\n  HostComponent = 5,\n  HostText = 6,\n  Fragment = 7,\n  Mode = 8,\n  ContextConsumer = 9,\n  ContextProvider = 10,\n  ForwardRef = 11,\n  Profiler = 12,\n  SuspenseComponent = 13,\n  MemoComponent = 14,\n  SimpleMemoComponent = 15,\n  LazyComponent = 16,\n  IncompleteClassComponent = 17,\n  DehydratedFragment = 18,\n  SuspenseListComponent = 19,\n  FundamentalComponent = 20,\n  ScopeComponent = 21,\n}\n\ntype Source = {\n  fileName: string;\n  lineNumber: number;\n};\n\ntype ExpirationTime = number;\n\ntype Dependencies = {\n  expirationTime: ExpirationTime;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  firstContext: ContextDependency<any> | null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  responders: Map<ReactEventResponder<any, any>, ReactEventResponderInstance<any, any>> | null;\n};\n\n// ========================================================\n// react/packages/react-reconciler/src/ReactFiber.js\n// ========================================================\n\n// A Fiber is work on a Component that needs to be done or was done. There can\n// be more than one per component.\n\nexport type Fiber = {\n  // These first fields are conceptually members of an Instance. This used to\n  // be split into a separate type and intersected with the other Fiber fields,\n  // but until Flow fixes its intersection bugs, we've merged them into a\n  // single type.\n\n  // An Instance is shared between all versions of a component. We can easily\n  // break this out into a separate object to avoid copying so much to the\n  // alternate versions of the tree. We put this on a single object for now to\n  // minimize the number of objects created during the initial render.\n\n  // Tag identifying the type of fiber.\n  tag: WorkTag;\n\n  // Unique identifier of this child.\n  key: null | string;\n\n  // The value of element.type which is used to preserve the identity during\n  // reconciliation of this child.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  elementType: any;\n\n  // The resolved function/class/ associated with this fiber.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  type: any;\n\n  // The local state associated with this fiber.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stateNode: any;\n\n  // Conceptual aliases\n  // parent : Instance -> return The parent happens to be the same as the\n  // return fiber since we've merged the fiber and instance.\n\n  // Remaining fields belong to Fiber\n\n  // The Fiber to return to after finishing processing this one.\n  // This is effectively the parent, but there can be multiple parents (two)\n  // so this is only the parent of the thing we're currently processing.\n  // It is conceptually the same as the return address of a stack frame.\n  return: Fiber | null;\n\n  // Singly Linked List Tree Structure.\n  child: Fiber | null;\n  sibling: Fiber | null;\n  index: number;\n\n  // The ref last used to attach this node.\n  // I'll avoid adding an owner field for prod and model that as functions.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ref: React.Ref<any>;\n\n  // Input is the data coming into process this fiber. Arguments. Props.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  pendingProps: any; // This type will be more specific once we overload the tag.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  memoizedProps: any; // The props used to create the output.\n\n  // A queue of state updates and callbacks.\n  // updateQueue: UpdateQueue<any> | null,\n\n  // The state used to create the output\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  memoizedState: any;\n\n  // Dependencies (contexts, events) for this fiber, if it has any\n  dependencies: Dependencies | null;\n\n  // // Bitfield that describes properties about the fiber and its subtree. E.g.\n  // // the ConcurrentMode flag indicates whether the subtree should be async-by-\n  // // default. When a fiber is created, it inherits the mode of its\n  // // parent. Additional flags can be set at creation time, but after that the\n  // // value should remain unchanged throughout the fiber's lifetime, particularly\n  // // before its child fibers are created.\n  // mode: TypeOfMode\n  //\n  // // Effect\n  // effectTag: SideEffectTag\n\n  // Singly linked list fast path to the next fiber with side-effects.\n  nextEffect: Fiber | null;\n\n  // The first and last fiber with side-effect within this subtree. This allows\n  // us to reuse a slice of the linked list when we reuse the work done within\n  // this fiber.\n  firstEffect: Fiber | null;\n  lastEffect: Fiber | null;\n\n  // Represents a time in the future by which this work should be completed.\n  // Does not include work found in its subtree.\n  expirationTime: ExpirationTime;\n\n  // This is used to quickly determine if a subtree has no pending changes.\n  childExpirationTime: ExpirationTime;\n\n  // This is a pooled version of a Fiber. Every fiber that gets updated will\n  // eventually have a pair. There are cases when we can clean up pairs to save\n  // memory if we need to.\n  alternate: Fiber | null;\n\n  // Time spent rendering this Fiber and its descendants for the current update.\n  // This tells us how well the tree makes use of sCU for memoization.\n  // It is reset to 0 each time we render and only updated when we don't bailout.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  actualDuration?: number;\n\n  // If the Fiber is currently active in the \"render\" phase,\n  // This marks the time at which the work began.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  actualStartTime?: number;\n\n  // Duration of the most recent render time for this Fiber.\n  // This value is not updated when we bailout for memoization purposes.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  selfBaseDuration?: number;\n\n  // Sum of base times for all descendants of this Fiber.\n  // This value bubbles up during the \"complete\" phase.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  treeBaseDuration?: number;\n\n  // Conceptual aliases\n  // workInProgress : Fiber ->  alternate The alternate used for reuse happens\n  // to be the same as work in progress.\n  // __DEV__ only\n  _debugID?: number;\n  _debugSource?: Source | null;\n  _debugOwner?: Fiber | null;\n  _debugIsCurrentlyTiming?: boolean;\n  _debugNeedsRemount?: boolean;\n\n  // Used to verify that the order of hooks does not change between renders.\n  _debugHookTypes?: HookType[] | null;\n};\n\nexport function getReactFiberFromNode(elm: Node | undefined): Fiber | null {\n  if (!elm) {\n    return null;\n  }\n\n  for (const k in elm) {\n    // React 16 uses \"__reactInternalInstance$\" prefix\n    // React 17 uses \"__reactFiber$\" prefix\n    // https://github.com/facebook/react/pull/18377\n    if (k.indexOf('__reactInternalInstance$') === 0 || k.indexOf('__reactFiber$') === 0) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      return elm[k];\n    }\n  }\n\n  throw new Error('getReactFiber(): Failed to find a React Fiber on a node');\n}\n"],"names":["getReactFiberFromNode","WorkTag","elm","k","indexOf","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA6PgBA;;;eAAAA;;;;iEA7PO;;UAuElBC;;;;;;;;;;;;;;;;;;;;;;;GAAAA,YAAAA;AAsLE,SAASD,sBAAsBE,GAAqB;IACzD,IAAI,CAACA,KAAK;QACR,OAAO;IACT;IAEA,IAAK,MAAMC,KAAKD,IAAK;QACnB,kDAAkD;QAClD,uCAAuC;QACvC,+CAA+C;QAC/C,IAAIC,EAAEC,OAAO,CAAC,gCAAgC,KAAKD,EAAEC,OAAO,CAAC,qBAAqB,GAAG;YACnF,6DAA6D;YAC7D,aAAa;YACb,OAAOF,GAAG,CAACC,EAAE;QACf;IACF;IAEA,MAAM,IAAIE,MAAM;AAClB"}
+{"version":3,"sources":["../src/utils/getReactFiberFromNode.ts"],"sourcesContent":["import * as React from 'react';\n\n// ========================================================\n// react/packages/shared/ReactTypes.js\n// ========================================================\n\ntype ReactEventResponder<E, C> = {\n  $$typeof: Symbol | number;\n  displayName: string;\n  targetEventTypes: null | string[];\n  rootEventTypes: null | string[];\n  getInitialState: null | ((props: Object) => Object);\n  onEvent: null | ((event: E, context: C, props: Object, state: Object) => void);\n  onRootEvent: null | ((event: E, context: C, props: Object, state: Object) => void);\n  onMount: null | ((context: C, props: Object, state: Object) => void);\n  onUnmount: null | ((context: C, props: Object, state: Object) => void);\n};\n\ntype ReactEventResponderInstance<E, C> = {\n  fiber: Object;\n  props: Object;\n  responder: ReactEventResponder<E, C>;\n  rootEventTypes: null | Set<string>;\n  state: Object;\n};\n\n// ========================================================\n// react/packages/react-reconciler/src/ReactFiberHooks.js\n// ========================================================\n\nexport type HookType =\n  | 'useState'\n  | 'useReducer'\n  | 'useContext'\n  | 'useRef'\n  | 'useEffect'\n  | 'useLayoutEffect'\n  | 'useCallback'\n  | 'useMemo'\n  | 'useImperativeHandle'\n  | 'useDebugValue'\n  | 'useResponder';\n\ntype ReactProviderType<T> = {\n  $$typeof: Symbol | number;\n  _context: ReactContext<T>;\n};\n\ntype ReactContext<T> = {\n  $$typeof: Symbol | number;\n  Consumer: ReactContext<T>;\n  Provider: ReactProviderType<T>;\n\n  _calculateChangedBits: ((a: T, b: T) => number) | null;\n\n  _currentValue: T;\n  _currentValue2: T;\n  _threadCount: number;\n\n  // DEV only\n  _currentRenderer?: Object | null;\n  _currentRenderer2?: Object | null;\n};\n\ntype ContextDependency<T> = {\n  context: ReactContext<T>;\n  observedBits: number;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  next: ContextDependency<any> | null;\n};\n\nenum WorkTag {\n  FunctionComponent = 0,\n  ClassComponent = 1,\n  IndeterminateComponent = 2, // Before we know whether it is function or class\n  HostRoot = 3, // Root of a host tree. Could be nested inside another node.\n  HostPortal = 4, // A subtree. Could be an entry point to a different renderer.\n  HostComponent = 5,\n  HostText = 6,\n  Fragment = 7,\n  Mode = 8,\n  ContextConsumer = 9,\n  ContextProvider = 10,\n  ForwardRef = 11,\n  Profiler = 12,\n  SuspenseComponent = 13,\n  MemoComponent = 14,\n  SimpleMemoComponent = 15,\n  LazyComponent = 16,\n  IncompleteClassComponent = 17,\n  DehydratedFragment = 18,\n  SuspenseListComponent = 19,\n  FundamentalComponent = 20,\n  ScopeComponent = 21,\n}\n\ntype Source = {\n  fileName: string;\n  lineNumber: number;\n};\n\ntype ExpirationTime = number;\n\ntype Dependencies = {\n  expirationTime: ExpirationTime;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  firstContext: ContextDependency<any> | null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  responders: Map<ReactEventResponder<any, any>, ReactEventResponderInstance<any, any>> | null;\n};\n\n// ========================================================\n// react/packages/react-reconciler/src/ReactFiber.js\n// ========================================================\n\n// A Fiber is work on a Component that needs to be done or was done. There can\n// be more than one per component.\n\nexport type Fiber = {\n  // These first fields are conceptually members of an Instance. This used to\n  // be split into a separate type and intersected with the other Fiber fields,\n  // but until Flow fixes its intersection bugs, we've merged them into a\n  // single type.\n\n  // An Instance is shared between all versions of a component. We can easily\n  // break this out into a separate object to avoid copying so much to the\n  // alternate versions of the tree. We put this on a single object for now to\n  // minimize the number of objects created during the initial render.\n\n  // Tag identifying the type of fiber.\n  tag: WorkTag;\n\n  // Unique identifier of this child.\n  key: null | string;\n\n  // The value of element.type which is used to preserve the identity during\n  // reconciliation of this child.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  elementType: any;\n\n  // The resolved function/class/ associated with this fiber.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  type: any;\n\n  // The local state associated with this fiber.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  stateNode: any;\n\n  // Conceptual aliases\n  // parent : Instance -> return The parent happens to be the same as the\n  // return fiber since we've merged the fiber and instance.\n\n  // Remaining fields belong to Fiber\n\n  // The Fiber to return to after finishing processing this one.\n  // This is effectively the parent, but there can be multiple parents (two)\n  // so this is only the parent of the thing we're currently processing.\n  // It is conceptually the same as the return address of a stack frame.\n  return: Fiber | null;\n\n  // Singly Linked List Tree Structure.\n  child: Fiber | null;\n  sibling: Fiber | null;\n  index: number;\n\n  // The ref last used to attach this node.\n  // I'll avoid adding an owner field for prod and model that as functions.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ref: React.Ref<any>;\n\n  // Input is the data coming into process this fiber. Arguments. Props.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  pendingProps: any; // This type will be more specific once we overload the tag.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  memoizedProps: any; // The props used to create the output.\n\n  // A queue of state updates and callbacks.\n  // updateQueue: UpdateQueue<any> | null,\n\n  // The state used to create the output\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  memoizedState: any;\n\n  // Dependencies (contexts, events) for this fiber, if it has any\n  dependencies: Dependencies | null;\n\n  // // Bitfield that describes properties about the fiber and its subtree. E.g.\n  // // the ConcurrentMode flag indicates whether the subtree should be async-by-\n  // // default. When a fiber is created, it inherits the mode of its\n  // // parent. Additional flags can be set at creation time, but after that the\n  // // value should remain unchanged throughout the fiber's lifetime, particularly\n  // // before its child fibers are created.\n  // mode: TypeOfMode\n  //\n  // // Effect\n  // effectTag: SideEffectTag\n\n  // Singly linked list fast path to the next fiber with side-effects.\n  nextEffect: Fiber | null;\n\n  // The first and last fiber with side-effect within this subtree. This allows\n  // us to reuse a slice of the linked list when we reuse the work done within\n  // this fiber.\n  firstEffect: Fiber | null;\n  lastEffect: Fiber | null;\n\n  // Represents a time in the future by which this work should be completed.\n  // Does not include work found in its subtree.\n  expirationTime: ExpirationTime;\n\n  // This is used to quickly determine if a subtree has no pending changes.\n  childExpirationTime: ExpirationTime;\n\n  // This is a pooled version of a Fiber. Every fiber that gets updated will\n  // eventually have a pair. There are cases when we can clean up pairs to save\n  // memory if we need to.\n  alternate: Fiber | null;\n\n  // Time spent rendering this Fiber and its descendants for the current update.\n  // This tells us how well the tree makes use of sCU for memoization.\n  // It is reset to 0 each time we render and only updated when we don't bailout.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  actualDuration?: number;\n\n  // If the Fiber is currently active in the \"render\" phase,\n  // This marks the time at which the work began.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  actualStartTime?: number;\n\n  // Duration of the most recent render time for this Fiber.\n  // This value is not updated when we bailout for memoization purposes.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  selfBaseDuration?: number;\n\n  // Sum of base times for all descendants of this Fiber.\n  // This value bubbles up during the \"complete\" phase.\n  // This field is only set when the enableProfilerTimer flag is enabled.\n  treeBaseDuration?: number;\n\n  // Conceptual aliases\n  // workInProgress : Fiber ->  alternate The alternate used for reuse happens\n  // to be the same as work in progress.\n  // __DEV__ only\n  _debugID?: number;\n  _debugSource?: Source | null;\n  _debugOwner?: Fiber | null;\n  _debugIsCurrentlyTiming?: boolean;\n  _debugNeedsRemount?: boolean;\n\n  // Used to verify that the order of hooks does not change between renders.\n  _debugHookTypes?: HookType[] | null;\n};\n\nexport function getReactFiberFromNode(elm: Node | undefined): Fiber | null {\n  if (!elm) {\n    return null;\n  }\n\n  for (const k in elm) {\n    // React 16 uses \"__reactInternalInstance$\" prefix\n    // React 17 uses \"__reactFiber$\" prefix\n    // https://github.com/facebook/react/pull/18377\n    if (k.indexOf('__reactInternalInstance$') === 0 || k.indexOf('__reactFiber$') === 0) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      return elm[k];\n    }\n  }\n\n  throw new Error('getReactFiber(): Failed to find a React Fiber on a node');\n}\n"],"names":["getReactFiberFromNode","WorkTag","elm","k","indexOf","Error"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA6PgBA;;;eAAAA;;;;iEA7PO;;UAuElBC,OAAAA;;;;;;;;;;;;;;;;;;;;;;;GAAAA,WAAAA,CAAAA,UAAAA,CAAAA,CAAAA;AAsLE,SAASD,sBAAsBE,GAAqB;IACzD,IAAI,CAACA,KAAK;QACR,OAAO;IACT;IAEA,IAAK,MAAMC,KAAKD,IAAK;QACnB,kDAAkD;QAClD,uCAAuC;QACvC,+CAA+C;QAC/C,IAAIC,EAAEC,OAAO,CAAC,gCAAgC,KAAKD,EAAEC,OAAO,CAAC,qBAAqB,GAAG;YACnF,6DAA6D;YAC7D,aAAa;YACb,OAAOF,GAAG,CAACC,EAAE;QACf;IACF;IAEA,MAAM,IAAIE,MAAM;AAClB"}

package/lib-commonjs/utils/getScrollParent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/getScrollParent.ts"],"sourcesContent":["/**\n * Returns the parent node or the host of the node argument.\n * @param node - DOM node.\n * @returns - parent DOM node.\n */\nexport const getParentNode = (node: HTMLElement): HTMLElement => {\n  if (node.nodeName === 'HTML') {\n    return node;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return node.parentNode || (node as any).host;\n};\n\n/**\n * Returns CSS styles of the given node.\n * @param node - DOM node.\n * @returns - CSS styles.\n */\nexport const getStyleComputedProperty = (node: HTMLElement): Partial<CSSStyleDeclaration> => {\n  if (node.nodeType !== 1) {\n    return {};\n  }\n\n  const targetWindow = node.ownerDocument?.defaultView;\n\n  if (targetWindow) {\n    return targetWindow.getComputedStyle(node, null);\n  }\n\n  return {};\n};\n\n/**\n * Returns the first scrollable parent of the given element.\n * @param node - DOM node.\n * @returns - the first scrollable parent.\n */\nexport const getScrollParent = (node: Document | HTMLElement | null): HTMLElement => {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  const parentNode = node && getParentNode(node as HTMLElement);\n  // eslint-disable-next-line\n  if (!parentNode) return document.body;\n\n  switch (parentNode.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return parentNode.ownerDocument!.body;\n    case '#document':\n      return (parentNode as unknown as Document).body;\n  }\n\n  // If any of the overflow props is defined for the node then we return it as the parent\n  const { overflow, overflowX, overflowY } = getStyleComputedProperty(parentNode);\n  if (/(auto|scroll|overlay)/.test(overflow! + overflowY! + overflowX)) {\n    return parentNode;\n  }\n\n  return getScrollParent(parentNode);\n};\n\nexport const hasScrollParent = (node: Document | HTMLElement | null): boolean => {\n  const scrollParentElement: HTMLElement = getScrollParent(node);\n\n  return scrollParentElement ? scrollParentElement !== scrollParentElement.ownerDocument?.body : false;\n};\n"],"names":["getParentNode","getScrollParent","getStyleComputedProperty","hasScrollParent","node","nodeName","parentNode","host","nodeType","targetWindow","ownerDocument","defaultView","getComputedStyle","document","body","overflow","overflowX","overflowY","test","scrollParentElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;CAIC;;;;;;;;;;;IACYA,aAAa;eAAbA;;IAiCAC,eAAe;eAAfA;;IAnBAC,wBAAwB;eAAxBA;;IA0CAC,eAAe;eAAfA;;;AAxDN,MAAMH,gBAAgB,CAACI;IAC5B,IAAIA,KAAKC,QAAQ,KAAK,QAAQ;QAC5B,OAAOD;IACT;IAEA,8DAA8D;IAC9D,OAAOA,KAAKE,UAAU,IAAI,AAACF,KAAaG,IAAI;AAC9C;AAOO,MAAML,2BAA2B,CAACE;QAKlBA;IAJrB,IAAIA,KAAKI,QAAQ,KAAK,GAAG;QACvB,OAAO,CAAC;IACV;IAEA,MAAMC,gBAAeL,sBAAAA,KAAKM,aAAa,cAAlBN,0CAAAA,oBAAoBO,WAAW;IAEpD,IAAIF,cAAc;QAChB,OAAOA,aAAaG,gBAAgB,CAACR,MAAM;IAC7C;IAEA,OAAO,CAAC;AACV;AAOO,MAAMH,kBAAkB,CAACG;IAC9B,iFAAiF;IACjF,MAAME,aAAaF,QAAQJ,cAAcI;IACzC,2BAA2B;IAC3B,IAAI,CAACE,YAAY,OAAOO,SAASC,IAAI;IAErC,OAAQR,WAAWD,QAAQ;QACzB,KAAK;QACL,KAAK;YACH,OAAOC,WAAWI,aAAa,CAAEI,IAAI;QACvC,KAAK;YACH,OAAO,AAACR,WAAmCQ,IAAI;IACnD;IAEA,uFAAuF;IACvF,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,SAAS,EAAE,GAAGf,yBAAyBI;IACpE,IAAI,wBAAwBY,IAAI,CAACH,WAAYE,YAAaD,YAAY;QACpE,OAAOV;IACT;IAEA,OAAOL,gBAAgBK;AACzB;AAEO,MAAMH,kBAAkB,CAACC;QAGuBe;IAFrD,MAAMA,sBAAmClB,gBAAgBG;IAEzD,OAAOe,sBAAsBA,0BAAwBA,qCAAAA,oBAAoBT,aAAa,cAAjCS,yDAAAA,mCAAmCL,IAAI,IAAG;AACjG"}
+{"version":3,"sources":["../src/utils/getScrollParent.ts"],"sourcesContent":["/**\n * Returns the parent node or the host of the node argument.\n * @param node - DOM node.\n * @returns - parent DOM node.\n */\nexport const getParentNode = (node: HTMLElement): HTMLElement => {\n  if (node.nodeName === 'HTML') {\n    return node;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return node.parentNode || (node as any).host;\n};\n\n/**\n * Returns CSS styles of the given node.\n * @param node - DOM node.\n * @returns - CSS styles.\n */\nexport const getStyleComputedProperty = (node: HTMLElement): Partial<CSSStyleDeclaration> => {\n  if (node.nodeType !== 1) {\n    return {};\n  }\n\n  const targetWindow = node.ownerDocument?.defaultView;\n\n  if (targetWindow) {\n    return targetWindow.getComputedStyle(node, null);\n  }\n\n  return {};\n};\n\n/**\n * Returns the first scrollable parent of the given element.\n * @param node - DOM node.\n * @returns - the first scrollable parent.\n */\nexport const getScrollParent = (node: Document | HTMLElement | null): HTMLElement => {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  const parentNode = node && getParentNode(node as HTMLElement);\n  // eslint-disable-next-line\n  if (!parentNode) return document.body;\n\n  switch (parentNode.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return parentNode.ownerDocument!.body;\n    case '#document':\n      return (parentNode as unknown as Document).body;\n  }\n\n  // If any of the overflow props is defined for the node then we return it as the parent\n  const { overflow, overflowX, overflowY } = getStyleComputedProperty(parentNode);\n  if (/(auto|scroll|overlay)/.test(overflow! + overflowY! + overflowX)) {\n    return parentNode;\n  }\n\n  return getScrollParent(parentNode);\n};\n\nexport const hasScrollParent = (node: Document | HTMLElement | null): boolean => {\n  const scrollParentElement: HTMLElement = getScrollParent(node);\n\n  return scrollParentElement ? scrollParentElement !== scrollParentElement.ownerDocument?.body : false;\n};\n"],"names":["getParentNode","getScrollParent","getStyleComputedProperty","hasScrollParent","node","nodeName","parentNode","host","nodeType","targetWindow","ownerDocument","defaultView","getComputedStyle","document","body","overflow","overflowX","overflowY","test","scrollParentElement"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;CAIC;;;;;;;;;;;IACYA,aAAAA;eAAAA;;IAiCAC,eAAAA;eAAAA;;IAnBAC,wBAAAA;eAAAA;;IA0CAC,eAAAA;eAAAA;;;AAxDN,MAAMH,gBAAgB,CAACI;IAC5B,IAAIA,KAAKC,QAAQ,KAAK,QAAQ;QAC5B,OAAOD;IACT;IAEA,8DAA8D;IAC9D,OAAOA,KAAKE,UAAU,IAAIF,KAAcG,IAAI;AAC9C;AAOO,MAAML,2BAA2B,CAACE;QAKlBA;IAJrB,IAAIA,KAAKI,QAAQ,KAAK,GAAG;QACvB,OAAO,CAAC;IACV;IAEA,MAAMC,eAAAA,AAAeL,CAAAA,sBAAAA,KAAKM,aAAa,AAAbA,MAAa,QAAlBN,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAoBO,WAAW;IAEpD,IAAIF,cAAc;QAChB,OAAOA,aAAaG,gBAAgB,CAACR,MAAM;IAC7C;IAEA,OAAO,CAAC;AACV;AAOO,MAAMH,kBAAkB,CAACG;IAC9B,iFAAiF;IACjF,MAAME,aAAaF,QAAQJ,cAAcI;IACzC,2BAA2B;IAC3B,IAAI,CAACE,YAAY,OAAOO,SAASC,IAAI;IAErC,OAAQR,WAAWD,QAAQ;QACzB,KAAK;QACL,KAAK;YACH,OAAOC,WAAWI,aAAa,CAAEI,IAAI;QACvC,KAAK;YACH,OAAOR,WAAoCQ,IAAI;IACnD;IAEA,uFAAuF;IACvF,MAAM,EAAEC,QAAQ,EAAEC,SAAS,EAAEC,SAAS,EAAE,GAAGf,yBAAyBI;IACpE,IAAI,wBAAwBY,IAAI,CAACH,WAAYE,YAAaD,YAAY;QACpE,OAAOV;IACT;IAEA,OAAOL,gBAAgBK;AACzB;AAEO,MAAMH,kBAAkB,CAACC;QAGuBe;IAFrD,MAAMA,sBAAmClB,gBAAgBG;IAEzD,OAAOe,sBAAsBA,wBAAAA,CAAAA,AAAwBA,CAAAA,qCAAAA,oBAAoBT,aAAa,AAAbA,MAAa,QAAjCS,uCAAAA,KAAAA,IAAAA,KAAAA,IAAAA,mCAAmCL,IAAI,AAAJA,IAAO;AACjG"}

package/lib-commonjs/utils/hasAutoFocusFilter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils/hasAutoFocusFilter.ts"],"sourcesContent":["//\n// Dev utils to detect if nodes have \"autoFocus\" props.\n//\n\nimport { getReactFiberFromNode } from './getReactFiberFromNode';\n\n/**\n * Detects if a passed HTML node has \"autoFocus\" prop on a React's fiber. Is needed as React handles autofocus behavior\n * in React DOM and will not pass \"autoFocus\" to an actual HTML.\n *\n * @param node\n */\nfunction hasAutofocusProp(node: Node): boolean {\n  // https://github.com/facebook/react/blob/848bb2426e44606e0a55dfe44c7b3ece33772485/packages/react-dom/src/client/ReactDOMHostConfig.js#L157-L166\n  const isAutoFocusableElement =\n    node.nodeName === 'BUTTON' ||\n    node.nodeName === 'INPUT' ||\n    node.nodeName === 'SELECT' ||\n    node.nodeName === 'TEXTAREA';\n\n  if (isAutoFocusableElement) {\n    return !!getReactFiberFromNode(node)?.pendingProps.autoFocus;\n  }\n\n  return false;\n}\n\nexport function hasAutofocusFilter(node: Node) {\n  return hasAutofocusProp(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n}\n"],"names":["hasAutofocusFilter","hasAutofocusProp","node","isAutoFocusableElement","nodeName","getReactFiberFromNode","pendingProps","autoFocus","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,EAAE;AACF,uDAAuD;AACvD,EAAE;;;;;+BAyBcA;;;eAAAA;;;uCAvBsB;AAEtC;;;;;CAKC,GACD,SAASC,iBAAiBC,IAAU;IAClC,gJAAgJ;IAChJ,MAAMC,yBACJD,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK,WAClBF,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK;IAEpB,IAAID,wBAAwB;YACjBE;QAAT,OAAO,CAAC,GAACA,0BAAAA,IAAAA,4CAAqB,EAACH,mBAAtBG,8CAAAA,wBAA6BC,YAAY,CAACC,SAAS;IAC9D;IAEA,OAAO;AACT;AAEO,SAASP,mBAAmBE,IAAU;IAC3C,OAAOD,iBAAiBC,QAAQM,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACnF"}
+{"version":3,"sources":["../src/utils/hasAutoFocusFilter.ts"],"sourcesContent":["//\n// Dev utils to detect if nodes have \"autoFocus\" props.\n//\n\nimport { getReactFiberFromNode } from './getReactFiberFromNode';\n\n/**\n * Detects if a passed HTML node has \"autoFocus\" prop on a React's fiber. Is needed as React handles autofocus behavior\n * in React DOM and will not pass \"autoFocus\" to an actual HTML.\n *\n * @param node\n */\nfunction hasAutofocusProp(node: Node): boolean {\n  // https://github.com/facebook/react/blob/848bb2426e44606e0a55dfe44c7b3ece33772485/packages/react-dom/src/client/ReactDOMHostConfig.js#L157-L166\n  const isAutoFocusableElement =\n    node.nodeName === 'BUTTON' ||\n    node.nodeName === 'INPUT' ||\n    node.nodeName === 'SELECT' ||\n    node.nodeName === 'TEXTAREA';\n\n  if (isAutoFocusableElement) {\n    return !!getReactFiberFromNode(node)?.pendingProps.autoFocus;\n  }\n\n  return false;\n}\n\nexport function hasAutofocusFilter(node: Node) {\n  return hasAutofocusProp(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n}\n"],"names":["hasAutofocusFilter","hasAutofocusProp","node","isAutoFocusableElement","nodeName","getReactFiberFromNode","pendingProps","autoFocus","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,EAAE;AACF,uDAAuD;AACvD,EAAE;;;;;+BAyBcA;;;eAAAA;;;uCAvBsB;AAEtC;;;;;CAKC,GACD,SAASC,iBAAiBC,IAAU;IAClC,gJAAgJ;IAChJ,MAAMC,yBACJD,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK,WAClBF,KAAKE,QAAQ,KAAK,YAClBF,KAAKE,QAAQ,KAAK;IAEpB,IAAID,wBAAwB;YACjBE;QAAT,OAAO,CAAC,CAAA,CAAA,AAACA,CAAAA,0BAAAA,IAAAA,4CAAAA,EAAsBH,KAAAA,MAAAA,QAAtBG,4BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,wBAA6BC,YAAY,CAACC,SAAS,AAATA;IACrD;IAEA,OAAO;AACT;AAEO,SAASP,mBAAmBE,IAAU;IAC3C,OAAOD,iBAAiBC,QAAQM,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACnF"}