first commit

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.base.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { ITooltipProps } from './Tooltip.types';
+import type { JSXElement } from '@fluentui/utilities';
+export declare class TooltipBase extends React.Component<ITooltipProps, any> {
+    static defaultProps: Partial<ITooltipProps>;
+    private _classNames;
+    render(): JSXElement;
+    private _onRenderContent;
+}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.base.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipBase = void 0;
+var tslib_1 = require("tslib");
+var React = require("react");
+var Utilities_1 = require("../../Utilities");
+var Callout_1 = require("../../Callout");
+var DirectionalHint_1 = require("../../common/DirectionalHint");
+var getClassNames = (0, Utilities_1.classNamesFunction)();
+var TooltipBase = /** @class */ (function (_super) {
+    tslib_1.__extends(TooltipBase, _super);
+    function TooltipBase() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._onRenderContent = function (props) {
+            if (typeof props.content === 'string') {
+                return React.createElement("p", { className: _this._classNames.subText }, props.content);
+            }
+            else {
+                return React.createElement("div", { className: _this._classNames.subText }, props.content);
+            }
+        };
+        return _this;
+    }
+    TooltipBase.prototype.render = function () {
+        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;
+        this._classNames = getClassNames(styles, {
+            theme: theme,
+            className: className || (calloutProps && calloutProps.className),
+            beakWidth: calloutProps && calloutProps.isBeakVisible ? calloutProps.beakWidth : 0,
+            gapSpace: calloutProps && calloutProps.gapSpace,
+            maxWidth: maxWidth,
+        });
+        return (React.createElement(Callout_1.Callout, tslib_1.__assign({ target: targetElement, directionalHint: directionalHint, directionalHintForRTL: directionalHintForRTL }, calloutProps, (0, Utilities_1.getNativeProps)(this.props, Utilities_1.divProperties, ['id']), { className: this._classNames.root }),
+            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))));
+    };
+    // Specify default props values
+    TooltipBase.defaultProps = {
+        directionalHint: DirectionalHint_1.DirectionalHint.topCenter,
+        maxWidth: '364px',
+        calloutProps: {
+            isBeakVisible: true,
+            beakWidth: 16,
+            gapSpace: 0,
+            setInitialFocus: true,
+            doNotLayer: false,
+        },
+    };
+    return TooltipBase;
+}(React.Component));
+exports.TooltipBase = TooltipBase;
+//# sourceMappingURL=Tooltip.base.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.base.js","sourceRoot":"../src/","sources":["components/Tooltip/Tooltip.base.tsx"],"names":[],"mappings":";;;;AAAA,6BAA+B;AAC/B,6CAAoF;AACpF,yCAAwC;AACxC,gEAA+D;AAM/D,IAAM,aAAa,GAAG,IAAA,8BAAkB,GAAsC,CAAC;AAE/E;IAAiC,uCAAmC;IAApE;;QA4DU,sBAAgB,GAAG,UAAC,KAAoB;YAC9C,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACtC,OAAO,2BAAG,SAAS,EAAE,KAAI,CAAC,WAAW,CAAC,OAAO,IAAG,KAAK,CAAC,OAAO,CAAK,CAAC;YACrE,CAAC;iBAAM,CAAC;gBACN,OAAO,6BAAK,SAAS,EAAE,KAAI,CAAC,WAAW,CAAC,OAAO,IAAG,KAAK,CAAC,OAAO,CAAO,CAAC;YACzE,CAAC;QACH,CAAC,CAAC;;IACJ,CAAC;IAnDQ,4BAAM,GAAb;QACQ,IAAA,KAWF,IAAI,CAAC,KAAK,EAVZ,SAAS,eAAA,EACT,YAAY,kBAAA,EACZ,eAAe,qBAAA,EACf,qBAAqB,2BAAA,EACrB,MAAM,YAAA,EACN,EAAE,QAAA,EACF,QAAQ,cAAA,EACR,uBAAuC,EAAvC,eAAe,mBAAG,IAAI,CAAC,gBAAgB,KAAA,EACvC,aAAa,mBAAA,EACb,KAAK,WACO,CAAC;QAEf,IAAI,CAAC,WAAW,GAAG,aAAa,CAAC,MAAO,EAAE;YACxC,KAAK,EAAE,KAAM;YACb,SAAS,EAAE,SAAS,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,SAAS,CAAC;YAChE,SAAS,EAAE,YAAY,IAAI,YAAY,CAAC,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAClF,QAAQ,EAAE,YAAY,IAAI,YAAY,CAAC,QAAQ;YAC/C,QAAQ,EAAE,QAAS;SACpB,CAAC,CAAC;QAEH,OAAO,CACL,oBAAC,iBAAO,qBACN,MAAM,EAAE,aAAa,EACrB,eAAe,EAAE,eAAe,EAChC,qBAAqB,EAAE,qBAAqB,IACxC,YAAY,EACZ,IAAA,0BAAc,EAAC,IAAI,CAAC,KAAK,EAAE,yBAAa,EAAE,CAAC,IAAI,CAAC,CAAC,IACrD,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YAEhC,6BACE,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO,EACnC,EAAE,EAAE,EAAE,EACN,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,EAC3B,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EACrC,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,IAEpC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAC/C,CACE,CACX,CAAC;IACJ,CAAC;IAzDD,+BAA+B;IACjB,wBAAY,GAA2B;QACnD,eAAe,EAAE,iCAAe,CAAC,SAAS;QAC1C,QAAQ,EAAE,OAAO;QACjB,YAAY,EAAE;YACZ,aAAa,EAAE,IAAI;YACnB,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE,CAAC;YACX,eAAe,EAAE,IAAI;YACrB,UAAU,EAAE,KAAK;SAClB;KACF,AAVyB,CAUxB;IAuDJ,kBAAC;CAAA,AAnED,CAAiC,KAAK,CAAC,SAAS,GAmE/C;AAnEY,kCAAW","sourcesContent":["import * as React from 'react';\nimport { classNamesFunction, divProperties, getNativeProps } from '../../Utilities';\nimport { Callout } from '../../Callout';\nimport { DirectionalHint } from '../../common/DirectionalHint';\nimport type { IProcessedStyleSet } from '../../Styling';\nimport type { ITooltipProps, ITooltipStyleProps, ITooltipStyles } from './Tooltip.types';\n\nimport type { JSXElement } from '@fluentui/utilities';\n\nconst getClassNames = classNamesFunction<ITooltipStyleProps, ITooltipStyles>();\n\nexport class TooltipBase extends React.Component<ITooltipProps, any> {\n  // Specify default props values\n  public static defaultProps: Partial<ITooltipProps> = {\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\n  private _classNames: IProcessedStyleSet<ITooltipStyles>;\n\n  public render(): JSXElement {\n    const {\n      className,\n      calloutProps,\n      directionalHint,\n      directionalHintForRTL,\n      styles,\n      id,\n      maxWidth,\n      onRenderContent = this._onRenderContent,\n      targetElement,\n      theme,\n    } = this.props;\n\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\n    return (\n      <Callout\n        target={targetElement}\n        directionalHint={directionalHint}\n        directionalHintForRTL={directionalHintForRTL}\n        {...calloutProps}\n        {...getNativeProps(this.props, divProperties, ['id'])} // omitting ID due to it being used in the div below\n        className={this._classNames.root}\n      >\n        <div\n          className={this._classNames.content}\n          id={id}\n          onFocus={this.props.onFocus}\n          onMouseEnter={this.props.onMouseEnter}\n          onMouseLeave={this.props.onMouseLeave}\n        >\n          {onRenderContent(this.props, this._onRenderContent)}\n        </div>\n      </Callout>\n    );\n  }\n\n  private _onRenderContent = (props: ITooltipProps): JSXElement => {\n    if (typeof props.content === 'string') {\n      return <p className={this._classNames.subText}>{props.content}</p>;\n    } else {\n      return <div className={this._classNames.subText}>{props.content}</div>;\n    }\n  };\n}\n"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { ITooltipProps } from './Tooltip.types';
+export declare const Tooltip: React.FunctionComponent<ITooltipProps>;

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tooltip = void 0;
+var Utilities_1 = require("../../Utilities");
+var Tooltip_base_1 = require("./Tooltip.base");
+var Tooltip_styles_1 = require("./Tooltip.styles");
+exports.Tooltip = (0, Utilities_1.styled)(Tooltip_base_1.TooltipBase, Tooltip_styles_1.getStyles, undefined, {
+    scope: 'Tooltip',
+});
+//# sourceMappingURL=Tooltip.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.js","sourceRoot":"../src/","sources":["components/Tooltip/Tooltip.tsx"],"names":[],"mappings":";;;AACA,6CAAyC;AACzC,+CAA6C;AAC7C,mDAA6C;AAGhC,QAAA,OAAO,GAA2C,IAAA,kBAAM,EAInE,0BAAW,EAAE,0BAAS,EAAE,SAAS,EAAE;IACnC,KAAK,EAAE,SAAS;CACjB,CAAC,CAAC","sourcesContent":["import * as React from 'react';\nimport { styled } from '../../Utilities';\nimport { TooltipBase } from './Tooltip.base';\nimport { getStyles } from './Tooltip.styles';\nimport type { ITooltipProps, ITooltipStyleProps, ITooltipStyles } from './Tooltip.types';\n\nexport const Tooltip: React.FunctionComponent<ITooltipProps> = styled<\n  ITooltipProps,\n  ITooltipStyleProps,\n  ITooltipStyles\n>(TooltipBase, getStyles, undefined, {\n  scope: 'Tooltip',\n});\n"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.styles.d.ts

@@ -0,0 +1,2 @@
+import type { ITooltipStyleProps, ITooltipStyles } from './Tooltip.types';
+export declare const getStyles: (props: ITooltipStyleProps) => ITooltipStyles;

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.styles.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStyles = void 0;
+var Styling_1 = require("../../Styling");
+var getStyles = function (props) {
+    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;
+    var semanticColors = theme.semanticColors, fonts = theme.fonts, effects = theme.effects;
+    // The math here is done to account for the 45 degree rotation of the beak
+    // and sub-pixel rounding that differs across browsers, which is more noticeable when
+    // the device pixel ratio is larger
+    var tooltipGapSpace = -(Math.sqrt((beakWidth * beakWidth) / 2) + gapSpace) +
+        1 /
+            // There isn't really a great way to pass in a `window` reference here so disabling the line rule
+            // eslint-disable-next-line no-restricted-globals
+            window.devicePixelRatio;
+    return {
+        root: [
+            'ms-Tooltip',
+            theme.fonts.medium,
+            Styling_1.AnimationClassNames.fadeIn200,
+            {
+                background: semanticColors.menuBackground,
+                boxShadow: effects.elevation8,
+                padding: '8px',
+                maxWidth: maxWidth,
+                selectors: {
+                    ':after': {
+                        content: "''",
+                        position: 'absolute',
+                        bottom: tooltipGapSpace,
+                        left: tooltipGapSpace,
+                        right: tooltipGapSpace,
+                        top: tooltipGapSpace,
+                        zIndex: 0,
+                    },
+                },
+            },
+            className,
+        ],
+        content: [
+            'ms-Tooltip-content',
+            fonts.small,
+            {
+                position: 'relative',
+                zIndex: 1,
+                color: semanticColors.menuItemText,
+                wordWrap: 'break-word',
+                overflowWrap: 'break-word',
+                overflow: 'hidden',
+            },
+        ],
+        subText: [
+            'ms-Tooltip-subtext',
+            {
+                // Using inherit here to avoid unintentional global overrides of the <p> tag.
+                fontSize: 'inherit',
+                fontWeight: 'inherit',
+                color: 'inherit',
+                margin: 0,
+            },
+        ],
+    };
+};
+exports.getStyles = getStyles;
+//# sourceMappingURL=Tooltip.styles.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.styles.js","sourceRoot":"../src/","sources":["components/Tooltip/Tooltip.styles.ts"],"names":[],"mappings":";;;AAAA,yCAAoD;AAG7C,IAAM,SAAS,GAAG,UAAC,KAAyB;IACzC,IAAA,SAAS,GAAoD,KAAK,UAAzD,EAAE,KAAkD,KAAK,UAAzC,EAAd,SAAS,mBAAG,EAAE,KAAA,EAAE,KAAkC,KAAK,SAA3B,EAAZ,QAAQ,mBAAG,CAAC,KAAA,EAAE,QAAQ,GAAY,KAAK,SAAjB,EAAE,KAAK,GAAK,KAAK,MAAV,CAAW;IACnE,IAAA,cAAc,GAAqB,KAAK,eAA1B,EAAE,KAAK,GAAc,KAAK,MAAnB,EAAE,OAAO,GAAK,KAAK,QAAV,CAAW;IAEjD,0EAA0E;IAC1E,qFAAqF;IACrF,mCAAmC;IACnC,IAAM,eAAe,GACnB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC;QACpD,CAAC;YACC,iGAAiG;YACjG,iDAAiD;YACjD,MAAM,CAAC,gBAAgB,CAAC;IAE5B,OAAO;QACL,IAAI,EAAE;YACJ,YAAY;YACZ,KAAK,CAAC,KAAK,CAAC,MAAM;YAClB,6BAAmB,CAAC,SAAS;YAC7B;gBACE,UAAU,EAAE,cAAc,CAAC,cAAc;gBACzC,SAAS,EAAE,OAAO,CAAC,UAAU;gBAC7B,OAAO,EAAE,KAAK;gBACd,QAAQ,UAAA;gBACR,SAAS,EAAE;oBACT,QAAQ,EAAE;wBACR,OAAO,EAAE,IAAI;wBACb,QAAQ,EAAE,UAAU;wBACpB,MAAM,EAAE,eAAe;wBACvB,IAAI,EAAE,eAAe;wBACrB,KAAK,EAAE,eAAe;wBACtB,GAAG,EAAE,eAAe;wBACpB,MAAM,EAAE,CAAC;qBACV;iBACF;aACF;YACD,SAAS;SACV;QACD,OAAO,EAAE;YACP,oBAAoB;YACpB,KAAK,CAAC,KAAK;YACX;gBACE,QAAQ,EAAE,UAAU;gBACpB,MAAM,EAAE,CAAC;gBACT,KAAK,EAAE,cAAc,CAAC,YAAY;gBAClC,QAAQ,EAAE,YAAY;gBACtB,YAAY,EAAE,YAAY;gBAC1B,QAAQ,EAAE,QAAQ;aACnB;SACF;QACD,OAAO,EAAE;YACP,oBAAoB;YACpB;gBACE,6EAA6E;gBAC7E,QAAQ,EAAE,SAAS;gBACnB,UAAU,EAAE,SAAS;gBACrB,KAAK,EAAE,SAAS;gBAChB,MAAM,EAAE,CAAC;aACV;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AA7DW,QAAA,SAAS,aA6DpB","sourcesContent":["import { AnimationClassNames } from '../../Styling';\nimport type { ITooltipStyleProps, ITooltipStyles } from './Tooltip.types';\n\nexport const getStyles = (props: ITooltipStyleProps): ITooltipStyles => {\n  const { className, beakWidth = 16, gapSpace = 0, maxWidth, theme } = props;\n  const { semanticColors, fonts, effects } = theme;\n\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  const tooltipGapSpace =\n    -(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\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,\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"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.types.d.ts

@@ -0,0 +1,120 @@
+import * as React from 'react';
+import { TooltipBase } from './Tooltip.base';
+import { DirectionalHint } from '../../common/DirectionalHint';
+import type { ICalloutProps } from '../../Callout';
+import type { IRenderFunction, IRefObject, IStyleFunctionOrObject } from '../../Utilities';
+import type { IStyle, ITheme } from '../../Styling';
+import type { JSXElement } from '@fluentui/utilities';
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltip {
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipProps extends Omit<React.HTMLAttributes<HTMLDivElement | TooltipBase>, 'content'> {
+    /**
+     * Optional callback to access the ITooltip interface. Use this instead of ref for accessing
+     * the public methods and properties of the component.
+     */
+    componentRef?: IRefObject<ITooltip>;
+    /**
+     * Properties to pass through for Callout.
+     * @defaultvalue `{ isBeakVisible: true, beakWidth: 16, gapSpace: 0, setInitialFocus: true, doNotLayer: false }`
+     */
+    calloutProps?: ICalloutProps;
+    /**
+     * Content to be passed to the tooltip
+     */
+    content?: string | JSXElement | JSXElement[];
+    /**
+     * Render function to populate tooltip content.
+     */
+    onRenderContent?: IRenderFunction<ITooltipProps>;
+    /**
+     * Length of delay. Set to `TooltipDelay.zero` if you do not want a delay.
+     * @defaultvalue TooltipDelay.medium
+     */
+    delay?: TooltipDelay;
+    /**
+     * Max width of tooltip
+     * @defaultvalue 364px
+     */
+    maxWidth?: string | null;
+    /**
+     * Element to anchor the Tooltip to.
+     */
+    targetElement?: HTMLElement;
+    /**
+     * How the tooltip should be anchored to its `targetElement`.
+     * @defaultvalue DirectionalHint.topCenter
+     */
+    directionalHint?: DirectionalHint;
+    /**
+     * How the element should be positioned in RTL layouts.
+     * If not specified, a mirror of `directionalHint` will be used instead
+     */
+    directionalHintForRTL?: DirectionalHint;
+    /**
+     * Theme provided by higher-order component.
+     */
+    theme?: ITheme;
+    /**
+     * Call to provide customized styling that will layer on top of the variant rules.
+     */
+    styles?: IStyleFunctionOrObject<ITooltipStyleProps, ITooltipStyles>;
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export declare enum TooltipDelay {
+    zero = 0,
+    /** 300 ms delay before showing the tooltip */
+    medium = 1,
+    /** 500 ms delay before showing the tooltip */
+    long = 2
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipStyleProps {
+    theme: ITheme;
+    className?: string;
+    /**
+     * Delay before tooltip appears.
+     * @deprecated Delay logic moved to TooltipHost vs relying on animation delay.
+     */
+    delay?: TooltipDelay;
+    /**
+     * Maximum width of tooltip.
+     */
+    maxWidth?: string;
+    /**
+     * The gap between the Callout and the target
+     * @defaultvalue 0
+     */
+    gapSpace?: number;
+    /**
+     * The width of the Callout's beak
+     * @defaultvalue 16
+     */
+    beakWidth?: number;
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipStyles {
+    /**
+     * Style for the root element.
+     */
+    root: IStyle;
+    /**
+     * Style for the content element.
+     */
+    content: IStyle;
+    /**
+     * Style for the subtext element.
+     */
+    subText: IStyle;
+}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipDelay = void 0;
+/**
+ * {@docCategory Tooltip}
+ */
+var TooltipDelay;
+(function (TooltipDelay) {
+    TooltipDelay[TooltipDelay["zero"] = 0] = "zero";
+    /** 300 ms delay before showing the tooltip */
+    TooltipDelay[TooltipDelay["medium"] = 1] = "medium";
+    /** 500 ms delay before showing the tooltip */
+    TooltipDelay[TooltipDelay["long"] = 2] = "long";
+})(TooltipDelay || (exports.TooltipDelay = TooltipDelay = {}));
+//# sourceMappingURL=Tooltip.types.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/Tooltip.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.types.js","sourceRoot":"../src/","sources":["components/Tooltip/Tooltip.types.ts"],"names":[],"mappings":";;;AAiFA;;GAEG;AACH,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,+CAAQ,CAAA;IACR,8CAA8C;IAC9C,mDAAU,CAAA;IACV,8CAA8C;IAC9C,+CAAQ,CAAA;AACV,CAAC,EANW,YAAY,4BAAZ,YAAY,QAMvB","sourcesContent":["import * as React from 'react';\nimport { TooltipBase } from './Tooltip.base';\nimport { DirectionalHint } from '../../common/DirectionalHint';\nimport type { ICalloutProps } from '../../Callout';\nimport type { IRenderFunction, IRefObject, IStyleFunctionOrObject } from '../../Utilities';\nimport type { IStyle, ITheme } from '../../Styling';\n\nimport type { JSXElement } from '@fluentui/utilities';\n\n/**\n * {@docCategory Tooltip}\n */\nexport interface ITooltip {}\n\n/**\n * {@docCategory Tooltip}\n */\nexport interface ITooltipProps extends Omit<React.HTMLAttributes<HTMLDivElement | TooltipBase>, 'content'> {\n  /**\n   * Optional callback to access the ITooltip interface. Use this instead of ref for accessing\n   * the public methods and properties of the component.\n   */\n  componentRef?: IRefObject<ITooltip>;\n\n  /**\n   * Properties to pass through for Callout.\n   * @defaultvalue `{ isBeakVisible: true, beakWidth: 16, gapSpace: 0, setInitialFocus: true, doNotLayer: false }`\n   */\n  calloutProps?: ICalloutProps;\n\n  /**\n   * Content to be passed to the tooltip\n   */\n\n  content?: string | JSXElement | JSXElement[];\n\n  /**\n   * Render function to populate tooltip content.\n   */\n  onRenderContent?: IRenderFunction<ITooltipProps>;\n\n  /**\n   * Length of delay. Set to `TooltipDelay.zero` if you do not want a delay.\n   * @defaultvalue TooltipDelay.medium\n   */\n  delay?: TooltipDelay;\n\n  /**\n   * Max width of tooltip\n   * @defaultvalue 364px\n   */\n  maxWidth?: string | null;\n\n  /**\n   * Element to anchor the Tooltip to.\n   */\n  targetElement?: HTMLElement;\n\n  /**\n   * How the tooltip should be anchored to its `targetElement`.\n   * @defaultvalue DirectionalHint.topCenter\n   */\n  directionalHint?: DirectionalHint;\n\n  /**\n   * How the element should be positioned in RTL layouts.\n   * If not specified, a mirror of `directionalHint` will be used instead\n   */\n  directionalHintForRTL?: DirectionalHint;\n\n  /**\n   * Theme provided by higher-order component.\n   */\n  theme?: ITheme;\n\n  /**\n   * Call to provide customized styling that will layer on top of the variant rules.\n   */\n  styles?: IStyleFunctionOrObject<ITooltipStyleProps, ITooltipStyles>;\n}\n\n/**\n * {@docCategory Tooltip}\n */\nexport enum TooltipDelay {\n  zero = 0,\n  /** 300 ms delay before showing the tooltip */\n  medium = 1,\n  /** 500 ms delay before showing the tooltip */\n  long = 2,\n}\n\n/**\n * {@docCategory Tooltip}\n */\nexport interface ITooltipStyleProps {\n  theme: ITheme;\n\n  className?: string;\n\n  /**\n   * Delay before tooltip appears.\n   * @deprecated Delay logic moved to TooltipHost vs relying on animation delay.\n   */\n  delay?: TooltipDelay;\n\n  /**\n   * Maximum width of tooltip.\n   */\n  maxWidth?: string;\n\n  /**\n   * The gap between the Callout and the target\n   * @defaultvalue 0\n   */\n  gapSpace?: number;\n\n  /**\n   * The width of the Callout's beak\n   * @defaultvalue 16\n   */\n  beakWidth?: number;\n}\n\n/**\n * {@docCategory Tooltip}\n */\nexport interface ITooltipStyles {\n  /**\n   * Style for the root element.\n   */\n  root: IStyle;\n\n  /**\n   * Style for the content element.\n   */\n  content: IStyle;\n\n  /**\n   * Style for the subtext element.\n   */\n  subText: IStyle;\n}\n"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.base.d.ts

@@ -0,0 +1,42 @@
+import * as React from 'react';
+import { TooltipDelay } from './Tooltip.types';
+import type { ITooltipHostProps, ITooltipHost } from './TooltipHost.types';
+import type { JSXElement } from '@fluentui/utilities';
+export interface ITooltipHostState {
+    /** @deprecated No longer used internally */
+    isAriaPlaceholderRendered: boolean;
+    isTooltipVisible: boolean;
+}
+export declare class TooltipHostBase extends React.Component<ITooltipHostProps, ITooltipHostState> implements ITooltipHost {
+    static defaultProps: {
+        delay: TooltipDelay;
+    };
+    static contextType: React.Context<import("@fluentui/react-window-provider").WindowProviderProps>;
+    private static _currentVisibleTooltip;
+    context: any;
+    private _tooltipHost;
+    private _classNames;
+    private _async;
+    private _dismissTimerId;
+    private _openTimerId;
+    private _defaultTooltipId;
+    private _ignoreNextFocusEvent;
+    constructor(props: ITooltipHostProps);
+    render(): JSXElement;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    show: () => void;
+    dismiss: () => void;
+    private _getTargetElement;
+    private _onTooltipFocus;
+    private _onTooltipContentFocus;
+    private _onTooltipBlur;
+    private _onTooltipMouseEnter;
+    private _onTooltipMouseLeave;
+    private _onTooltipKeyDown;
+    private _clearDismissTimer;
+    private _clearOpenTimer;
+    private _hideTooltip;
+    private _toggleTooltip;
+    private _getDelayTime;
+}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.base.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipHostBase = void 0;
+var tslib_1 = require("tslib");
+var React = require("react");
+var Styling_1 = require("../../Styling");
+var Utilities_1 = require("../../Utilities");
+var TooltipHost_types_1 = require("./TooltipHost.types");
+var Tooltip_1 = require("./Tooltip");
+var Tooltip_types_1 = require("./Tooltip.types");
+var react_window_provider_1 = require("@fluentui/react-window-provider");
+var dom_1 = require("../../utilities/dom");
+var getClassNames = (0, Utilities_1.classNamesFunction)();
+var TooltipHostBase = /** @class */ (function (_super) {
+    tslib_1.__extends(TooltipHostBase, _super);
+    // Constructor
+    function TooltipHostBase(props) {
+        var _this = _super.call(this, props) || this;
+        // The wrapping div that gets the hover events
+        _this._tooltipHost = React.createRef();
+        _this._defaultTooltipId = (0, Utilities_1.getId)('tooltip');
+        _this.show = function () {
+            _this._toggleTooltip(true);
+        };
+        _this.dismiss = function () {
+            _this._hideTooltip();
+        };
+        _this._getTargetElement = function () {
+            if (!_this._tooltipHost.current) {
+                return undefined;
+            }
+            var overflowMode = _this.props.overflowMode;
+            // Select target element based on overflow mode. For parent mode, you want to position the tooltip relative
+            // to the parent element, otherwise it might look off.
+            if (overflowMode !== undefined) {
+                switch (overflowMode) {
+                    case TooltipHost_types_1.TooltipOverflowMode.Parent:
+                        return _this._tooltipHost.current.parentElement;
+                    case TooltipHost_types_1.TooltipOverflowMode.Self:
+                        return _this._tooltipHost.current;
+                }
+            }
+            return _this._tooltipHost.current;
+        };
+        _this._onTooltipFocus = function (ev) {
+            if (_this._ignoreNextFocusEvent) {
+                _this._ignoreNextFocusEvent = false;
+                return;
+            }
+            _this._onTooltipMouseEnter(ev);
+        };
+        _this._onTooltipContentFocus = function (ev) {
+            if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip !== _this) {
+                TooltipHostBase._currentVisibleTooltip.dismiss();
+            }
+            TooltipHostBase._currentVisibleTooltip = _this;
+            _this._clearDismissTimer();
+            _this._clearOpenTimer();
+        };
+        _this._onTooltipBlur = function (ev) {
+            var _a;
+            // The focused element gets a blur event when the document loses focus
+            // (e.g. switching tabs in the browser), but we don't want to show the
+            // tooltip again when the document gets focus back. Handle this case by
+            // checking if the blurred element is still the document's activeElement,
+            // and ignoring when it next gets focus back.
+            // See https://github.com/microsoft/fluentui/issues/13541
+            _this._ignoreNextFocusEvent = ((_a = (0, dom_1.getDocumentEx)(_this.context)) === null || _a === void 0 ? void 0 : _a.activeElement) === ev.target;
+            _this._dismissTimerId = _this._async.setTimeout(function () {
+                _this._hideTooltip();
+            }, 0);
+        };
+        // Show Tooltip
+        _this._onTooltipMouseEnter = function (ev) {
+            var _a = _this.props, overflowMode = _a.overflowMode, delay = _a.delay;
+            var doc = (0, dom_1.getDocumentEx)(_this.context);
+            if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip !== _this) {
+                TooltipHostBase._currentVisibleTooltip.dismiss();
+            }
+            TooltipHostBase._currentVisibleTooltip = _this;
+            if (overflowMode !== undefined) {
+                var overflowElement = _this._getTargetElement();
+                if (overflowElement && !(0, Utilities_1.hasOverflow)(overflowElement)) {
+                    return;
+                }
+            }
+            if (ev.target && (0, Utilities_1.portalContainsElement)(ev.target, _this._getTargetElement(), doc)) {
+                // Do not show tooltip when target is inside a portal relative to TooltipHost.
+                return;
+            }
+            _this._clearDismissTimer();
+            _this._clearOpenTimer();
+            if (delay !== Tooltip_types_1.TooltipDelay.zero) {
+                var delayTime = _this._getDelayTime(delay); // non-null assertion because we set it in `defaultProps`
+                _this._openTimerId = _this._async.setTimeout(function () {
+                    _this._toggleTooltip(true);
+                }, delayTime);
+            }
+            else {
+                _this._toggleTooltip(true);
+            }
+        };
+        // Hide Tooltip
+        _this._onTooltipMouseLeave = function (ev) {
+            var closeDelay = _this.props.closeDelay;
+            _this._clearDismissTimer();
+            _this._clearOpenTimer();
+            if (closeDelay) {
+                _this._dismissTimerId = _this._async.setTimeout(function () {
+                    _this._toggleTooltip(false);
+                }, closeDelay);
+            }
+            else {
+                _this._toggleTooltip(false);
+            }
+            if (TooltipHostBase._currentVisibleTooltip === _this) {
+                TooltipHostBase._currentVisibleTooltip = undefined;
+            }
+        };
+        _this._onTooltipKeyDown = function (ev) {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            if ((ev.which === Utilities_1.KeyCodes.escape || ev.ctrlKey) && _this.state.isTooltipVisible) {
+                _this._hideTooltip();
+                ev.stopPropagation();
+            }
+        };
+        _this._clearDismissTimer = function () {
+            _this._async.clearTimeout(_this._dismissTimerId);
+        };
+        _this._clearOpenTimer = function () {
+            _this._async.clearTimeout(_this._openTimerId);
+        };
+        // Hide Tooltip
+        _this._hideTooltip = function () {
+            _this._clearOpenTimer();
+            _this._clearDismissTimer();
+            _this._toggleTooltip(false);
+        };
+        _this._toggleTooltip = function (isTooltipVisible) {
+            if (_this.state.isTooltipVisible !== isTooltipVisible) {
+                _this.setState({ isTooltipVisible: isTooltipVisible }, function () { return _this.props.onTooltipToggle && _this.props.onTooltipToggle(isTooltipVisible); });
+            }
+        };
+        _this._getDelayTime = function (delay) {
+            switch (delay) {
+                case Tooltip_types_1.TooltipDelay.medium:
+                    return 300;
+                case Tooltip_types_1.TooltipDelay.long:
+                    return 500;
+                default:
+                    return 0;
+            }
+        };
+        (0, Utilities_1.initializeComponentRef)(_this);
+        _this.state = {
+            isAriaPlaceholderRendered: false,
+            isTooltipVisible: false,
+        };
+        return _this;
+    }
+    // Render
+    TooltipHostBase.prototype.render = function () {
+        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, 
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        _b = _a.setAriaDescribedBy, 
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        setAriaDescribedBy = _b === void 0 ? true : _b, tooltipProps = _a.tooltipProps, styles = _a.styles, theme = _a.theme;
+        this._classNames = getClassNames(styles, {
+            theme: theme,
+            className: className,
+        });
+        var isTooltipVisible = this.state.isTooltipVisible;
+        var tooltipId = id || this._defaultTooltipId;
+        var tooltipRenderProps = tslib_1.__assign(tslib_1.__assign({ id: "".concat(tooltipId, "--tooltip"), content: content, targetElement: this._getTargetElement(), directionalHint: directionalHint, directionalHintForRTL: directionalHintForRTL, calloutProps: (0, Utilities_1.assign)({}, calloutProps, {
+                onDismiss: this._hideTooltip,
+                onFocus: this._onTooltipContentFocus,
+                onMouseEnter: this._onTooltipMouseEnter,
+                onMouseLeave: this._onTooltipMouseLeave,
+            }), onMouseEnter: this._onTooltipMouseEnter, onMouseLeave: this._onTooltipMouseLeave }, (0, Utilities_1.getNativeProps)(this.props, Utilities_1.divProperties, ['id'])), tooltipProps);
+        // Get the content of the tooltip for use in the hidden div used for screen readers
+        var tooltipContent = (tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.onRenderContent)
+            ? tooltipProps.onRenderContent(tooltipRenderProps, function (props) { return ((props === null || props === void 0 ? void 0 : props.content) ? React.createElement(React.Fragment, null, props.content) : null); })
+            : content;
+        var showTooltip = isTooltipVisible && !!tooltipContent;
+        var ariaDescribedBy = setAriaDescribedBy && isTooltipVisible && !!tooltipContent ? tooltipId : undefined;
+        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 },
+            children,
+            showTooltip && React.createElement(Tooltip_1.Tooltip, tslib_1.__assign({}, tooltipRenderProps)),
+            React.createElement("div", { hidden: true, id: tooltipId, style: Styling_1.hiddenContentStyle }, tooltipContent)));
+    };
+    TooltipHostBase.prototype.componentDidMount = function () {
+        this._async = new Utilities_1.Async(this);
+    };
+    TooltipHostBase.prototype.componentWillUnmount = function () {
+        if (TooltipHostBase._currentVisibleTooltip && TooltipHostBase._currentVisibleTooltip === this) {
+            TooltipHostBase._currentVisibleTooltip = undefined;
+        }
+        this._async.dispose();
+    };
+    TooltipHostBase.defaultProps = {
+        delay: Tooltip_types_1.TooltipDelay.medium,
+    };
+    TooltipHostBase.contextType = react_window_provider_1.WindowContext;
+    return TooltipHostBase;
+}(React.Component));
+exports.TooltipHostBase = TooltipHostBase;
+//# sourceMappingURL=TooltipHost.base.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { ITooltipHostProps } from './TooltipHost.types';
+export declare const TooltipHost: React.FunctionComponent<ITooltipHostProps>;

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipHost = void 0;
+var Utilities_1 = require("../../Utilities");
+var TooltipHost_base_1 = require("./TooltipHost.base");
+var TooltipHost_styles_1 = require("./TooltipHost.styles");
+exports.TooltipHost = (0, Utilities_1.styled)(TooltipHost_base_1.TooltipHostBase, TooltipHost_styles_1.getStyles, undefined, {
+    scope: 'TooltipHost',
+});
+//# sourceMappingURL=TooltipHost.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipHost.js","sourceRoot":"../src/","sources":["components/Tooltip/TooltipHost.ts"],"names":[],"mappings":";;;AACA,6CAAyC;AACzC,uDAAqD;AACrD,2DAAiD;AAGpC,QAAA,WAAW,GAA+C,IAAA,kBAAM,EAI3E,kCAAe,EAAE,8BAAS,EAAE,SAAS,EAAE;IACvC,KAAK,EAAE,aAAa;CACrB,CAAC,CAAC","sourcesContent":["import * as React from 'react';\nimport { styled } from '../../Utilities';\nimport { TooltipHostBase } from './TooltipHost.base';\nimport { getStyles } from './TooltipHost.styles';\nimport type { ITooltipHostProps, ITooltipHostStyleProps, ITooltipHostStyles } from './TooltipHost.types';\n\nexport const TooltipHost: React.FunctionComponent<ITooltipHostProps> = styled<\n  ITooltipHostProps,\n  ITooltipHostStyleProps,\n  ITooltipHostStyles\n>(TooltipHostBase, getStyles, undefined, {\n  scope: 'TooltipHost',\n});\n"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.styles.d.ts

@@ -0,0 +1,2 @@
+import type { ITooltipHostStyleProps, ITooltipHostStyles } from './TooltipHost.types';
+export declare const getStyles: (props: ITooltipHostStyleProps) => ITooltipHostStyles;

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.styles.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStyles = void 0;
+var Styling_1 = require("../../Styling");
+var GlobalClassNames = {
+    root: 'ms-TooltipHost',
+    ariaPlaceholder: 'ms-TooltipHost-aria-placeholder',
+};
+var getStyles = function (props) {
+    var className = props.className, theme = props.theme;
+    var classNames = (0, Styling_1.getGlobalClassNames)(GlobalClassNames, theme);
+    return {
+        root: [
+            classNames.root,
+            {
+                display: 'inline',
+            },
+            className,
+        ],
+    };
+};
+exports.getStyles = getStyles;
+//# sourceMappingURL=TooltipHost.styles.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TooltipHost.styles.js","sourceRoot":"../src/","sources":["components/Tooltip/TooltipHost.styles.ts"],"names":[],"mappings":";;;AAAA,yCAAoD;AAGpD,IAAM,gBAAgB,GAAG;IACvB,IAAI,EAAE,gBAAgB;IACtB,eAAe,EAAE,iCAAiC;CACnD,CAAC;AAEK,IAAM,SAAS,GAAG,UAAC,KAA6B;IAC7C,IAAA,SAAS,GAAY,KAAK,UAAjB,EAAE,KAAK,GAAK,KAAK,MAAV,CAAW;IACnC,IAAM,UAAU,GAAG,IAAA,6BAAmB,EAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;IAEhE,OAAO;QACL,IAAI,EAAE;YACJ,UAAU,CAAC,IAAI;YACf;gBACE,OAAO,EAAE,QAAQ;aAClB;YACD,SAAS;SACV;KACF,CAAC;AACJ,CAAC,CAAC;AAbW,QAAA,SAAS,aAapB","sourcesContent":["import { getGlobalClassNames } from '../../Styling';\nimport type { ITooltipHostStyleProps, ITooltipHostStyles } from './TooltipHost.types';\n\nconst GlobalClassNames = {\n  root: 'ms-TooltipHost',\n  ariaPlaceholder: 'ms-TooltipHost-aria-placeholder',\n};\n\nexport const getStyles = (props: ITooltipHostStyleProps): ITooltipHostStyles => {\n  const { className, theme } = props;\n  const classNames = getGlobalClassNames(GlobalClassNames, theme);\n\n  return {\n    root: [\n      classNames.root,\n      {\n        display: 'inline',\n      },\n      className,\n    ],\n  };\n};\n"]}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.types.d.ts

@@ -0,0 +1,140 @@
+import * as React from 'react';
+import { TooltipHostBase } from './TooltipHost.base';
+import { TooltipDelay } from './Tooltip.types';
+import { DirectionalHint } from '../../common/DirectionalHint';
+import type { ITooltipProps } from './Tooltip.types';
+import type { ICalloutProps } from '../../Callout';
+import type { IRefObject, IStyleFunctionOrObject } from '../../Utilities';
+import type { IStyle, ITheme } from '../../Styling';
+import type { JSXElement } from '@fluentui/utilities';
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipHost {
+    /**
+     * Shows the tooltip.
+     */
+    show: () => void;
+    /**
+     * Dismisses the tooltip.
+     */
+    dismiss: () => void;
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export declare enum TooltipOverflowMode {
+    /** Only show tooltip if parent DOM element is overflowing */
+    Parent = 0,
+    /**
+     * Only show tooltip if tooltip host's content is overflowing.
+     * Note that this does not check the children for overflow, only the TooltipHost root.
+     */
+    Self = 1
+}
+/**
+ * TooltipHost props. Note that native props (such as `id`, `className`, and `aria-` props) are
+ * passed through to the Tooltip itself, rather than being used on the host element.
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipHostProps extends Omit<React.HTMLAttributes<HTMLDivElement | TooltipHostBase>, 'content'> {
+    /**
+     * Optional callback to access the ITooltipHost interface. Use this instead of ref for accessing
+     * the public methods and properties of the component.
+     */
+    componentRef?: IRefObject<ITooltipHost>;
+    /**
+     * Additional properties to pass through for Callout.
+     */
+    calloutProps?: ICalloutProps;
+    /**
+     * Number of milliseconds to delay closing the tooltip, so that the user has time to hover over
+     * the tooltip and interact with it. Hovering over the tooltip will count as hovering over the
+     * host, so that the tooltip will stay open if the user is actively interacting with it.
+     */
+    closeDelay?: number;
+    /**
+     * Content to display in the Tooltip.
+     */
+    content?: string | JSXElement | JSXElement[];
+    /**
+     * Length of delay before showing the tooltip on hover.
+     * @defaultvalue TooltipDelay.medium
+     */
+    delay?: TooltipDelay;
+    /**
+     * How the tooltip should be anchored to its `targetElement`.
+     * @defaultvalue DirectionalHint.topCenter
+     */
+    directionalHint?: DirectionalHint;
+    /**
+     * How the element should be positioned in RTL layouts.
+     * If not specified, a mirror of `directionalHint` will be used.
+     */
+    directionalHintForRTL?: DirectionalHint;
+    /**
+     * Class name to apply to tooltip host.
+     */
+    hostClassName?: string;
+    /**
+     * Class name to apply to the *tooltip itself*, not the host.
+     * To apply a class to the host, use `hostClassName` or `styles.root`.
+     */
+    className?: string;
+    /**
+     * If this is unset (the default), the tooltip is always shown even if there's no overflow.
+     *
+     * If set, only show the tooltip if the specified element (`Self` or `Parent`) has overflow.
+     * When set to `Parent`, the parent element is also used as the tooltip's target element.
+     *
+     * Note that even with `Self` mode, the TooltipHost *does not* check whether any children have overflow.
+     */
+    overflowMode?: TooltipOverflowMode;
+    /**
+     * Whether or not to mark the TooltipHost root element as described by the tooltip.
+     * Since this applies aria-describedby to a generic <div>, the description will not be
+     * read by screen readers. Instead, the caller should pass an `id` to the TooltipHost
+     * (to be passed through to the Tooltip) and mark the appropriate element as `aria-describedby`
+     * with the `id`.
+     * @defaultvalue true
+     * @deprecated use aria-describedby on the appropriate element instead
+     */
+    setAriaDescribedBy?: boolean;
+    /**
+     * Additional properties to pass through for Tooltip.
+     */
+    tooltipProps?: ITooltipProps;
+    /**
+     * Optional ID to pass through to the tooltip (not used on the host itself).
+     * Auto-generated if not provided.
+     */
+    id?: string;
+    /**
+     * Call to provide customized styling that will layer on top of the variant rules.
+     */
+    styles?: IStyleFunctionOrObject<ITooltipHostStyleProps, ITooltipHostStyles>;
+    /**
+     * Theme provided by higher-order component.
+     */
+    theme?: ITheme;
+    /**
+     * Notifies when tooltip becomes visible or hidden, whatever the trigger was.
+     */
+    onTooltipToggle?(isTooltipVisible: boolean): void;
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipHostStyleProps {
+    theme: ITheme;
+    className?: string;
+}
+/**
+ * {@docCategory Tooltip}
+ */
+export interface ITooltipHostStyles {
+    /**
+     * Style for the host wrapper element.
+     */
+    root: IStyle;
+}

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/TooltipHost.types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooltipOverflowMode = void 0;
+/**
+ * {@docCategory Tooltip}
+ */
+var TooltipOverflowMode;
+(function (TooltipOverflowMode) {
+    /** Only show tooltip if parent DOM element is overflowing */
+    TooltipOverflowMode[TooltipOverflowMode["Parent"] = 0] = "Parent";
+    /**
+     * Only show tooltip if tooltip host's content is overflowing.
+     * Note that this does not check the children for overflow, only the TooltipHost root.
+     */
+    TooltipOverflowMode[TooltipOverflowMode["Self"] = 1] = "Self";
+})(TooltipOverflowMode || (exports.TooltipOverflowMode = TooltipOverflowMode = {}));
+//# sourceMappingURL=TooltipHost.types.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Tooltip';
+export * from './Tooltip.base';
+export * from './Tooltip.types';
+export * from './TooltipHost';
+export * from './TooltipHost.base';
+export * from './TooltipHost.types';

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Tooltip"), exports);
+tslib_1.__exportStar(require("./Tooltip.base"), exports);
+tslib_1.__exportStar(require("./Tooltip.types"), exports);
+tslib_1.__exportStar(require("./TooltipHost"), exports);
+tslib_1.__exportStar(require("./TooltipHost.base"), exports);
+tslib_1.__exportStar(require("./TooltipHost.types"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@fluentui/react/lib-commonjs/components/Tooltip/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"../src/","sources":["components/Tooltip/index.ts"],"names":[],"mappings":";;;AAAA,oDAA0B;AAC1B,yDAA+B;AAC/B,0DAAgC;AAChC,wDAA8B;AAC9B,6DAAmC;AACnC,8DAAoC","sourcesContent":["export * from './Tooltip';\nexport * from './Tooltip.base';\nexport * from './Tooltip.types';\nexport * from './TooltipHost';\nexport * from './TooltipHost.base';\nexport * from './TooltipHost.types';\n"]}