File Manager

Editing File: /home/ubuntu/voice-assistant-frontend/node_modules/react-tooltip/dist/react-tooltip.umd.js

/*
* React Tooltip
* {@link https://github.com/ReactTooltip/react-tooltip}
* @copyright ReactTooltip Team
* @license MIT
*/
(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('@floating-ui/dom'), require('classnames')) :
    typeof define === 'function' && define.amd ? define(['exports', 'react', '@floating-ui/dom', 'classnames'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactTooltip = {}, global.React, global.FloatingUIDOM, global.classNames));
})(this, (function (exports, React, dom, classNames) { 'use strict';

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
    var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);

// This is the ID for the core styles of ReactTooltip
    const REACT_TOOLTIP_CORE_STYLES_ID = 'react-tooltip-core-styles';
    // This is the ID for the visual styles of ReactTooltip
    const REACT_TOOLTIP_BASE_STYLES_ID = 'react-tooltip-base-styles';
    const injected = {
        core: false,
        base: false,
    };
    function injectStyle({ css, id = REACT_TOOLTIP_BASE_STYLES_ID, type = 'base', ref, }) {
        var _a, _b;
        if (!css || typeof document === 'undefined' || injected[type]) {
            return;
        }
        if (type === 'core' &&
            typeof process !== 'undefined' && // this validation prevents docs from breaking even with `process?`
            ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.REACT_TOOLTIP_DISABLE_CORE_STYLES)) {
            return;
        }
        if (type !== 'base' &&
            typeof process !== 'undefined' && // this validation prevents docs from breaking even with `process?`
            ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b.REACT_TOOLTIP_DISABLE_BASE_STYLES)) {
            return;
        }
        if (type === 'core') {
            // eslint-disable-next-line no-param-reassign
            id = REACT_TOOLTIP_CORE_STYLES_ID;
        }
        if (!ref) {
            // eslint-disable-next-line no-param-reassign
            ref = {};
        }
        const { insertAt } = ref;
        if (document.getElementById(id)) {
            // this should never happen because of `injected[type]`
            {
                // eslint-disable-next-line no-console
                console.warn(`[react-tooltip] Element with id '${id}' already exists. Call \`removeStyle()\` first`);
            }
            return;
        }
        const head = document.head || document.getElementsByTagName('head')[0];
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const style = document.createElement('style');
        style.id = id;
        style.type = 'text/css';
        if (insertAt === 'top') {
            if (head.firstChild) {
                head.insertBefore(style, head.firstChild);
            }
            else {
                head.appendChild(style);
            }
        }
        else {
            head.appendChild(style);
        }
        if (style.styleSheet) {
            style.styleSheet.cssText = css;
        }
        else {
            style.appendChild(document.createTextNode(css));
        }
        injected[type] = true;
    }
    /**
     * @deprecated Use the `disableStyleInjection` tooltip prop instead.
     * See https://react-tooltip.com/docs/examples/styling#disabling-reacttooltip-css
     */
    function removeStyle({ type = 'base', id = REACT_TOOLTIP_BASE_STYLES_ID, } = {}) {
        if (!injected[type]) {
            return;
        }
        if (type === 'core') {
            // eslint-disable-next-line no-param-reassign
            id = REACT_TOOLTIP_CORE_STYLES_ID;
        }
        const style = document.getElementById(id);
        if ((style === null || style === void 0 ? void 0 : style.tagName) === 'style') {
            style === null || style === void 0 ? void 0 : style.remove();
        }
        else {
            // eslint-disable-next-line no-console
            console.warn(`[react-tooltip] Failed to remove 'style' element with id '${id}'. Call \`injectStyle()\` first`);
        }
        injected[type] = false;
    }

const cssSupports = (property, value) => {
        const hasCssSupports = 'CSS' in window && 'supports' in window.CSS;
        return hasCssSupports ? window.CSS.supports(property, value) : true;
    };

const cssTimeToMs = (time) => {
        const match = time.match(/^([\d.]+)(ms|s)$/);
        if (!match) {
            return 0;
        }
        const [, amount, unit] = match;
        return Number(amount) * (unit === 'ms' ? 1 : 1000);
    };

/* eslint-disable @typescript-eslint/no-explicit-any */
    /**
     * This function debounce the received function
     * @param { function } 	func				Function to be debounced
     * @param { number } 		wait				Time to wait before execut the function
     * @param { boolean } 	immediate		Param to define if the function will be executed immediately
     */
    const debounce = (func, wait, immediate) => {
        let timeout = null;
        const debounced = function debounced(...args) {
            const later = () => {
                timeout = null;
                if (!immediate) {
                    func.apply(this, args);
                }
            };
            if (immediate && !timeout) {
                /**
                 * there's no need to clear the timeout
                 * since we expect it to resolve and set `timeout = null`
                 */
                func.apply(this, args);
                timeout = setTimeout(later, wait);
            }
            if (!immediate) {
                if (timeout) {
                    clearTimeout(timeout);
                }
                timeout = setTimeout(later, wait);
            }
        };
        debounced.cancel = () => {
            /* c8 ignore start */
            if (!timeout) {
                return;
            }
            /* c8 ignore end */
            clearTimeout(timeout);
            timeout = null;
        };
        return debounced;
    };

const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;

/**
     * @deprecated Use the `data-tooltip-id` attribute, or the `anchorSelect` prop instead.
     * See https://react-tooltip.com/docs/getting-started
     */
    const TooltipWrapper = ({ tooltipId, children, className, place, content, html, variant, offset, wrapper, events, positionStrategy, delayShow, delayHide, }) => {
        const { attach, detach } = useTooltip(tooltipId);
        const anchorRef = React.useRef(null);
        React.useEffect(() => {
            attach(anchorRef);
            return () => {
                detach(anchorRef);
            };
        }, []);
        return (React__default["default"].createElement("span", { ref: anchorRef, className: classNames__default["default"]('react-tooltip-wrapper', className), "data-tooltip-place": place, "data-tooltip-content": content, "data-tooltip-html": html, "data-tooltip-variant": variant, "data-tooltip-offset": offset, "data-tooltip-wrapper": wrapper, "data-tooltip-events": events, "data-tooltip-position-strategy": positionStrategy, "data-tooltip-delay-show": delayShow, "data-tooltip-delay-hide": delayHide }, children));
    };

var coreStyles = {"tooltip":"core-styles-module_tooltip__3vRRp","fixed":"core-styles-module_fixed__pcSol","arrow":"core-styles-module_arrow__cvMwQ","noArrow":"core-styles-module_noArrow__xock6","clickable":"core-styles-module_clickable__ZuTTB","show":"core-styles-module_show__Nt9eE","closing":"core-styles-module_closing__sGnxF"};

var styles = {"tooltip":"styles-module_tooltip__mnnfp","arrow":"styles-module_arrow__K0L3T","dark":"styles-module_dark__xNqje","light":"styles-module_light__Z6W-X","success":"styles-module_success__A2AKt","warning":"styles-module_warning__SCK0X","error":"styles-module_error__JvumD","info":"styles-module_info__BWdHW"};

/* eslint-disable react/no-danger */
    const TooltipContent = ({ content }) => {
        return React__default["default"].createElement("span", { dangerouslySetInnerHTML: { __html: content } });
    };

// those content will be replaced in build time with the `react-tooltip.css` builded content
    const TooltipCoreStyles = `:root {
  --rt-color-white: #fff;
  --rt-color-dark: #222;
  --rt-color-success: #8dc572;
  --rt-color-error: #be6464;
  --rt-color-warning: #f0ad4e;
  --rt-color-info: #337ab7;
  --rt-opacity: 0.9;
  --rt-transition-show-delay: 0.15s;
  --rt-transition-closing-delay: 0.15s;
}

.core-styles-module_tooltip__3vRRp {
  position: absolute;
  top: 0;
  left: 0;
  pointer-events: none;
  opacity: 0;
  will-change: opacity;
}

.core-styles-module_fixed__pcSol {
  position: fixed;
}

.core-styles-module_arrow__cvMwQ {
  position: absolute;
  background: inherit;
}

.core-styles-module_noArrow__xock6 {
  display: none;
}

.core-styles-module_clickable__ZuTTB {
  pointer-events: auto;
}

.core-styles-module_show__Nt9eE {
  opacity: var(--rt-opacity);
  transition: opacity var(--rt-transition-show-delay) ease-out;
}

.core-styles-module_closing__sGnxF {
  opacity: 0;
  transition: opacity var(--rt-transition-closing-delay) ease-in;
}

`;
    const TooltipStyles = `

.styles-module_tooltip__mnnfp {
  padding: 8px 16px;
  border-radius: 3px;
  font-size: 90%;
  width: max-content;
}

.styles-module_arrow__K0L3T {
  width: 8px;
  height: 8px;
}

[class*='react-tooltip__place-top'] > .styles-module_arrow__K0L3T {
  transform: rotate(45deg);
}

[class*='react-tooltip__place-right'] > .styles-module_arrow__K0L3T {
  transform: rotate(135deg);
}

[class*='react-tooltip__place-bottom'] > .styles-module_arrow__K0L3T {
  transform: rotate(225deg);
}

[class*='react-tooltip__place-left'] > .styles-module_arrow__K0L3T {
  transform: rotate(315deg);
}

/** Types variant **/
.styles-module_dark__xNqje {
  background: var(--rt-color-dark);
  color: var(--rt-color-white);
}

.styles-module_light__Z6W-X {
  background-color: var(--rt-color-white);
  color: var(--rt-color-dark);
}

.styles-module_success__A2AKt {
  background-color: var(--rt-color-success);
  color: var(--rt-color-white);
}

.styles-module_warning__SCK0X {
  background-color: var(--rt-color-warning);
  color: var(--rt-color-white);
}

.styles-module_error__JvumD {
  background-color: var(--rt-color-error);
  color: var(--rt-color-white);
}

.styles-module_info__BWdHW {
  background-color: var(--rt-color-info);
  color: var(--rt-color-white);
}
`;
    if (typeof window !== 'undefined') {
        window.addEventListener('react-tooltip-inject-styles', ((event) => {
            if (!event.detail.disableCore) {
                injectStyle({ css: TooltipCoreStyles, type: 'core' });
            }
            if (!event.detail.disableBase) {
                injectStyle({ css: TooltipStyles, type: 'base' });
            }
        }));
    }

exports.Tooltip = TooltipController;
    exports.TooltipProvider = TooltipProvider;
    exports.TooltipWrapper = TooltipWrapper;
    exports.removeStyle = removeStyle;

Object.defineProperty(exports, '__esModule', { value: true });

}));

Back to Directory File Manager