@progress/kendo-react-tooltip 6.1.1 → 7.0.0-develop.10

package/dist/es/tooltip/Tooltip.d.ts

@@ -1,85 +0,0 @@
-import * as React from 'react';
-import * as PropTypes from 'prop-types';
-import { ZIndexContext } from '@progress/kendo-react-common';
-import { TooltipProps } from './TooltipProps';
-/**
- * @hidden
- */
-interface TooltipState {
-    targetElement: HTMLElement | null;
-    open: boolean;
-    title: string;
-}
-export declare class Tooltip extends React.PureComponent<TooltipProps, TooltipState> {
-    /**
-     * @hidden
-     */
-    static propTypes: {
-        anchorElement: PropTypes.Requireable<string>;
-        content: PropTypes.Requireable<(...args: any[]) => any>;
-        filter: PropTypes.Requireable<(...args: any[]) => any>;
-        openDelay: PropTypes.Requireable<number>;
-        position: PropTypes.Requireable<string>;
-        updateInterval: PropTypes.Requireable<number>;
-    };
-    static defaultProps: {
-        anchorElement: string;
-        openDelay: number;
-        position: string;
-        showCallout: boolean;
-        parentTitle: boolean;
-    };
-    /**
-     * @hidden
-     */
-    static contextType: React.Context<import("@progress/kendo-react-common").ZIndexContextType>;
-    /**
-     * @hidden
-     */
-    context: React.ContextType<typeof ZIndexContext>;
-    /**
-     * @hidden
-     */
-    readonly state: TooltipState;
-    private top;
-    private left;
-    private openTimeoutId?;
-    private updateIntervalId?;
-    private willOpen;
-    constructor(props: TooltipProps);
-    /**
-     * @hidden
-     */
-    componentDidMount(): void;
-    /**
-     * @hidden
-     */
-    componentWillUnmount(): void;
-    /**
-     * @hidden
-     */
-    componentDidUpdate(): void;
-    /**
-     * The method is used on the MouseOut event to hide the Tooltip.
-     */
-    handleMouseOut: (event: any) => void;
-    /**
-     * Used on the `MouseOver` event to show the Tooltip.
-     */
-    handleMouseOver: (event: any) => void;
-    /**
-     * @hidden
-     */
-    render(): "" | JSX.Element | null;
-    private handleBodyMousemove;
-    private onClose;
-    private showToolTip;
-    private setUpdateInterval;
-    private onIntervalUpdate;
-    private isVisible;
-    private position;
-    private getTitle;
-    private calloutClassName;
-    private getCurrentZIndex;
-}
-export {};

package/dist/es/tooltip/Tooltip.js

@@ -1,313 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import * as React from 'react';
-import * as ReactDOM from 'react-dom';
-import * as PropTypes from 'prop-types';
-import { dispatchEvent, classNames, ZIndexContext } from '@progress/kendo-react-common';
-import { getLeftPosition, getTopPosition, getDomRect, isTooltipElement } from './utils';
-import { validatePackage } from '@progress/kendo-react-common';
-import { packageMetadata } from './../package-metadata';
-var DEFAULT_TOOLTIP_ZINDEX = 100;
-var Tooltip = /** @class */ (function (_super) {
-    __extends(Tooltip, _super);
-    function Tooltip(props) {
-        var _this = _super.call(this, props) || this;
-        /**
-         * @hidden
-         */
-        _this.context = 0;
-        /**
-         * @hidden
-         */
-        _this.state = {
-            targetElement: null,
-            open: false,
-            title: ''
-        };
-        _this.top = 0;
-        _this.left = 0;
-        _this.willOpen = false;
-        /**
-         * The method is used on the MouseOut event to hide the Tooltip.
-         */
-        _this.handleMouseOut = function (event) {
-            var targetElement = _this.state.targetElement;
-            var currentDocument = targetElement ? targetElement.ownerDocument : document;
-            var element = currentDocument && currentDocument.elementFromPoint(event.clientX, event.clientY);
-            if (isTooltipElement(element)) {
-                return;
-            }
-            if (_this.props.open) {
-                return;
-            }
-            clearInterval(_this.updateIntervalId);
-            _this.willOpen = false;
-            _this.onClose(event);
-        };
-        /**
-         * Used on the `MouseOver` event to show the Tooltip.
-         */
-        _this.handleMouseOver = function (event) {
-            var target = event.target;
-            if (!_this.isVisible(target) || isTooltipElement(target) || target === _this.state.targetElement) {
-                return;
-            }
-            _this.showToolTip(event);
-        };
-        _this.handleBodyMousemove = function (event) {
-            _this.top = event.clientY;
-            _this.left = event.clientX;
-        };
-        _this.onClose = function (event) {
-            dispatchEvent(_this.props.onClose, event, _this, undefined);
-            _this.setState({ targetElement: null, open: false, title: '' });
-        };
-        _this.setUpdateInterval = function () {
-            if (_this.props.updateInterval) {
-                _this.updateIntervalId = setInterval(_this.onIntervalUpdate, _this.props.updateInterval);
-            }
-        };
-        _this.onIntervalUpdate = function () {
-            var target = _this.state.targetElement;
-            if (!target) {
-                return;
-            }
-            if (target.parentElement === null) {
-                // Getting element from previous target coordinates will cause reflow which is performance hit.
-                // Also remount case can be avoided easily
-                _this.onClose({ target: target });
-            }
-            else {
-                _this.showToolTip({ target: target });
-            }
-        };
-        _this.position = function (element) {
-            var domRect = getDomRect(_this.state.targetElement);
-            var left = getLeftPosition(_this.left, element.offsetWidth, domRect, _this.props.anchorElement, _this.props.position);
-            var top = getTopPosition(_this.top, domRect, element.offsetHeight, _this.props.anchorElement, _this.props.position);
-            return { left: left, top: top };
-        };
-        _this.getTitle = function (element) {
-            while (element) {
-                if (element.getAttribute('title') !== null || element.titleExpando) {
-                    var title = element.getAttribute('title') || element.titleExpando;
-                    return { title: title, element: element };
-                }
-                element = _this.props.parentTitle && element.parentElement || null;
-            }
-            return { title: '', element: element };
-        };
-        _this.calloutClassName = function () {
-            switch (_this.props.position) {
-                case 'bottom':
-                    return 'k-callout k-callout-n';
-                case 'left':
-                    return 'k-callout k-callout-e';
-                case 'right':
-                    return 'k-callout k-callout-w';
-                case 'top':
-                    return 'k-callout k-callout-s';
-                default:
-                    return _this.top < (window.innerHeight / 2) ? 'k-callout k-callout-n' : 'k-callout k-callout-s';
-            }
-        };
-        _this.getCurrentZIndex = function () {
-            return _this.context ? _this.context : DEFAULT_TOOLTIP_ZINDEX;
-        };
-        validatePackage(packageMetadata);
-        return _this;
-    }
-    /**
-     * @hidden
-     */
-    Tooltip.prototype.componentDidMount = function () {
-        if (document) {
-            document.body.addEventListener('mousemove', this.handleBodyMousemove);
-        }
-    };
-    /**
-     * @hidden
-     */
-    Tooltip.prototype.componentWillUnmount = function () {
-        clearTimeout(this.openTimeoutId);
-        clearInterval(this.updateIntervalId);
-        if (document) {
-            document.body.removeEventListener('mousemove', this.handleBodyMousemove);
-        }
-    };
-    /**
-     * @hidden
-     */
-    Tooltip.prototype.componentDidUpdate = function () {
-        if (this.props.open && this.props.targetElement) {
-            this.showToolTip({ target: this.props.targetElement });
-        }
-    };
-    /**
-     * @hidden
-     */
-    Tooltip.prototype.render = function () {
-        var _this = this;
-        if (this.props.children) {
-            var _a = this.props, children = _a.children, options = __rest(_a, ["children"]);
-            var tooltip_1 = null;
-            return (React.createElement("div", { onMouseOver: function (event) { if (tooltip_1) {
-                    tooltip_1.handleMouseOver(event);
-                } }, onMouseOut: function (event) { if (tooltip_1) {
-                    tooltip_1.handleMouseOut(event);
-                } } },
-                React.createElement(Tooltip, __assign({ ref: function (el) { return tooltip_1 = el; } }, options)),
-                children));
-        }
-        if (this.props.open === false) {
-            return null;
-        }
-        var targetElement = this.state.targetElement;
-        var currentZIndex = this.getCurrentZIndex();
-        return targetElement &&
-            this.state.title &&
-            targetElement.ownerDocument &&
-            ReactDOM.createPortal((React.createElement("div", { ref: function (el) {
-                    if (!el) {
-                        return;
-                    }
-                    var position;
-                    if (_this.props.onPosition) {
-                        var ev = {
-                            element: el,
-                            targetElement: _this.state.targetElement,
-                            mouseTop: _this.top,
-                            mouseLeft: _this.left,
-                            anchorElement: _this.props.anchorElement,
-                            position: _this.props.position,
-                            target: _this,
-                            syntheticEvent: null,
-                            nativeEvent: null
-                        };
-                        position = _this.props.onPosition.call(undefined, ev);
-                    }
-                    else {
-                        position = _this.position(el);
-                    }
-                    el.style.left = position.left + 'px';
-                    el.style.top = position.top + 'px';
-                }, className: classNames('k-animation-container', 'k-animation-container-fixed', 'k-animation-container-shown', this.props.className), style: __assign({ zIndex: currentZIndex }, this.props.style), tabIndex: 0 },
-                React.createElement("div", { className: 'k-child-animation-container' },
-                    React.createElement("div", { id: this.props.id, role: 'tooltip', className: classNames('k-tooltip', this.props.tooltipClassName), style: __assign({ position: 'relative' }, this.props.tooltipStyle) },
-                        React.createElement("div", { className: "k-tooltip-content" }, this.props.content &&
-                            React.createElement(this.props.content, { title: this.state.title, target: this.state.targetElement })
-                            || this.state.title),
-                        this.props.showCallout && React.createElement("div", { ref: function (el) {
-                                if (!el) {
-                                    return;
-                                }
-                                el.className = _this.calloutClassName();
-                                if (_this.props.position === 'auto') {
-                                    _this.left < (window.screen.availWidth / 2)
-                                        ? el.style.left = _this.props.setCalloutOnPositionAuto || '25%'
-                                        : el.style.left = _this.props.setCalloutOnPositionAuto || '75%';
-                                }
-                            } }))))), this.props.appendTo ? this.props.appendTo : targetElement.ownerDocument.body);
-    };
-    Tooltip.prototype.showToolTip = function (event) {
-        var _this = this;
-        clearTimeout(this.openTimeoutId);
-        clearInterval(this.updateIntervalId);
-        if (event.target.hasChildNodes()) {
-            event.target.childNodes.forEach(function (childElement) {
-                if (childElement.nodeName === 'title') {
-                    event.target.titleExpando = childElement.innerHTML;
-                    childElement.remove();
-                }
-            });
-        }
-        var target = this.props.targetElement || event.target;
-        var titleResult = this.getTitle(target);
-        if (!titleResult.title) {
-            if (this.state.open) {
-                this.onClose(event);
-            }
-            return;
-        }
-        if (titleResult.element) {
-            titleResult.element.titleExpando = titleResult.title;
-            titleResult.element.title = '';
-        }
-        this.willOpen = true;
-        if (!this.props.openDelay) {
-            this.setState({ targetElement: target, open: true, title: titleResult.title }, this.setUpdateInterval);
-        }
-        else {
-            this.openTimeoutId = window.setTimeout(function () {
-                if (_this.willOpen) {
-                    _this.setState({ targetElement: target, open: true, title: titleResult.title }, _this.setUpdateInterval);
-                }
-            }, this.props.openDelay);
-        }
-        if (this.state.title !== titleResult.title) {
-            dispatchEvent(this.props.onOpen, event, this, undefined);
-        }
-    };
-    Tooltip.prototype.isVisible = function (element) {
-        return !this.props.filter || this.props.filter(element);
-    };
-    /**
-     * @hidden
-     */
-    Tooltip.propTypes = {
-        anchorElement: PropTypes.oneOf(['pointer', 'target']),
-        content: PropTypes.func,
-        filter: PropTypes.func,
-        openDelay: PropTypes.number,
-        position: PropTypes.oneOf(['right', 'left', 'top', 'bottom', 'auto']),
-        updateInterval: PropTypes.number
-    };
-    Tooltip.defaultProps = {
-        anchorElement: 'pointer',
-        openDelay: 400,
-        position: 'auto',
-        showCallout: true,
-        parentTitle: false
-    };
-    /**
-     * @hidden
-     */
-    Tooltip.contextType = ZIndexContext;
-    return Tooltip;
-}(React.PureComponent));
-export { Tooltip };

package/dist/es/tooltip/TooltipProps.d.ts

@@ -1,109 +0,0 @@
-/// <reference types="react" />
-import { TooltipEvent, TooltipPositionEvent } from './events';
-import { TooltipPosition } from './utils';
-/**
- * Represents the props of the [KendoReact Tooltip component]({% slug overview_tooltip %}).
- */
-export interface TooltipProps {
-    /**
-     * Specifies the `id` of the wrapping element of the Tooltip component.
-     */
-    id?: string;
-    /**
-     * Sets the anchor element of the Tooltip.
-     *
-     * The available options are:
-     * - (Default) `pointer`&mdash;Shows a Tooltip where the cursor is located.
-     * - `target`&mdash;Positions the Tooltip based on the anchor element.
-     */
-    anchorElement?: string;
-    /**
-     * Defines the container to which the Tooltip will be appended. Defaults to [`body`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body).
-     */
-    appendTo?: HTMLElement | null;
-    /**
-     * Sets the position of the Tooltip ([see example]({% slug positioning_tooltip %})).
-     *
-     * The available options are:
-     * - (Default) `auto`&mdash;Positions the Tooltip depending on the available space.
-     * - `right`&mdash;Positions the Tooltip to the right side of the element.
-     * - `left`&mdash;Positions the Tooltip to the left side of the element.
-     * - `bottom`&mdash;Positions the Tooltip at the bottom of the element.
-     * - `top`&mdash;Positions the Tooltip at the top of the element.
-     */
-    position?: TooltipPosition;
-    /**
-     * Sets a class of the Tooltip animation container.
-     */
-    className?: string;
-    /**
-     * Sets the content of the Tooltip ([see example]({% slug templates_tooltip %})).
-     */
-    content?: any;
-    /**
-     * Sets the content of the Tooltip.
-     */
-    children?: any;
-    /**
-     * Specifies if the Tooltip will be open.
-     * Sets the Tooltip in its controlled mode ([see example]({% slug controlledmode_tooltip %})).
-     * Requires you to set the `targetElement` property.
-     */
-    open?: boolean;
-    /**
-     * Sets a delay in milliseconds.
-     */
-    openDelay?: number;
-    /**
-     * If any of the parent elements has a title, displays a Tooltip.
-     */
-    parentTitle?: boolean;
-    /**
-     * Specifies if the Tooltip callout will be displayed.
-     */
-    showCallout?: boolean;
-    /**
-     * When the position is set to `auto`, sets the start point of the Tooltip callout (in pixels).
-     */
-    setCalloutOnPositionAuto?: any;
-    /**
-     * Specifies the styles which are set to the Tooltip animation container.
-     */
-    style?: React.CSSProperties;
-    /**
-     * Sets the Tooltip target element. You have to use it with the `open` property.
-     */
-    targetElement?: any;
-    /**
-     * Specifies the CSS class names which are set to the Tooltip DOM element.
-     */
-    tooltipClassName?: string;
-    /**
-     * Specifies the styles which are set to the Tooltip DOM element.
-     */
-    tooltipStyle?: React.CSSProperties;
-    /**
-     * Fires when the Tooltip is shown.
-     */
-    onOpen?: (event: TooltipEvent) => void;
-    /**
-     * Fires when the Tooltip is hidden.
-     */
-    onClose?: (event: TooltipEvent) => void;
-    /**
-     * Callback called when the Tooltip calculates it's position. Useful to modify the default position behavior.
-     * Require to return the `top` and `left` position of the Tooltip.
-     */
-    onPosition?: (event: TooltipPositionEvent) => {
-        top: number;
-        left: number;
-    };
-    /**
-     * Represents a callback function which determines if a Tooltip will be displayed ([see example]({% slug filter_elements_tooltip %})).
-     */
-    filter?: (target: HTMLElement) => void;
-    /**
-     * The milliseconds interval on which the Tooltip will check for title change. By default the Tooltip does not track for title updates.
-     */
-    updateInterval?: number;
-}

package/dist/es/tooltip/TooltipProps.js

@@ -1,2 +0,0 @@
-export {};
-// tslint:enable:max-line-length

package/dist/es/tooltip/events.js

@@ -1 +0,0 @@
-export {};

package/dist/es/tooltip/utils.d.ts

@@ -1,24 +0,0 @@
-/**
- * @hidden
- */
-export declare type TooltipPosition = 'right' | 'left' | 'bottom' | 'top' | 'auto';
-/**
- * @hidden
- */
-export declare const getLeftPosition: (left: any, elementWidth: any, targetElement: any, anchorElement: any, position: any) => any;
-/**
- * @hidden
- */
-export declare const getTopPosition: (top: any, targetElement: any, elementHeight: any, anchorElement: any, position: any) => any;
-/**
- * @hidden
- */
-export declare const getDomRect: (currentTarget: any) => any;
-/**
- * @hidden
- */
-export declare const toolTipSelectors: string[];
-/**
- * @hidden
- */
-export declare const isTooltipElement: (element: any) => boolean;

package/dist/es/tooltip/utils.js

@@ -1,106 +0,0 @@
-var arrowWidth = 10;
-var arrowHeight = 10;
-/**
- * @hidden
- */
-export var getLeftPosition = function (left, elementWidth, targetElement, anchorElement, position) {
-    switch (position) {
-        case 'bottom':
-            return anchorElement === 'pointer'
-                ? left - (elementWidth / 2)
-                : targetElement.left - (elementWidth / 2) + targetElement.width / 2;
-        case 'left':
-            return anchorElement === 'pointer'
-                ? left - elementWidth - arrowWidth
-                : targetElement.left - elementWidth - arrowWidth;
-        case 'right':
-            return anchorElement === 'pointer'
-                ? left + arrowWidth
-                : targetElement.right + arrowWidth;
-        case 'top':
-            return anchorElement === 'pointer'
-                ? left - (elementWidth / 2)
-                : targetElement.left - (elementWidth / 2) + targetElement.width / 2;
-        default:
-            if (anchorElement === 'pointer') {
-                return left < (window.screen.availWidth / 2)
-                    ? left - arrowWidth
-                    : left - elementWidth + arrowWidth;
-            }
-            else {
-                return left < (window.screen.availWidth / 2)
-                    ? targetElement.left
-                    : targetElement.right - elementWidth;
-            }
-    }
-};
-/**
- * @hidden
- */
-export var getTopPosition = function (top, targetElement, elementHeight, anchorElement, position) {
-    switch (position) {
-        case 'bottom':
-            return anchorElement === 'pointer'
-                ? top + arrowHeight
-                : targetElement.bottom + arrowHeight;
-        case 'left':
-            return anchorElement === 'pointer'
-                ? top - (elementHeight / 2)
-                : targetElement.top - (elementHeight / 2) + (targetElement.height / 2);
-        case 'right':
-            return anchorElement === 'pointer'
-                ? top - (elementHeight / 2)
-                : targetElement.top - (elementHeight / 2) + (targetElement.height / 2);
-        case 'top':
-            return anchorElement === 'pointer'
-                ? top - elementHeight - arrowHeight
-                : targetElement.top - elementHeight - arrowHeight;
-        default:
-            if (anchorElement === 'pointer') {
-                return top < (window.innerHeight / 2)
-                    ? top + arrowWidth
-                    : top - elementHeight - arrowWidth;
-            }
-            else {
-                return top < (window.innerHeight / 2)
-                    ? targetElement.bottom + arrowHeight
-                    : targetElement.top - elementHeight - arrowHeight;
-            }
-    }
-};
-/**
- * @hidden
- */
-export var getDomRect = function (currentTarget) {
-    if (currentTarget !== null) {
-        return currentTarget.getBoundingClientRect();
-    }
-    return document.body.getBoundingClientRect();
-};
-/**
- * @hidden
- */
-export var toolTipSelectors = [
-    'k-tooltip-content',
-    'k-animation-container',
-    'k-tooltip',
-    'k-tooltip-title',
-    'k-tooltip k-tooltip-closable',
-    'k-icon k-i-close'
-];
-/**
- * @hidden
- */
-export var isTooltipElement = function (element) {
-    if (element === null) {
-        return false;
-    }
-    var node = element;
-    while (node) {
-        if (node !== null && node.classList && node.classList.contains('k-tooltip')) {
-            return true;
-        }
-        node.parentNode !== null ? node = node.parentNode : node = false;
-    }
-    return toolTipSelectors.filter(function (t) { return t === element.className; }).length > 0;
-};

package/dist/npm/main.d.ts

@@ -1,19 +0,0 @@
-import { Tooltip } from './tooltip/Tooltip';
-import { TooltipProps } from './tooltip/TooltipProps';
-import { TooltipEvent, TooltipPositionEvent } from './tooltip/events';
-import { TooltipPosition } from './tooltip/utils';
-import { PopoverCollision } from './popover/interfaces/PopoverCollision';
-import { PopoverMargin } from './popover/interfaces/PopoverMargin';
-import { PopoverOffset } from './popover/interfaces/PopoverOffset';
-import { PopoverOpenEvent } from './popover/interfaces/PopoverOpenEvent';
-import { PopoverCloseEvent } from './popover/interfaces/PopoverCloseEvent';
-import { PopoverPositionEvent } from './popover/interfaces/PopoverPositionEvent';
-import { PopoverAnimation } from './popover/interfaces/PopoverAnimation';
-import { PopoverPosition } from './popover/interfaces/PopoverPosition';
-import { PopoverPositionMode } from './popover/interfaces/PopoverPositionMode';
-import { PopoverProps } from './popover/interfaces/PopoverProps';
-import { Popover, PopoverHandle } from './popover/Popover';
-import { PopoverActionsBar, PopoverActionsBarHandle } from './popover/PopoverActionsBar';
-import { PopoverActionsBarProps } from './popover/interfaces/PopoverActionsBarProps';
-import { PopoverCollisionType } from './popover/interfaces/PopoverCollisionType';
-export { Tooltip, TooltipEvent, TooltipPositionEvent, TooltipProps, TooltipPosition, PopoverCollision, PopoverCollisionType, PopoverMargin, PopoverOffset, PopoverPosition, PopoverPositionMode, PopoverAnimation, PopoverOpenEvent, PopoverCloseEvent, PopoverPositionEvent, PopoverProps, PopoverHandle, Popover, PopoverActionsBarProps, PopoverActionsBarHandle, PopoverActionsBar };

package/dist/npm/main.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PopoverActionsBar = exports.Popover = exports.Tooltip = void 0;
-var Tooltip_1 = require("./tooltip/Tooltip");
-Object.defineProperty(exports, "Tooltip", { enumerable: true, get: function () { return Tooltip_1.Tooltip; } });
-var Popover_1 = require("./popover/Popover");
-Object.defineProperty(exports, "Popover", { enumerable: true, get: function () { return Popover_1.Popover; } });
-var PopoverActionsBar_1 = require("./popover/PopoverActionsBar");
-Object.defineProperty(exports, "PopoverActionsBar", { enumerable: true, get: function () { return PopoverActionsBar_1.PopoverActionsBar; } });

package/dist/npm/package-metadata.d.ts

@@ -1,5 +0,0 @@
-import { PackageMetadata } from '@progress/kendo-licensing';
-/**
- * @hidden
- */
-export declare const packageMetadata: PackageMetadata;