{"version":3,"file":"TooltipHost.50def425.js","sources":["../../../node_modules/@fluentui/utilities/lib/overflow.js","../../../node_modules/@fluentui/react/lib/components/ResizeGroup/ResizeGroup.types.js","../../../node_modules/@fluentui/react/lib/components/ResizeGroup/ResizeGroup.base.js","../../../node_modules/@fluentui/react/lib/components/ResizeGroup/ResizeGroup.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/Tooltip.base.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/Tooltip.styles.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/Tooltip.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/Tooltip.types.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/TooltipHost.types.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/TooltipHost.base.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/TooltipHost.styles.js","../../../node_modules/@fluentui/react/lib/components/Tooltip/TooltipHost.js"],"sourcesContent":["/**\n * Detects whether an element's content has horizontal overflow\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasHorizontalOverflow(element) {\n    return element.clientWidth < element.scrollWidth;\n}\n/**\n * Detects whether an element's content has vertical overflow\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasVerticalOverflow(element) {\n    return element.clientHeight < element.scrollHeight;\n}\n/**\n * Detects whether an element's content has overflow in any direction\n *\n * @public\n * @param element - Element to check for overflow\n * @returns True if element's content overflows\n */\nexport function hasOverflow(element) {\n    return hasHorizontalOverflow(element) || hasVerticalOverflow(element);\n}\n//# sourceMappingURL=overflow.js.map","/**\n * {@docCategory ResizeGroup}\n */\nexport var ResizeGroupDirection;\n(function (ResizeGroupDirection) {\n    ResizeGroupDirection[ResizeGroupDirection[\"horizontal\"] = 0] = \"horizontal\";\n    ResizeGroupDirection[ResizeGroupDirection[\"vertical\"] = 1] = \"vertical\";\n})(ResizeGroupDirection || (ResizeGroupDirection = {}));\n//# sourceMappingURL=ResizeGroup.types.js.map","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { divProperties, getNativeProps } from '../../Utilities';\nimport { ResizeGroupDirection } from './ResizeGroup.types';\nimport { useConst, useMergedRefs, useAsync, useOnEvent, useWarnings } from '@fluentui/react-hooks';\nimport { useWindow } from '../../WindowProvider';\nvar RESIZE_DELAY = 16;\n/**\n * Returns a simple object is able to store measurements with a given key.\n */\nexport var getMeasurementCache = function () {\n    var measurementsCache = {};\n    return {\n        /**\n         * Checks if the provided data has a cacheKey. If it has a cacheKey and there is a\n         * corresponding entry in the measurementsCache, then it will return that value.\n         * Returns undefined otherwise.\n         */\n        getCachedMeasurement: function (data) {\n            if (data && data.cacheKey && measurementsCache.hasOwnProperty(data.cacheKey)) {\n                return measurementsCache[data.cacheKey];\n            }\n            return undefined;\n        },\n        /**\n         * Should be called whenever there is a new measurement associated with a given data object.\n         * If the data has a cacheKey, store that measurement in the measurementsCache.\n         */\n        addMeasurementToCache: function (data, measurement) {\n            if (data.cacheKey) {\n                measurementsCache[data.cacheKey] = measurement;\n            }\n        },\n    };\n};\n/**\n * Returns a function that is able to compute the next state for the ResizeGroup given the current\n * state and any measurement updates.\n */\nexport var getNextResizeGroupStateProvider = function (measurementCache) {\n    if (measurementCache === void 0) { measurementCache = getMeasurementCache(); }\n    var _measurementCache = measurementCache;\n    var _containerDimension;\n    /**\n     * Gets the width/height of the data rendered in a hidden div.\n     * @param measuredData - The data corresponding to the measurement we wish to take.\n     * @param getElementToMeasureDimension - A function that returns the measurement of the rendered data.\n     * Only called when the measurement is not in the cache.\n     */\n    function _getMeasuredDimension(measuredData, getElementToMeasureDimension) {\n        var cachedDimension = _measurementCache.getCachedMeasurement(measuredData);\n        if (cachedDimension !== undefined) {\n            return cachedDimension;\n        }\n        var measuredDimension = getElementToMeasureDimension();\n        _measurementCache.addMeasurementToCache(measuredData, measuredDimension);\n        return measuredDimension;\n    }\n    /**\n     * Will get the next IResizeGroupState based on the current data while trying to shrink contents\n     * to fit in the container.\n     * @param data - The initial data point to start measuring.\n     * @param onReduceData - Function that transforms the data into something that should render with less width/height.\n     * @param getElementToMeasureDimension - A function that returns the measurement of the rendered data.\n     * Only called when the measurement is not in the cache.\n     */\n    function _shrinkContentsUntilTheyFit(data, onReduceData, getElementToMeasureDimension) {\n        var dataToMeasure = data;\n        var measuredDimension = _getMeasuredDimension(data, getElementToMeasureDimension);\n        while (measuredDimension > _containerDimension) {\n            var nextMeasuredData = onReduceData(dataToMeasure);\n            // We don't want to get stuck in an infinite render loop when there are no more\n            // scaling steps, so implementations of onReduceData should return undefined when\n            // there are no more scaling states to apply.\n            if (nextMeasuredData === undefined) {\n                return {\n                    renderedData: dataToMeasure,\n                    resizeDirection: undefined,\n                    dataToMeasure: undefined,\n                };\n            }\n            measuredDimension = _measurementCache.getCachedMeasurement(nextMeasuredData);\n            // If the measurement isn't in the cache, we need to re-render with some data in a hidden div\n            if (measuredDimension === undefined) {\n                return {\n                    dataToMeasure: nextMeasuredData,\n                    resizeDirection: 'shrink',\n                };\n            }\n            dataToMeasure = nextMeasuredData;\n        }\n        return {\n            renderedData: dataToMeasure,\n            resizeDirection: undefined,\n            dataToMeasure: undefined,\n        };\n    }\n    /**\n     * This function should be called when the state changes in a manner that might allow for more content to fit\n     * on the screen, such as the window width/height growing.\n     * @param data - The initial data point to start measuring.\n     * @param onGrowData - Function that transforms the data into something that may take up more space when rendering.\n     * @param getElementToMeasureDimension - A function that returns the measurement of the rendered data.\n     * Only called when the measurement is not in the cache.\n     */\n    function _growDataUntilItDoesNotFit(data, onGrowData, getElementToMeasureDimension, onReduceData) {\n        var dataToMeasure = data;\n        var measuredDimension = _getMeasuredDimension(data, getElementToMeasureDimension);\n        while (measuredDimension < _containerDimension) {\n            var nextMeasuredData = onGrowData(dataToMeasure);\n            // We don't want to get stuck in an infinite render loop when there are no more\n            // scaling steps, so implementations of onGrowData should return undefined when\n            // there are no more scaling states to apply.\n            if (nextMeasuredData === undefined) {\n                return {\n                    renderedData: dataToMeasure,\n                    resizeDirection: undefined,\n                    dataToMeasure: undefined,\n                };\n            }\n            measuredDimension = _measurementCache.getCachedMeasurement(nextMeasuredData);\n            // If the measurement isn't in the cache, we need to re-render with some data in a hidden div\n            if (measuredDimension === undefined) {\n                return {\n                    dataToMeasure: nextMeasuredData,\n                };\n            }\n            dataToMeasure = nextMeasuredData;\n        }\n        // Once the loop is done, we should now shrink until the contents fit.\n        return __assign({ resizeDirection: 'shrink' }, _shrinkContentsUntilTheyFit(dataToMeasure, onReduceData, getElementToMeasureDimension));\n    }\n    /**\n     * Handles an update to the container width/height.\n     * Should only be called when we knew the previous container width/height.\n     * @param newDimension - The new width/height of the container.\n     * @param fullDimensionData - The initial data passed in as a prop to resizeGroup.\n     * @param renderedData - The data that was rendered prior to the container size changing.\n     * @param onGrowData - Set to true if the Resize group has an onGrowData function.\n     */\n    function _updateContainerDimension(newDimension, fullDimensionData, renderedData, onGrowData) {\n        var nextState;\n        if (newDimension > _containerDimension) {\n            if (onGrowData) {\n                nextState = {\n                    resizeDirection: 'grow',\n                    dataToMeasure: onGrowData(renderedData),\n                };\n            }\n            else {\n                nextState = {\n                    resizeDirection: 'shrink',\n                    dataToMeasure: fullDimensionData,\n                };\n            }\n        }\n        else {\n            nextState = {\n                resizeDirection: 'shrink',\n                dataToMeasure: renderedData,\n            };\n        }\n        _containerDimension = newDimension;\n        return __assign(__assign({}, nextState), { measureContainer: false });\n    }\n    function getNextState(props, currentState, getElementToMeasureDimension, newContainerDimension) {\n        // If there is no new container width/height or data to measure, there is no need for a new state update\n        if (newContainerDimension === undefined && currentState.dataToMeasure === undefined) {\n            return undefined;\n        }\n        if (newContainerDimension) {\n            // If we know the last container size and we rendered data at that width/height, we can do an optimized render\n            if (_containerDimension && currentState.renderedData && !currentState.dataToMeasure) {\n                return __assign(__assign({}, currentState), _updateContainerDimension(newContainerDimension, props.data, currentState.renderedData, props.onGrowData));\n            }\n            // If we are just setting the container width/height for the first time, we can't do any optimizations\n            _containerDimension = newContainerDimension;\n        }\n        var nextState = __assign(__assign({}, currentState), { measureContainer: false });\n        if (currentState.dataToMeasure) {\n            if (currentState.resizeDirection === 'grow' && props.onGrowData) {\n                nextState = __assign(__assign({}, nextState), _growDataUntilItDoesNotFit(currentState.dataToMeasure, props.onGrowData, getElementToMeasureDimension, props.onReduceData));\n            }\n            else {\n                nextState = __assign(__assign({}, nextState), _shrinkContentsUntilTheyFit(currentState.dataToMeasure, props.onReduceData, getElementToMeasureDimension));\n            }\n        }\n        return nextState;\n    }\n    /** Function that determines if we need to render content for measurement based on the measurement cache contents. */\n    function shouldRenderDataForMeasurement(dataToMeasure) {\n        if (!dataToMeasure || _measurementCache.getCachedMeasurement(dataToMeasure) !== undefined) {\n            return false;\n        }\n        return true;\n    }\n    function getInitialResizeGroupState(data) {\n        return {\n            dataToMeasure: __assign({}, data),\n            resizeDirection: 'grow',\n            measureContainer: true,\n        };\n    }\n    return {\n        getNextState: getNextState,\n        shouldRenderDataForMeasurement: shouldRenderDataForMeasurement,\n        getInitialResizeGroupState: getInitialResizeGroupState,\n    };\n};\n// Provides a context property that (if true) tells any child components that\n// they are only being used for measurement purposes and will not be visible.\nexport var MeasuredContext = React.createContext({ isMeasured: false });\n// Styles for the hidden div used for measurement\nvar hiddenDivStyles = { position: 'fixed', visibility: 'hidden' };\nvar hiddenParentStyles = { position: 'relative' };\nvar COMPONENT_NAME = 'ResizeGroup';\n/**\n * Use useReducer instead of userState because React is not batching the state updates\n * when state is set in callbacks of setTimeout or requestAnimationFrame.\n * See issue: https://github.com/facebook/react/issues/14259\n */\nfunction resizeDataReducer(state, action) {\n    var _a;\n    switch (action.type) {\n        case 'resizeData':\n            return __assign({}, action.value);\n        case 'dataToMeasure':\n            return __assign(__assign({}, state), { dataToMeasure: action.value, resizeDirection: 'grow', measureContainer: true });\n        default:\n            return __assign(__assign({}, state), (_a = {}, _a[action.type] = action.value, _a));\n    }\n}\nfunction useResizeState(props, nextResizeGroupStateProvider, rootRef) {\n    var initialStateData = useConst(function () { return nextResizeGroupStateProvider.getInitialResizeGroupState(props.data); });\n    var _a = React.useReducer(resizeDataReducer, initialStateData), resizeData = _a[0], dispatchResizeDataAction = _a[1];\n    // Reset state when new data is provided\n    React.useEffect(function () {\n        dispatchResizeDataAction({\n            type: 'dataToMeasure',\n            value: props.data,\n        });\n    }, [props.data]);\n    // Because it's possible that we may force more than one re-render per animation frame, we\n    // want to make sure that the RAF request is using the most recent data.\n    var stateRef = React.useRef(initialStateData);\n    stateRef.current = __assign({}, resizeData);\n    var updateResizeState = React.useCallback(function (nextState) {\n        if (nextState) {\n            dispatchResizeDataAction({\n                type: 'resizeData',\n                value: nextState,\n            });\n        }\n    }, []);\n    var remeasure = React.useCallback(function () {\n        if (rootRef.current) {\n            dispatchResizeDataAction({\n                type: 'measureContainer',\n                value: true,\n            });\n        }\n    }, [rootRef]);\n    return [stateRef, updateResizeState, remeasure];\n}\nfunction useResizingBehavior(props, rootRef) {\n    var nextResizeGroupStateProvider = useConst(getNextResizeGroupStateProvider);\n    // A div that can be used for the initial measurement so that we can avoid mounting a second instance\n    // of the component being measured for the initial render.\n    var initialHiddenDiv = React.useRef(null);\n    // A hidden div that is used for mounting a new instance of the component for measurement in a hidden\n    // div without unmounting the currently visible content.\n    var updateHiddenDiv = React.useRef(null);\n    // Tracks if any content has been rendered to the user. This enables us to do some performance optimizations\n    // for the initial render.\n    var hasRenderedContent = React.useRef(false);\n    var async = useAsync();\n    var _a = useResizeState(props, nextResizeGroupStateProvider, rootRef), stateRef = _a[0], updateResizeState = _a[1], remeasure = _a[2];\n    React.useEffect(function () {\n        var _a;\n        if (stateRef.current.renderedData) {\n            hasRenderedContent.current = true;\n            (_a = props.dataDidRender) === null || _a === void 0 ? void 0 : _a.call(props, stateRef.current.renderedData);\n        }\n    });\n    React.useEffect(function () {\n        async.requestAnimationFrame(function () {\n            var containerDimension = undefined;\n            if (stateRef.current.measureContainer && rootRef.current) {\n                var boundingRect = rootRef.current.getBoundingClientRect();\n                containerDimension =\n                    props.direction === ResizeGroupDirection.vertical ? boundingRect.height : boundingRect.width;\n            }\n            var nextState = nextResizeGroupStateProvider.getNextState(props, stateRef.current, function () {\n                var refToMeasure = !hasRenderedContent.current ? initialHiddenDiv : updateHiddenDiv;\n                if (!refToMeasure.current) {\n                    return 0;\n                }\n                var measuredBoundingRect = refToMeasure.current.getBoundingClientRect();\n                return props.direction === ResizeGroupDirection.vertical\n                    ? measuredBoundingRect.height\n                    : measuredBoundingRect.width;\n            }, containerDimension);\n            updateResizeState(nextState);\n        }, rootRef.current);\n    });\n    var win = useWindow();\n    useOnEvent(win, 'resize', async.debounce(remeasure, RESIZE_DELAY, { leading: true }));\n    var dataNeedsMeasuring = nextResizeGroupStateProvider.shouldRenderDataForMeasurement(stateRef.current.dataToMeasure);\n    var isInitialMeasure = !hasRenderedContent.current && dataNeedsMeasuring;\n    return [\n        stateRef.current.dataToMeasure,\n        stateRef.current.renderedData,\n        remeasure,\n        initialHiddenDiv,\n        updateHiddenDiv,\n        dataNeedsMeasuring,\n        isInitialMeasure,\n    ];\n}\nfunction useDebugWarnings(props) {\n    if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line react-hooks/rules-of-hooks -- build-time conditional\n        useWarnings({\n            name: COMPONENT_NAME,\n            props: props,\n            deprecations: { styles: 'className' },\n        });\n    }\n}\nvar measuredContextValue = { isMeasured: true };\nexport var ResizeGroupBase = React.forwardRef(function (props, forwardedRef) {\n    var rootRef = React.useRef(null);\n    // The root div which is the container inside of which we are trying to fit content.\n    var mergedRootRef = useMergedRefs(rootRef, forwardedRef);\n    var _a = useResizingBehavior(props, rootRef), dataToMeasure = _a[0], renderedData = _a[1], remeasure = _a[2], initialHiddenDiv = _a[3], updateHiddenDiv = _a[4], dataNeedsMeasuring = _a[5], isInitialMeasure = _a[6];\n    React.useImperativeHandle(props.componentRef, function () { return ({ remeasure: remeasure }); }, [remeasure]);\n    useDebugWarnings(props);\n    var className = props.className, onRenderData = props.onRenderData;\n    var divProps = getNativeProps(props, divProperties, ['data']);\n    // We only ever render the final content to the user. All measurements are done in a hidden div.\n    // For the initial render, we want this to be as fast as possible, so we need to make sure that we only mount one\n    // version of the component for measurement and the final render. For renders that update what is on screen, we\n    // want to make sure that there are no jarring effects such as the screen flashing as we apply scaling steps for\n    // measurement. In the update case, we mount a second version of the component just for measurement purposes and\n    // leave the rendered content untouched until we know the next state to show to the user.\n    return (React.createElement(\"div\", __assign({}, divProps, { className: className, ref: mergedRootRef }),\n        React.createElement(\"div\", { style: hiddenParentStyles },\n            dataNeedsMeasuring && !isInitialMeasure && (React.createElement(\"div\", { style: hiddenDivStyles, ref: updateHiddenDiv },\n                React.createElement(MeasuredContext.Provider, { value: measuredContextValue }, onRenderData(dataToMeasure)))),\n            React.createElement(\"div\", { ref: initialHiddenDiv, style: isInitialMeasure ? hiddenDivStyles : undefined, \"data-automation-id\": \"visibleContent\" }, isInitialMeasure ? onRenderData(dataToMeasure) : renderedData && onRenderData(renderedData)))));\n});\nResizeGroupBase.displayName = 'ResizeGroupBase';\n//# sourceMappingURL=ResizeGroup.base.js.map","import { ResizeGroupBase } from './ResizeGroup.base';\nexport var ResizeGroup = ResizeGroupBase;\n//# sourceMappingURL=ResizeGroup.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { classNamesFunction, divProperties, getNativeProps } from '../../Utilities';\nimport { Callout } from '../../Callout';\nimport { DirectionalHint } from '../../common/DirectionalHint';\nvar getClassNames = classNamesFunction();\nvar TooltipBase = /** @class */ (function (_super) {\n    __extends(TooltipBase, _super);\n    function TooltipBase() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this._onRenderContent = function (props) {\n            if (typeof props.content === 'string') {\n                return React.createElement(\"p\", { className: _this._classNames.subText }, props.content);\n            }\n            else {\n                return React.createElement(\"div\", { className: _this._classNames.subText }, props.content);\n            }\n        };\n        return _this;\n    }\n    TooltipBase.prototype.render = function () {\n        var _a = this.props, className = _a.className, calloutProps = _a.calloutProps, directionalHint = _a.directionalHint, directionalHintForRTL = _a.directionalHintForRTL, styles = _a.styles, id = _a.id, maxWidth = _a.maxWidth, _b = _a.onRenderContent, onRenderContent = _b === void 0 ? this._onRenderContent : _b, targetElement = _a.targetElement, theme = _a.theme;\n        this._classNames = getClassNames(styles, {\n            theme: theme,\n            className: className || (calloutProps && calloutProps.className),\n            beakWidth: calloutProps && calloutProps.isBeakVisible ? calloutProps.beakWidth : 0,\n            gapSpace: calloutProps && calloutProps.gapSpace,\n            maxWidth: maxWidth,\n        });\n        return (React.createElement(Callout, __assign({ target: targetElement, directionalHint: directionalHint, directionalHintForRTL: directionalHintForRTL }, calloutProps, getNativeProps(this.props, divProperties, ['id']), { className: this._classNames.root }),\n            React.createElement(\"div\", { className: this._classNames.content, id: id, onFocus: this.props.onFocus, onMouseEnter: this.props.onMouseEnter, onMouseLeave: this.props.onMouseLeave }, onRenderContent(this.props, this._onRenderContent))));\n    };\n    // Specify default props values\n    TooltipBase.defaultProps = {\n        directionalHint: DirectionalHint.topCenter,\n        maxWidth: '364px',\n        calloutProps: {\n            isBeakVisible: true,\n            beakWidth: 16,\n            gapSpace: 0,\n            setInitialFocus: true,\n            doNotLayer: false,\n        },\n    };\n    return TooltipBase;\n}(React.Component));\nexport { TooltipBase };\n//# sourceMappingURL=Tooltip.base.js.map","import { AnimationClassNames } from '../../Styling';\nexport var getStyles = function (props) {\n    var className = props.className, _a = props.beakWidth, beakWidth = _a === void 0 ? 16 : _a, _b = props.gapSpace, gapSpace = _b === void 0 ? 0 : _b, maxWidth = props.maxWidth, theme = props.theme;\n    var semanticColors = theme.semanticColors, fonts = theme.fonts, effects = theme.effects;\n    // The math here is done to account for the 45 degree rotation of the beak\n    // and sub-pixel rounding that differs across browsers, which is more noticeable when\n    // the device pixel ratio is larger\n    var tooltipGapSpace = -(Math.sqrt((beakWidth * beakWidth) / 2) + gapSpace) +\n        1 /\n            // There isn't really a great way to pass in a `window` reference here so disabling the line rule\n            // eslint-disable-next-line no-restricted-globals\n            window.devicePixelRatio;\n    return {\n        root: [\n            'ms-Tooltip',\n            theme.fonts.medium,\n            AnimationClassNames.fadeIn200,\n            {\n                background: semanticColors.menuBackground,\n                boxShadow: effects.elevation8,\n                padding: '8px',\n                maxWidth: maxWidth,\n                selectors: {\n                    ':after': {\n                        content: \"''\",\n                        position: 'absolute',\n                        bottom: tooltipGapSpace,\n                        left: tooltipGapSpace,\n                        right: tooltipGapSpace,\n                        top: tooltipGapSpace,\n                        zIndex: 0,\n                    },\n                },\n            },\n            className,\n        ],\n        content: [\n            'ms-Tooltip-content',\n            fonts.small,\n            {\n                position: 'relative',\n                zIndex: 1,\n                color: semanticColors.menuItemText,\n                wordWrap: 'break-word',\n                overflowWrap: 'break-word',\n                overflow: 'hidden',\n            },\n        ],\n        subText: [\n            'ms-Tooltip-subtext',\n            {\n                // Using inherit here to avoid unintentional global overrides of the <p> tag.\n                fontSize: 'inherit',\n                fontWeight: 'inherit',\n                color: 'inherit',\n                margin: 0,\n            },\n        ],\n    };\n};\n//# sourceMappingURL=Tooltip.styles.js.map","import { styled } from '../../Utilities';\nimport { TooltipBase } from './Tooltip.base';\nimport { getStyles } from './Tooltip.styles';\nexport var Tooltip = styled(TooltipBase, getStyles, undefined, {\n    scope: 'Tooltip',\n});\n//# sourceMappingURL=Tooltip.js.map","/**\n * {@docCategory Tooltip}\n */\nexport var TooltipDelay;\n(function (TooltipDelay) {\n    TooltipDelay[TooltipDelay[\"zero\"] = 0] = \"zero\";\n    /** 300 ms delay before showing the tooltip */\n    TooltipDelay[TooltipDelay[\"medium\"] = 1] = \"medium\";\n    /** 500 ms delay before showing the tooltip */\n    TooltipDelay[TooltipDelay[\"long\"] = 2] = \"long\";\n})(TooltipDelay || (TooltipDelay = {}));\n//# sourceMappingURL=Tooltip.types.js.map","/**\n * {@docCategory Tooltip}\n */\nexport var TooltipOverflowMode;\n(function (TooltipOverflowMode) {\n    /** Only show tooltip if parent DOM element is overflowing */\n    TooltipOverflowMode[TooltipOverflowMode[\"Parent\"] = 0] = \"Parent\";\n    /**\n     * Only show tooltip if tooltip host's content is overflowing.\n     * Note that this does not check the children for overflow, only the TooltipHost root.\n     */\n    TooltipOverflowMode[TooltipOverflowMode[\"Self\"] = 1] = \"Self\";\n})(TooltipOverflowMode || (TooltipOverflowMode = {}));\n//# sourceMappingURL=TooltipHost.types.js.map","import { __assign, __extends } from \"tslib\";\nimport * as React from 'react';\nimport { hiddenContentStyle } from '../../Styling';\nimport { initializeComponentRef, Async, divProperties, getNativeProps, getId, assign, hasOverflow, portalContainsElement, classNamesFunction, KeyCodes, } from '../../Utilities';\nimport { TooltipOverflowMode } from './TooltipHost.types';\nimport { Tooltip } from './Tooltip';\nimport { TooltipDelay } from './Tooltip.types';\nimport { WindowContext } from '@fluentui/react-window-provider';\nimport { getDocumentEx } from '../../utilities/dom';\nvar getClassNames = classNamesFunction();\nvar TooltipHostBase = /** @class */ (function (_super) {\n    __extends(TooltipHostBase, _super);\n    // Constructor\n    function TooltipHostBase(props) {\n        var _this = _super.call(this, props) || this;\n        // The wrapping div that gets the hover events\n        _this._tooltipHost = React.createRef();\n        _this._defaultTooltipId = getId('tooltip');\n        _this.show = function () {\n            _this._toggleTooltip(true);\n        };\n        _this.dismiss = function () {\n            _this._hideTooltip();\n        };\n        _this._getTargetElement = function () {\n            if (!_this._tooltipHost.current) {\n                return undefined;\n            }\n            var overflowMode = _this.props.overflowMode;\n            // Select target element based on overflow mode. For parent mode, you want to position the tooltip relative\n            // to the parent element, otherwise it might look off.\n            if (overflowMode !== undefined) {\n                switch (overflowMode) {\n                    case TooltipOverflowMode.Parent:\n                        return _this._tooltipHost.current.parentElement;\n                    case TooltipOverflowMode.Self:\n                        return _this._tooltipHost.current;\n                }\n            }\n            return _this._tooltipHost.current;\n        };\n        _this._onTooltipFocus = function (ev) {\n            if (_this._ignoreNextFocusEvent) {\n                _this._ignoreNextFocusEvent = false;\n                return;\n            }\n            _this._onTooltipMouseEnter(ev);\n        };\n        _this._onTooltipContentFocus = function (ev) {\n            if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip !== _this) {\n                TooltipHostBase._currentVisibleTooltip.dismiss();\n            }\n            TooltipHostBase._currentVisibleTooltip = _this;\n            _this._clearDismissTimer();\n            _this._clearOpenTimer();\n        };\n        _this._onTooltipBlur = function (ev) {\n            var _a;\n            // The focused element gets a blur event when the document loses focus\n            // (e.g. switching tabs in the browser), but we don't want to show the\n            // tooltip again when the document gets focus back. Handle this case by\n            // checking if the blurred element is still the document's activeElement,\n            // and ignoring when it next gets focus back.\n            // See https://github.com/microsoft/fluentui/issues/13541\n            _this._ignoreNextFocusEvent = ((_a = getDocumentEx(_this.context)) === null || _a === void 0 ? void 0 : _a.activeElement) === ev.target;\n            _this._dismissTimerId = _this._async.setTimeout(function () {\n                _this._hideTooltip();\n            }, 0);\n        };\n        // Show Tooltip\n        _this._onTooltipMouseEnter = function (ev) {\n            var _a = _this.props, overflowMode = _a.overflowMode, delay = _a.delay;\n            var doc = getDocumentEx(_this.context);\n            if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip !== _this) {\n                TooltipHostBase._currentVisibleTooltip.dismiss();\n            }\n            TooltipHostBase._currentVisibleTooltip = _this;\n            if (overflowMode !== undefined) {\n                var overflowElement = _this._getTargetElement();\n                if (overflowElement && !hasOverflow(overflowElement)) {\n                    return;\n                }\n            }\n            if (ev.target && portalContainsElement(ev.target, _this._getTargetElement(), doc)) {\n                // Do not show tooltip when target is inside a portal relative to TooltipHost.\n                return;\n            }\n            _this._clearDismissTimer();\n            _this._clearOpenTimer();\n            if (delay !== TooltipDelay.zero) {\n                var delayTime = _this._getDelayTime(delay); // non-null assertion because we set it in `defaultProps`\n                _this._openTimerId = _this._async.setTimeout(function () {\n                    _this._toggleTooltip(true);\n                }, delayTime);\n            }\n            else {\n                _this._toggleTooltip(true);\n            }\n        };\n        // Hide Tooltip\n        _this._onTooltipMouseLeave = function (ev) {\n            var closeDelay = _this.props.closeDelay;\n            _this._clearDismissTimer();\n            _this._clearOpenTimer();\n            if (closeDelay) {\n                _this._dismissTimerId = _this._async.setTimeout(function () {\n                    _this._toggleTooltip(false);\n                }, closeDelay);\n            }\n            else {\n                _this._toggleTooltip(false);\n            }\n            if (TooltipHostBase._currentVisibleTooltip === _this) {\n                TooltipHostBase._currentVisibleTooltip = undefined;\n            }\n        };\n        _this._onTooltipKeyDown = function (ev) {\n            // eslint-disable-next-line @typescript-eslint/no-deprecated\n            if ((ev.which === KeyCodes.escape || ev.ctrlKey) && _this.state.isTooltipVisible) {\n                _this._hideTooltip();\n                ev.stopPropagation();\n            }\n        };\n        _this._clearDismissTimer = function () {\n            _this._async.clearTimeout(_this._dismissTimerId);\n        };\n        _this._clearOpenTimer = function () {\n            _this._async.clearTimeout(_this._openTimerId);\n        };\n        // Hide Tooltip\n        _this._hideTooltip = function () {\n            _this._clearOpenTimer();\n            _this._clearDismissTimer();\n            _this._toggleTooltip(false);\n        };\n        _this._toggleTooltip = function (isTooltipVisible) {\n            if (_this.state.isTooltipVisible !== isTooltipVisible) {\n                _this.setState({ isTooltipVisible: isTooltipVisible }, function () { return _this.props.onTooltipToggle && _this.props.onTooltipToggle(isTooltipVisible); });\n            }\n        };\n        _this._getDelayTime = function (delay) {\n            switch (delay) {\n                case TooltipDelay.medium:\n                    return 300;\n                case TooltipDelay.long:\n                    return 500;\n                default:\n                    return 0;\n            }\n        };\n        initializeComponentRef(_this);\n        _this.state = {\n            isAriaPlaceholderRendered: false,\n            isTooltipVisible: false,\n        };\n        return _this;\n    }\n    // Render\n    TooltipHostBase.prototype.render = function () {\n        var _a = this.props, calloutProps = _a.calloutProps, children = _a.children, content = _a.content, directionalHint = _a.directionalHint, directionalHintForRTL = _a.directionalHintForRTL, className = _a.hostClassName, id = _a.id, \n        // eslint-disable-next-line @typescript-eslint/no-deprecated\n        _b = _a.setAriaDescribedBy, \n        // eslint-disable-next-line @typescript-eslint/no-deprecated\n        setAriaDescribedBy = _b === void 0 ? true : _b, tooltipProps = _a.tooltipProps, styles = _a.styles, theme = _a.theme;\n        this._classNames = getClassNames(styles, {\n            theme: theme,\n            className: className,\n        });\n        var isTooltipVisible = this.state.isTooltipVisible;\n        var tooltipId = id || this._defaultTooltipId;\n        var tooltipRenderProps = __assign(__assign({ id: \"\".concat(tooltipId, \"--tooltip\"), content: content, targetElement: this._getTargetElement(), directionalHint: directionalHint, directionalHintForRTL: directionalHintForRTL, calloutProps: assign({}, calloutProps, {\n                onDismiss: this._hideTooltip,\n                onFocus: this._onTooltipContentFocus,\n                onMouseEnter: this._onTooltipMouseEnter,\n                onMouseLeave: this._onTooltipMouseLeave,\n            }), onMouseEnter: this._onTooltipMouseEnter, onMouseLeave: this._onTooltipMouseLeave }, getNativeProps(this.props, divProperties, ['id'])), tooltipProps);\n        // Get the content of the tooltip for use in the hidden div used for screen readers\n        var tooltipContent = (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.onRenderContent)\n            ? tooltipProps.onRenderContent(tooltipRenderProps, function (props) { return ((props === null || props === void 0 ? void 0 : props.content) ? React.createElement(React.Fragment, null, props.content) : null); })\n            : content;\n        var showTooltip = isTooltipVisible && !!tooltipContent;\n        var ariaDescribedBy = setAriaDescribedBy && isTooltipVisible && !!tooltipContent ? tooltipId : undefined;\n        return (React.createElement(\"div\", { className: this._classNames.root, ref: this._tooltipHost, onFocusCapture: this._onTooltipFocus, onBlurCapture: this._onTooltipBlur, onMouseEnter: this._onTooltipMouseEnter, onMouseLeave: this._onTooltipMouseLeave, onKeyDown: this._onTooltipKeyDown, role: \"none\", \"aria-describedby\": ariaDescribedBy },\n            children,\n            showTooltip && React.createElement(Tooltip, __assign({}, tooltipRenderProps)),\n            React.createElement(\"div\", { hidden: true, id: tooltipId, style: hiddenContentStyle }, tooltipContent)));\n    };\n    TooltipHostBase.prototype.componentDidMount = function () {\n        this._async = new Async(this);\n    };\n    TooltipHostBase.prototype.componentWillUnmount = function () {\n        if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip === this) {\n            TooltipHostBase._currentVisibleTooltip = undefined;\n        }\n        this._async.dispose();\n    };\n    TooltipHostBase.defaultProps = {\n        delay: TooltipDelay.medium,\n    };\n    TooltipHostBase.contextType = WindowContext;\n    return TooltipHostBase;\n}(React.Component));\nexport { TooltipHostBase };\n//# sourceMappingURL=TooltipHost.base.js.map","import { getGlobalClassNames } from '../../Styling';\nvar GlobalClassNames = {\n    root: 'ms-TooltipHost',\n    ariaPlaceholder: 'ms-TooltipHost-aria-placeholder',\n};\nexport var getStyles = function (props) {\n    var className = props.className, theme = props.theme;\n    var classNames = getGlobalClassNames(GlobalClassNames, theme);\n    return {\n        root: [\n            classNames.root,\n            {\n                display: 'inline',\n            },\n            className,\n        ],\n    };\n};\n//# sourceMappingURL=TooltipHost.styles.js.map","import { styled } from '../../Utilities';\nimport { TooltipHostBase } from './TooltipHost.base';\nimport { getStyles } from './TooltipHost.styles';\nexport var TooltipHost = styled(TooltipHostBase, getStyles, undefined, {\n    scope: 'TooltipHost',\n});\n//# sourceMappingURL=TooltipHost.js.map"],"names":["hasHorizontalOverflow","element","hasVerticalOverflow","hasOverflow","ResizeGroupDirection","RESIZE_DELAY","getMeasurementCache","measurementsCache","data","measurement","getNextResizeGroupStateProvider","measurementCache","_measurementCache","_containerDimension","_getMeasuredDimension","measuredData","getElementToMeasureDimension","cachedDimension","measuredDimension","_shrinkContentsUntilTheyFit","onReduceData","dataToMeasure","nextMeasuredData","_growDataUntilItDoesNotFit","onGrowData","__assign","_updateContainerDimension","newDimension","fullDimensionData","renderedData","nextState","getNextState","props","currentState","newContainerDimension","shouldRenderDataForMeasurement","getInitialResizeGroupState","MeasuredContext","React.createContext","hiddenDivStyles","hiddenParentStyles","resizeDataReducer","state","action","_a","useResizeState","nextResizeGroupStateProvider","rootRef","initialStateData","useConst","React.useReducer","resizeData","dispatchResizeDataAction","React.useEffect","stateRef","React.useRef","updateResizeState","React.useCallback","remeasure","useResizingBehavior","initialHiddenDiv","updateHiddenDiv","hasRenderedContent","async","useAsync","containerDimension","boundingRect","refToMeasure","measuredBoundingRect","win","useWindow","useOnEvent","dataNeedsMeasuring","isInitialMeasure","measuredContextValue","ResizeGroupBase","React.forwardRef","forwardedRef","mergedRootRef","useMergedRefs","React.useImperativeHandle","className","onRenderData","divProps","getNativeProps","divProperties","React.createElement","ResizeGroup","getClassNames","classNamesFunction","TooltipBase","_super","__extends","_this","calloutProps","directionalHint","directionalHintForRTL","styles","id","maxWidth","_b","onRenderContent","targetElement","theme","Callout","DirectionalHint","React.Component","getStyles","beakWidth","gapSpace","semanticColors","fonts","effects","tooltipGapSpace","AnimationClassNames","Tooltip","styled","TooltipDelay","TooltipOverflowMode","TooltipHostBase","React.createRef","getId","overflowMode","ev","getDocumentEx","delay","doc","overflowElement","portalContainsElement","delayTime","closeDelay","KeyCodes","isTooltipVisible","initializeComponentRef","children","content","setAriaDescribedBy","tooltipProps","tooltipId","tooltipRenderProps","assign","tooltipContent","React.Fragment","showTooltip","ariaDescribedBy","hiddenContentStyle","Async","WindowContext","GlobalClassNames","classNames","getGlobalClassNames","TooltipHost"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11]}