feat: Fluent UI Outlook Lite + connections mockup

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/coverTarget.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "coverTarget", {
+    enumerable: true,
+    get: function() {
+        return coverTarget;
+    }
+});
+const _index = require("../utils/index");
+function coverTarget() {
+    return {
+        name: 'coverTarget',
+        fn: (middlewareArguments)=>{
+            const { placement, rects, x, y } = middlewareArguments;
+            const basePlacement = (0, _index.parseFloatingUIPlacement)(placement).side;
+            const newCoords = {
+                x,
+                y
+            };
+            switch(basePlacement){
+                case 'bottom':
+                    newCoords.y -= rects.reference.height;
+                    break;
+                case 'top':
+                    newCoords.y += rects.reference.height;
+                    break;
+                case 'left':
+                    newCoords.x += rects.reference.width;
+                    break;
+                case 'right':
+                    newCoords.x -= rects.reference.width;
+                    break;
+            }
+            return newCoords;
+        }
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/coverTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/coverTarget.ts"],"sourcesContent":["import type { Middleware } from '@floating-ui/dom';\nimport { parseFloatingUIPlacement } from '../utils/index';\n\nexport function coverTarget(): Middleware {\n  return {\n    name: 'coverTarget',\n    fn: middlewareArguments => {\n      const { placement, rects, x, y } = middlewareArguments;\n      const basePlacement = parseFloatingUIPlacement(placement).side;\n      const newCoords = { x, y };\n\n      switch (basePlacement) {\n        case 'bottom':\n          newCoords.y -= rects.reference.height;\n          break;\n        case 'top':\n          newCoords.y += rects.reference.height;\n          break;\n        case 'left':\n          newCoords.x += rects.reference.width;\n          break;\n        case 'right':\n          newCoords.x -= rects.reference.width;\n          break;\n      }\n\n      return newCoords;\n    },\n  };\n}\n"],"names":["parseFloatingUIPlacement","coverTarget","name","fn","middlewareArguments","placement","rects","x","y","basePlacement","side","newCoords","reference","height","width"],"mappings":";;;;+BAGgBC;;;;;;uBAFyB,iBAAiB;AAEnD;IACL,OAAO;QACLC,MAAM;QACNC,IAAIC,CAAAA;YACF,MAAM,EAAEC,SAAS,EAAEC,KAAK,EAAEC,CAAC,EAAEC,CAAC,EAAE,GAAGJ;YACnC,MAAMK,gBAAgBT,mCAAAA,EAAyBK,WAAWK,IAAI;YAC9D,MAAMC,YAAY;gBAAEJ;gBAAGC;YAAE;YAEzB,OAAQC;gBACN,KAAK;oBACHE,UAAUH,CAAC,IAAIF,MAAMM,SAAS,CAACC,MAAM;oBACrC;gBACF,KAAK;oBACHF,UAAUH,CAAC,IAAIF,MAAMM,SAAS,CAACC,MAAM;oBACrC;gBACF,KAAK;oBACHF,UAAUJ,CAAC,IAAID,MAAMM,SAAS,CAACE,KAAK;oBACpC;gBACF,KAAK;oBACHH,UAAUJ,CAAC,IAAID,MAAMM,SAAS,CAACE,KAAK;oBACpC;YACJ;YAEA,OAAOH;QACT;IACF;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/flip.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "flip", {
+    enumerable: true,
+    get: function() {
+        return flip;
+    }
+});
+const _dom = require("@floating-ui/dom");
+const _index = require("../utils/index");
+function flip(options) {
+    const { hasScrollableElement, flipBoundary, container, fallbackPositions = [], isRtl } = options;
+    const fallbackPlacements = fallbackPositions.reduce((acc, shorthand)=>{
+        const { position, align } = (0, _index.resolvePositioningShorthand)(shorthand);
+        const placement = (0, _index.toFloatingUIPlacement)(align, position, isRtl);
+        if (placement) {
+            acc.push(placement);
+        }
+        return acc;
+    }, []);
+    return (0, _dom.flip)({
+        ...hasScrollableElement && {
+            boundary: 'clippingAncestors'
+        },
+        ...flipBoundary && {
+            altBoundary: true,
+            boundary: (0, _index.getBoundary)(container, flipBoundary)
+        },
+        fallbackStrategy: 'bestFit',
+        ...fallbackPlacements.length && {
+            fallbackPlacements
+        }
+    });
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/flip.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/flip.ts"],"sourcesContent":["import { flip as baseFlip, Placement, Middleware } 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): Middleware {\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","baseFlip","getBoundary","resolvePositioningShorthand","toFloatingUIPlacement","options","hasScrollableElement","flipBoundary","container","fallbackPositions","isRtl","fallbackPlacements","reduce","acc","shorthand","position","align","placement","push","boundary","altBoundary","fallbackStrategy","length"],"mappings":";;;;+BAUgBA;;;;;;qBAVwC,mBAAmB;uBAEK,iBAAiB;AAQ1F,cAAcK,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,OAAGb,kCAAAA,EAA4BW;QACxD,MAAMG,gBAAYb,4BAAAA,EAAsBY,OAAOD,UAAUL;QACzD,IAAIO,WAAW;YACbJ,IAAIK,IAAI,CAACD;QACX;QACA,OAAOJ;IACT,GAAG,EAAE;IAEL,WAAOZ,SAAAA,EAAS;QACd,GAAIK,wBAAwB;YAAEa,UAAU;QAAoB,CAAC;QAC7D,GAAIZ,gBAAgB;YAAEa,aAAa;YAAMD,cAAUjB,kBAAAA,EAAYM,WAAWD;QAAc,CAAC;QACzFc,kBAAkB;QAClB,GAAIV,mBAAmBW,MAAM,IAAI;YAAEX;QAAmB,CAAC;IACzD;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    coverTarget: function() {
+        return _coverTarget.coverTarget;
+    },
+    flip: function() {
+        return _flip.flip;
+    },
+    intersecting: function() {
+        return _intersecting.intersecting;
+    },
+    matchTargetSize: function() {
+        return _matchTargetSize.matchTargetSize;
+    },
+    matchTargetSizeCssVar: function() {
+        return _matchTargetSize.matchTargetSizeCssVar;
+    },
+    maxSize: function() {
+        return _maxSize.maxSize;
+    },
+    offset: function() {
+        return _offset.offset;
+    },
+    resetMaxSize: function() {
+        return _maxSize.resetMaxSize;
+    },
+    shift: function() {
+        return _shift.shift;
+    }
+});
+const _coverTarget = require("./coverTarget");
+const _flip = require("./flip");
+const _intersecting = require("./intersecting");
+const _maxSize = require("./maxSize");
+const _offset = require("./offset");
+const _shift = require("./shift");
+const _matchTargetSize = require("./matchTargetSize");

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/index.ts"],"sourcesContent":["export { coverTarget } from './coverTarget';\nexport type { FlipMiddlewareOptions } from './flip';\nexport { flip } from './flip';\nexport { intersecting } from './intersecting';\nexport type { MaxSizeMiddlewareOptions } from './maxSize';\nexport { maxSize, resetMaxSize } from './maxSize';\nexport { offset } from './offset';\nexport type { ShiftMiddlewareOptions } from './shift';\nexport { shift } from './shift';\nexport { matchTargetSize, matchTargetSizeCssVar } from './matchTargetSize';\n"],"names":["coverTarget","flip","intersecting","maxSize","resetMaxSize","offset","shift","matchTargetSize","matchTargetSizeCssVar"],"mappings":";;;;;;;;;;;IAASA;uCAAW;;;eAEXC,UAAI;;;eACJC,0BAAY;;;eAMZK,gCAAe;;;eAAEC,sCAAqB;;;eAJtCL,gBAAO;;;eACPE,cAAM;;;eADGD,qBAAY;;;eAGrBE,YAAK;;;6BARc,gBAAgB;sBAEvB,SAAS;8BACD,iBAAiB;yBAER,YAAY;wBAC3B,WAAW;uBAEZ,UAAU;iCACuB,oBAAoB"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/intersecting.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "intersecting", {
+    enumerable: true,
+    get: function() {
+        return intersecting;
+    }
+});
+const _dom = require("@floating-ui/dom");
+function intersecting() {
+    return {
+        name: 'intersectionObserver',
+        fn: async (middlewareArguments)=>{
+            const floatingRect = middlewareArguments.rects.floating;
+            const altOverflow = await (0, _dom.detectOverflow)(middlewareArguments, {
+                altBoundary: true
+            });
+            const isIntersectingTop = altOverflow.top < floatingRect.height && altOverflow.top > 0;
+            const isIntersectingBottom = altOverflow.bottom < floatingRect.height && altOverflow.bottom > 0;
+            const isIntersecting = isIntersectingTop || isIntersectingBottom;
+            return {
+                data: {
+                    intersecting: isIntersecting
+                }
+            };
+        }
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/intersecting.js.map

@@ -0,0 +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":["detectOverflow","intersecting","name","fn","middlewareArguments","floatingRect","rects","floating","altOverflow","altBoundary","isIntersectingTop","top","height","isIntersectingBottom","bottom","isIntersecting","data"],"mappings":";;;;+BAGgBC;;;;;;qBAFe,mBAAmB;AAE3C;IACL,OAAO;QACLC,MAAM;QACNC,IAAI,OAAMC;YACR,MAAMC,eAAeD,oBAAoBE,KAAK,CAACC,QAAQ;YACvD,MAAMC,cAAc,UAAMR,mBAAAA,EAAeI,qBAAqB;gBAAEK,aAAa;YAAK;YAElF,MAAMC,oBAAoBF,YAAYG,GAAG,GAAGN,aAAaO,MAAM,IAAIJ,YAAYG,GAAG,GAAG;YACrF,MAAME,uBAAuBL,YAAYM,MAAM,GAAGT,aAAaO,MAAM,IAAIJ,YAAYM,MAAM,GAAG;YAE9F,MAAMC,iBAAiBL,qBAAqBG;YAE5C,OAAO;gBACLG,MAAM;oBACJf,cAAcc;gBAChB;YACF;QACF;IACF;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/matchTargetSize.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    matchTargetSize: function() {
+        return matchTargetSize;
+    },
+    matchTargetSizeCssVar: function() {
+        return matchTargetSizeCssVar;
+    }
+});
+const matchTargetSizeCssVar = '--fui-match-target-size';
+function matchTargetSize() {
+    return {
+        name: 'matchTargetSize',
+        fn: async (middlewareArguments)=>{
+            const { rects: { reference: referenceRect, floating: floatingRect }, elements: { floating: floatingElement }, middlewareData: { matchTargetSize: { matchTargetSizeAttempt = false } = {} } } = middlewareArguments;
+            if (referenceRect.width === floatingRect.width || matchTargetSizeAttempt) {
+                return {};
+            }
+            const { width } = referenceRect;
+            floatingElement.style.setProperty(matchTargetSizeCssVar, `${width}px`);
+            if (!floatingElement.style.width) {
+                floatingElement.style.width = `var(${matchTargetSizeCssVar})`;
+            }
+            return {
+                data: {
+                    matchTargetSizeAttempt: true
+                },
+                reset: {
+                    rects: true
+                }
+            };
+        }
+    };
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/matchTargetSize.js.map

@@ -0,0 +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":["matchTargetSizeCssVar","matchTargetSize","name","fn","middlewareArguments","rects","reference","referenceRect","floating","floatingRect","elements","floatingElement","middlewareData","matchTargetSizeAttempt","width","style","setProperty","data","reset"],"mappings":";;;;;;;;;;;IAIgBC,eAAAA;;;yBAFHD;;;;AAAN,MAAMA,wBAAwB,0BAA0B;AAExD;IACL,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,EAAEX,iBAAiB,EAAEY,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,CAAChB,uBAAuB,GAAGc,MAAM,EAAE,CAAC;YACrE,IAAI,CAACH,gBAAgBI,KAAK,CAACD,KAAK,EAAE;gBAChCH,gBAAgBI,KAAK,CAACD,KAAK,GAAG,CAAC,IAAI,EAAEd,sBAAsB,CAAC,CAAC;YAC/D;YAEA,OAAO;gBACLiB,MAAM;oBAAEJ,wBAAwB;gBAAK;gBACrCK,OAAO;oBACLb,OAAO;gBACT;YACF;QACF;IACF;AACF"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/maxSize.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    maxSize: function() {
+        return maxSize;
+    },
+    resetMaxSize: function() {
+        return resetMaxSize;
+    }
+});
+const _dom = require("@floating-ui/dom");
+const _getBoundary = require("../utils/getBoundary");
+const _utils = require("../utils");
+const resetMaxSize = (autoSize)=>({
+        name: 'resetMaxSize',
+        fn ({ middlewareData, elements }) {
+            var _middlewareData_resetMaxSize;
+            if ((_middlewareData_resetMaxSize = middlewareData.resetMaxSize) === null || _middlewareData_resetMaxSize === void 0 ? void 0 : _middlewareData_resetMaxSize.maxSizeAlreadyReset) {
+                return {};
+            }
+            const { applyMaxWidth, applyMaxHeight } = autoSize;
+            if (applyMaxWidth) {
+                elements.floating.style.removeProperty('box-sizing');
+                elements.floating.style.removeProperty('max-width');
+                elements.floating.style.removeProperty('width');
+            }
+            if (applyMaxHeight) {
+                elements.floating.style.removeProperty('box-sizing');
+                elements.floating.style.removeProperty('max-height');
+                elements.floating.style.removeProperty('height');
+            }
+            return {
+                data: {
+                    maxSizeAlreadyReset: true
+                },
+                reset: {
+                    rects: true
+                }
+            };
+        }
+    });
+function maxSize(autoSize, options) {
+    const { container, overflowBoundary, overflowBoundaryPadding, isRtl } = options;
+    return (0, _dom.size)({
+        ...overflowBoundaryPadding && {
+            padding: (0, _utils.toFloatingUIPadding)(overflowBoundaryPadding, isRtl)
+        },
+        ...overflowBoundary && {
+            altBoundary: true,
+            boundary: (0, _getBoundary.getBoundary)(container, overflowBoundary)
+        },
+        apply ({ availableHeight, availableWidth, elements, rects }) {
+            const applyMaxSizeStyles = (apply, dimension, availableSize)=>{
+                if (!apply) {
+                    return;
+                }
+                elements.floating.style.setProperty('box-sizing', 'border-box');
+                elements.floating.style.setProperty(`max-${dimension}`, `${availableSize}px`);
+                if (rects.floating[dimension] > availableSize) {
+                    elements.floating.style.setProperty(dimension, `${availableSize}px`);
+                    const axis = dimension === 'width' ? 'x' : 'y';
+                    if (!elements.floating.style.getPropertyValue(`overflow-${axis}`)) {
+                        elements.floating.style.setProperty(`overflow-${axis}`, 'auto');
+                    }
+                }
+            };
+            const { applyMaxWidth, applyMaxHeight } = autoSize;
+            applyMaxSizeStyles(applyMaxWidth, 'width', availableWidth);
+            applyMaxSizeStyles(applyMaxHeight, 'height', availableHeight);
+        }
+    });
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/offset.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "offset", {
+    enumerable: true,
+    get: function() {
+        return offset;
+    }
+});
+const _dom = require("@floating-ui/dom");
+const _getFloatingUIOffset = require("../utils/getFloatingUIOffset");
+function offset(offsetValue) {
+    const floatingUIOffset = (0, _getFloatingUIOffset.getFloatingUIOffset)(offsetValue);
+    return (0, _dom.offset)(floatingUIOffset);
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/offset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/offset.ts"],"sourcesContent":["import { offset as baseOffset, Middleware } 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']): Middleware {\n  const floatingUIOffset = getFloatingUIOffset(offsetValue);\n  return baseOffset(floatingUIOffset);\n}\n"],"names":["offset","baseOffset","getFloatingUIOffset","offsetValue","floatingUIOffset"],"mappings":";;;;;;;;;;qBAAiD,mBAAmB;qCAEhC,+BAA+B;AAK5D,SAASA,OAAOG,WAAyC;IAC9D,MAAMC,uBAAmBF,wCAAAA,EAAoBC;IAC7C,WAAOF,WAAAA,EAAWG;AACpB"}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/shift.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "shift", {
+    enumerable: true,
+    get: function() {
+        return shift;
+    }
+});
+const _dom = require("@floating-ui/dom");
+const _index = require("../utils/index");
+function shift(options) {
+    const { hasScrollableElement, shiftToCoverTarget, disableTether, overflowBoundary, container, overflowBoundaryPadding, isRtl } = options;
+    return (0, _dom.shift)({
+        ...hasScrollableElement && {
+            boundary: 'clippingAncestors'
+        },
+        ...shiftToCoverTarget && {
+            crossAxis: true,
+            limiter: (0, _dom.limitShift)({
+                crossAxis: true,
+                mainAxis: false
+            })
+        },
+        ...disableTether && {
+            crossAxis: disableTether === 'all',
+            limiter: (0, _dom.limitShift)({
+                crossAxis: disableTether !== 'all',
+                mainAxis: false
+            })
+        },
+        ...overflowBoundaryPadding && {
+            padding: (0, _index.toFloatingUIPadding)(overflowBoundaryPadding, isRtl)
+        },
+        ...overflowBoundary && {
+            altBoundary: true,
+            boundary: (0, _index.getBoundary)(container, overflowBoundary)
+        }
+    });
+}

node_modules/@fluentui/react-positioning/lib-commonjs/middleware/shift.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/middleware/shift.ts"],"sourcesContent":["import { shift as baseShift, limitShift, Middleware } 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): Middleware {\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","baseShift","limitShift","getBoundary","toFloatingUIPadding","options","hasScrollableElement","shiftToCoverTarget","disableTether","overflowBoundary","container","overflowBoundaryPadding","isRtl","boundary","crossAxis","limiter","mainAxis","padding","altBoundary"],"mappings":";;;;+BAegBA;;;;;;qBAf2C,mBAAmB;uBAE7B,iBAAiB;AAa3D,eAAeK,OAA+B;IACnD,MAAM,EACJC,oBAAoB,EACpBC,kBAAkB,EAClBC,aAAa,EACbC,gBAAgB,EAChBC,SAAS,EACTC,uBAAuB,EACvBC,KAAK,EACN,GAAGP;IAEJ,WAAOJ,UAAAA,EAAU;QACf,GAAIK,wBAAwB;YAAEO,UAAU;QAAoB,CAAC;QAC7D,GAAIN,sBAAsB;YACxBO,WAAW;YACXC,aAASb,eAAAA,EAAW;gBAAEY,WAAW;gBAAME,UAAU;YAAM;QACzD,CAAC;QACD,GAAIR,iBAAiB;YACnBM,WAAWN,kBAAkB;YAC7BO,aAASb,eAAAA,EAAW;gBAAEY,WAAWN,kBAAkB;gBAAOQ,UAAU;YAAM;QAC5E,CAAC;QACD,GAAIL,2BAA2B;YAAEM,aAASb,0BAAAA,EAAoBO,yBAAyBC;QAAO,CAAC;QAC/F,GAAIH,oBAAoB;YAAES,aAAa;YAAML,cAAUV,kBAAAA,EAAYO,WAAWD;QAAkB,CAAC;IACnG;AACF"}