@mgdis/mg-components 5.19.2 → 5.20.0

package/dist/components/mg-tooltip2.js

@@ -1,13 +1,13 @@
 import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
-import { c as createID, i as isValidString, g as getWindows, f as focusableElements } from './components.utils.js';
+import { n as nextTick, c as createID, i as isValidString, g as getWindows, f as focusableElements } from './components.utils.js';
 import { d as defineCustomElement$1 } from './mg-tooltip-content2.js';
 import { c as createPopper } from './popper.js';
 
 var Guard;
 (function (Guard) {
-  Guard["FOCUS"] = "focus";
-  Guard["HOVER_TOOLTIP_ELEMENT"] = "hoverTooltipGuard";
-  Guard["HOVER_TOOLTIPED_ELEMENT"] = "hoverTooltipedGuard";
+    Guard["FOCUS"] = "focus";
+    Guard["HOVER_TOOLTIP_ELEMENT"] = "hoverTooltipGuard";
+    Guard["HOVER_TOOLTIPED_ELEMENT"] = "hoverTooltipedGuard";
 })(Guard || (Guard = {}));
 
 const mgTooltipCss = ":host{display:inline-block}";
@@ -19,332 +19,332 @@ const mgTooltipCss = ":host{display:inline-block}";
  */
 const isButton = (element) => typeof element === 'object' && ['MG-BUTTON', 'BUTTON'].includes(element.tagName);
 const MgTooltip = /*@__PURE__*/ proxyCustomElement(class MgTooltip extends HTMLElement {
-  constructor() {
-    super();
-    this.__registerHost();
-    this.__attachShadow();
-    /**
-     * Show tooltip
-     */
-    this.show = () => {
-      // Make the tooltip visible
-      this.mgTooltipContent.dataset.show = '';
-      // Enable the event listeners
-      this.popper.setOptions(options => (Object.assign(Object.assign({}, options), { modifiers: [...options.modifiers, { name: 'eventListeners', enabled: true }] })));
-      // hide when click outside
-      // setTimeout is used to prevent event to trigger after creation
-      setTimeout(() => {
-        this.windows.forEach((localWindow) => {
-          localWindow.addEventListener('click', this.clickOutside, false);
-          localWindow.addEventListener('keydown', this.pressEscape, false);
-        });
-      }, 0);
-    };
-    /**
-     * Hide tooltip
-     */
-    this.hide = () => {
-      // Hide the tooltip
-      this.mgTooltipContent.removeAttribute('data-show');
-      // Disable the event listeners
-      this.popper.setOptions(options => (Object.assign(Object.assign({}, options), { modifiers: [...options.modifiers, { name: 'eventListeners', enabled: false }] })));
-      // Remove event listener
-      this.windows.forEach((localWindow) => {
-        localWindow.removeEventListener('click', this.clickOutside, false);
-        localWindow.removeEventListener('keyboard', this.pressEscape, false);
-      });
-    };
-    /**
-     * Check if clicked outside of component and hidde tooltip
-     * @param event - mouse event
-     */
-    this.clickOutside = (event) => {
-      if (event.target.closest('mg-tooltip') !== this.element)
-        this.setDisplay(false);
-    };
-    /**
-     * Check if 'Escape' key is pressed of component and hidde tooltip
-     * @param event - keyboard event
-     */
-    this.pressEscape = (event) => {
-      if (event.code === 'Escape') {
-        this.setDisplay(false);
-        this.resetGuard();
-      }
-    };
-    /**
-     * Method to set display prop
-     * @param newValue - display prop new value
-     * @param condition - additionnal condition to apply display prop newValue
-     */
-    this.setDisplay = (newValue, condition = true) => {
-      if (!this.disabled && condition)
-        this.display = newValue;
-    };
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        /**
+         * Show tooltip
+         */
+        this.show = () => {
+            // Make the tooltip visible
+            this.mgTooltipContent.dataset.show = '';
+            // Enable the event listeners
+            this.popper.setOptions(options => (Object.assign(Object.assign({}, options), { modifiers: [...options.modifiers, { name: 'eventListeners', enabled: true }] })));
+            // hide when click outside on nextTick to prevent event to trigger after creation
+            nextTick(() => {
+                this.windows.forEach((localWindow) => {
+                    localWindow.addEventListener('click', this.clickOutside, false);
+                    localWindow.addEventListener('keydown', this.pressEscape, false);
+                });
+            });
+        };
+        /**
+         * Hide tooltip
+         */
+        this.hide = () => {
+            // Hide the tooltip
+            this.mgTooltipContent.removeAttribute('data-show');
+            // Disable the event listeners
+            this.popper.setOptions(options => (Object.assign(Object.assign({}, options), { modifiers: [...options.modifiers, { name: 'eventListeners', enabled: false }] })));
+            // Remove event listener
+            this.windows.forEach((localWindow) => {
+                localWindow.removeEventListener('click', this.clickOutside, false);
+                localWindow.removeEventListener('keyboard', this.pressEscape, false);
+            });
+        };
+        /**
+         * Check if clicked outside of component and hidde tooltip
+         * @param event - mouse event
+         */
+        this.clickOutside = (event) => {
+            if (event.target.closest('mg-tooltip') !== this.element)
+                this.setDisplay(false);
+        };
+        /**
+         * Check if 'Escape' key is pressed of component and hidde tooltip
+         * @param event - keyboard event
+         */
+        this.pressEscape = (event) => {
+            if (event.code === 'Escape') {
+                this.setDisplay(false);
+                this.resetGuard();
+            }
+        };
+        /**
+         * Method to set display prop
+         * @param newValue - display prop new value
+         * @param condition - additionnal condition to apply display prop newValue
+         */
+        this.setDisplay = (newValue, condition = true) => {
+            if (!this.disabled && condition)
+                this.display = newValue;
+        };
+        /**
+         * Action for tooltip element and tooltiped element mouse listener
+         * @param elementGuard -  tooltip element guard
+         * @param isMouseenter - mouseenter validation
+         * @param conditionalGuard - guard condition
+         */
+        this.tooltipMouseListenerAction = (elementGuard, isMouseenter, conditionalGuard) => {
+            // we mutate elementGuard
+            if (this.guard !== Guard.FOCUS) {
+                this.guard = elementGuard;
+                if (!isMouseenter) {
+                    // process action in the next event loop macro task
+                    setTimeout(() => {
+                        this.setDisplay(isMouseenter, this.guard !== conditionalGuard);
+                        this.resetGuard();
+                    }, 100);
+                }
+                else if (this.guard === Guard.HOVER_TOOLTIPED_ELEMENT) {
+                    this.setDisplay(isMouseenter);
+                }
+            }
+        };
+        /**
+         * Method to reset guard value
+         */
+        this.resetGuard = () => {
+            this.guard = undefined;
+        };
+        /**
+         * Update slot content when it is a mg-button
+         * @param mgButton - slotted mg-button
+         */
+        this.setMgButtonWrapper = (mgButton) => {
+            if (mgButton.disabled) {
+                const div = document.createElement('div');
+                div.classList.add('mg-c-tooltip__mg-button-wrapper');
+                mgButton.parentNode.insertBefore(div, mgButton);
+                div.appendChild(mgButton);
+                this.tooltipedElement = div;
+            }
+            else if (mgButton.parentElement.classList.contains('mg-c-tooltip__mg-button-wrapper')) {
+                this.element.firstElementChild.replaceWith(mgButton);
+                this.tooltipedElement = mgButton;
+            }
+        };
+        /**
+         * Init tooltip
+         * @param slotElement - slotted element
+         * @param interactiveElement - interactive element
+         */
+        this.initTooltip = (slotElement, interactiveElement) => {
+            // Add tabindex to slotted element if we can't find any interactive element
+            if (!this.disabled && !interactiveElement) {
+                this.hasCustomTabIndex = true;
+                slotElement.tabIndex = 0;
+                // Add role on non-interactive element to work with "aria-describedby" for screen readers
+                slotElement.setAttribute('role', 'button');
+            }
+            // Set aria-describedby
+            const ariaDescribedby = slotElement.getAttribute('aria-describedby');
+            if (ariaDescribedby === null) {
+                this.tooltipedElement.setAttribute('aria-describedby', this.identifier);
+            }
+            else {
+                // We ensure to have uniq ids
+                slotElement.setAttribute('aria-describedby', `${[...new Set([...ariaDescribedby.split(' '), this.identifier])].join(' ')}`);
+            }
+            // Create popperjs tooltip
+            this.popper = createPopper(this.tooltipedElement, this.mgTooltipContent, {
+                placement: this.placement,
+                strategy: 'fixed',
+                modifiers: [
+                    {
+                        name: 'offset',
+                        options: {
+                            offset: [0, 8],
+                        },
+                    },
+                    {
+                        name: 'flip',
+                        options: {
+                            fallbackPlacements: ['auto'],
+                        },
+                    },
+                ],
+            });
+            // Manage tooltipedElement focus/blur events
+            this.tooltipedElement.addEventListener('focus', () => {
+                this.guard = Guard.FOCUS;
+                this.setDisplay(true);
+            });
+            // as `click` event is the composition of `mousedown` and `mouseup` event,
+            // and `click` event trigger `focus` event after a success `mousedown` wich set the `guard` to `Guard.FOCUS`
+            // we reset the guard on `mouseup` event to unlock tooltip
+            this.tooltipedElement.addEventListener('mouseup', () => {
+                this.resetGuard();
+            });
+            this.tooltipedElement.addEventListener('blur', () => {
+                this.resetGuard();
+                this.setDisplay(false);
+            });
+            document.addEventListener('keydown', this.pressEscape);
+            // manage tooltipElement & tooltipedElement mouseenter/mouseleave events
+            ['mouseenter', 'mouseleave'].forEach(eventType => {
+                const isMouseenter = eventType === 'mouseenter';
+                [
+                    { element: this.mgTooltipContent, action: () => this.tooltipMouseListenerAction(Guard.HOVER_TOOLTIP_ELEMENT, isMouseenter, Guard.HOVER_TOOLTIPED_ELEMENT) },
+                    { element: this.tooltipedElement, action: () => this.tooltipMouseListenerAction(Guard.HOVER_TOOLTIPED_ELEMENT, isMouseenter, Guard.HOVER_TOOLTIP_ELEMENT) },
+                ].forEach(({ element, action }) => {
+                    element.addEventListener(eventType, () => {
+                        action();
+                    });
+                });
+            });
+        };
+        this.identifier = createID('mg-tooltip');
+        this.message = undefined;
+        this.placement = 'bottom';
+        this.display = false;
+        this.disabled = false;
+    }
+    validateIdentifier() {
+        // use renderTooltipContent to update tooltip-content id
+        this.renderTooltipContent();
+    }
+    validateMessage(newValue) {
+        if (!isValidString(newValue)) {
+            throw new Error('<mg-tooltip> prop "message" is required.');
+        }
+        this.mgTooltipContent.message = newValue;
+    }
+    handleDisplay(newValue) {
+        if (newValue) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
+    validateDisabled(newValue) {
+        if (this.hasCustomTabIndex) {
+            if (newValue)
+                this.tooltipedElement.removeAttribute('tabindex');
+            else if (this.tooltipedElement.getAttribute('tabindex') === null)
+                this.tooltipedElement.setAttribute('tabindex', '0');
+        }
+    }
     /**
-     * Action for tooltip element and tooltiped element mouse listener
-     * @param elementGuard -  tooltip element guard
-     * @param isMouseenter - mouseenter validation
-     * @param conditionalGuard - guard condition
+     * Render tooltip content element
      */
-    this.tooltipMouseListenerAction = (elementGuard, isMouseenter, conditionalGuard) => {
-      // we mutate elementGuard
-      if (this.guard !== Guard.FOCUS) {
-        this.guard = elementGuard;
-        if (!isMouseenter) {
-          setTimeout(() => {
-            this.setDisplay(isMouseenter, this.guard !== conditionalGuard);
-            this.resetGuard();
-          }, 100);
+    renderTooltipContent() {
+        const mgTooltipContent = this.element.querySelector('mg-tooltip-content');
+        if (mgTooltipContent === null) {
+            const mgTooltipContent = document.createElement('mg-tooltip-content');
+            mgTooltipContent.setAttribute('slot', 'content');
+            mgTooltipContent.setAttribute('id', this.identifier);
+            const arrow = document.createElement('div');
+            arrow.setAttribute('slot', 'arrow');
+            arrow.dataset.popperArrow = '';
+            mgTooltipContent.appendChild(arrow);
+            // append tooltip element to component
+            this.element.appendChild(mgTooltipContent);
         }
-        else if (this.guard === Guard.HOVER_TOOLTIPED_ELEMENT) {
-          this.setDisplay(isMouseenter);
+        else {
+            mgTooltipContent.setAttribute('id', this.identifier);
         }
-      }
-    };
+    }
+    /*************
+     * Lifecycle *
+     *************/
     /**
-     * Method to reset guard value
+     * set variables
      */
-    this.resetGuard = () => {
-      this.guard = undefined;
-    };
+    componentWillLoad() {
+        // Get windows to attach events
+        this.windows = getWindows(window);
+        // Get tooltip element
+        this.renderTooltipContent();
+        this.mgTooltipContent = this.element.querySelector(`#${this.identifier}`);
+        //validate properties
+        this.validateDisabled(this.disabled);
+        this.validateMessage(this.message);
+        this.validateIdentifier();
+    }
     /**
-     * Update slot content when it is a mg-button
-     * @param mgButton - slotted mg-button
+     * Get slotted element
+     * Check if it already contain an interactive element, if not we need to add a tabIndex attribute
+     * We need to attach the focused element to the tooltip (aria-describedby)
      */
-    this.setMgButtonWrapper = (mgButton) => {
-      if (mgButton.disabled) {
-        const div = document.createElement('div');
-        div.classList.add('mg-c-tooltip__mg-button-wrapper');
-        mgButton.parentNode.insertBefore(div, mgButton);
-        div.appendChild(mgButton);
-        this.tooltipedElement = div;
-      }
-      else if (mgButton.parentElement.classList.contains('mg-c-tooltip__mg-button-wrapper')) {
-        this.element.firstElementChild.replaceWith(mgButton);
-        this.tooltipedElement = mgButton;
-      }
-    };
+    componentDidLoad() {
+        var _a;
+        // get slotted element wich is not the tooltip
+        const slotElement = this.element.querySelector(`*:not(#${this.identifier})`);
+        // Get interactive element
+        const interactiveElement = slotElement.matches(focusableElements) ? slotElement : (_a = slotElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(focusableElements);
+        // define selected element to become tooltip selector
+        this.tooltipedElement = interactiveElement || slotElement;
+        // Check if slotted element is a disabled mg-button
+        // In this case we wrap the mg-button into a div to enable the tooltip
+        if (isButton(slotElement)) {
+            new MutationObserver(mutationList => {
+                if (mutationList.some(mutation => ['aria-disabled', 'disabled'].includes(mutation.attributeName))) {
+                    this.setMgButtonWrapper(slotElement);
+                    // Since Firefox doesn't trigger a "blur" event when the "disabled" attribute is added or removed from a button
+                    // we have to manually unlock the guard because the "blur" handler of the tooltipedElement won't do it.
+                    this.resetGuard();
+                    this.initTooltip(slotElement, interactiveElement);
+                }
+            }).observe(slotElement, { attributes: true });
+            this.setMgButtonWrapper(slotElement);
+        }
+        // Init Tooltip
+        this.initTooltip(slotElement, interactiveElement);
+        this.handleDisplay(this.display);
+    }
     /**
-     * Init tooltip
-     * @param slotElement - slotted element
-     * @param interactiveElement - interactive element
+     * update popper position after props change on component did update hook to benefit from render ended
      */
-    this.initTooltip = (slotElement, interactiveElement) => {
-      // Add tabindex to slotted element if we can't find any interactive element
-      if (!this.disabled && !interactiveElement) {
-        this.hasCustomTabIndex = true;
-        slotElement.tabIndex = 0;
-        // Add role on non-interactive element to work with "aria-describedby" for screen readers
-        slotElement.setAttribute('role', 'button');
-      }
-      // Set aria-describedby
-      const ariaDescribedby = slotElement.getAttribute('aria-describedby');
-      if (ariaDescribedby === null) {
-        this.tooltipedElement.setAttribute('aria-describedby', this.identifier);
-      }
-      else {
-        // We ensure to have uniq ids
-        slotElement.setAttribute('aria-describedby', `${[...new Set([...ariaDescribedby.split(' '), this.identifier])].join(' ')}`);
-      }
-      // Create popperjs tooltip
-      this.popper = createPopper(this.tooltipedElement, this.mgTooltipContent, {
-        placement: this.placement,
-        strategy: 'fixed',
-        modifiers: [
-          {
-            name: 'offset',
-            options: {
-              offset: [0, 8],
-            },
-          },
-          {
-            name: 'flip',
-            options: {
-              fallbackPlacements: ['auto'],
-            },
-          },
-        ],
-      });
-      // Manage tooltipedElement focus/blur events
-      this.tooltipedElement.addEventListener('focus', () => {
-        this.guard = Guard.FOCUS;
-        this.setDisplay(true);
-      });
-      // as `click` event is the composition of `mousedown` and `mouseup` event,
-      // and `click` event trigger `focus` event after a success `mousedown` wich set the `guard` to `Guard.FOCUS`
-      // we reset the guard on `mouseup` event to unlock tooltip
-      this.tooltipedElement.addEventListener('mouseup', () => {
-        this.resetGuard();
-      });
-      this.tooltipedElement.addEventListener('blur', () => {
-        this.resetGuard();
-        this.setDisplay(false);
-      });
-      document.addEventListener('keydown', this.pressEscape);
-      // manage tooltipElement & tooltipedElement mouseenter/mouseleave events
-      ['mouseenter', 'mouseleave'].forEach(eventType => {
-        const isMouseenter = eventType === 'mouseenter';
-        [
-          { element: this.mgTooltipContent, action: () => this.tooltipMouseListenerAction(Guard.HOVER_TOOLTIP_ELEMENT, isMouseenter, Guard.HOVER_TOOLTIPED_ELEMENT) },
-          { element: this.tooltipedElement, action: () => this.tooltipMouseListenerAction(Guard.HOVER_TOOLTIPED_ELEMENT, isMouseenter, Guard.HOVER_TOOLTIP_ELEMENT) },
-        ].forEach(({ element, action }) => {
-          element.addEventListener(eventType, () => {
-            action();
-          });
-        });
-      });
-    };
-    this.identifier = createID('mg-tooltip');
-    this.message = undefined;
-    this.placement = 'bottom';
-    this.display = false;
-    this.disabled = false;
-  }
-  validateIdentifier() {
-    // use renderTooltipContent to update tooltip-content id
-    this.renderTooltipContent();
-  }
-  validateMessage(newValue) {
-    if (!isValidString(newValue)) {
-      throw new Error('<mg-tooltip> prop "message" is required.');
-    }
-    this.mgTooltipContent.message = newValue;
-  }
-  handleDisplay(newValue) {
-    if (newValue) {
-      this.show();
+    componentDidUpdate() {
+        this.popper.update();
     }
-    else {
-      this.hide();
-    }
-  }
-  validateDisabled(newValue) {
-    if (this.hasCustomTabIndex) {
-      if (newValue)
-        this.tooltipedElement.removeAttribute('tabindex');
-      else if (this.tooltipedElement.getAttribute('tabindex') === null)
-        this.tooltipedElement.setAttribute('tabindex', '0');
-    }
-  }
-  /**
-   * Render tooltip content element
-   */
-  renderTooltipContent() {
-    const mgTooltipContent = this.element.querySelector('mg-tooltip-content');
-    if (mgTooltipContent === null) {
-      const mgTooltipContent = document.createElement('mg-tooltip-content');
-      mgTooltipContent.setAttribute('slot', 'content');
-      mgTooltipContent.setAttribute('id', this.identifier);
-      const arrow = document.createElement('div');
-      arrow.setAttribute('slot', 'arrow');
-      arrow.dataset.popperArrow = '';
-      mgTooltipContent.appendChild(arrow);
-      // append tooltip element to component
-      this.element.appendChild(mgTooltipContent);
-    }
-    else {
-      mgTooltipContent.setAttribute('id', this.identifier);
-    }
-  }
-  /*************
-   * Lifecycle *
-   *************/
-  /**
-   * set variables
-   */
-  componentWillLoad() {
-    // Get windows to attach events
-    this.windows = getWindows(window);
-    // Get tooltip element
-    this.renderTooltipContent();
-    this.mgTooltipContent = this.element.querySelector(`#${this.identifier}`);
-    //validate properties
-    this.validateDisabled(this.disabled);
-    this.validateMessage(this.message);
-    this.validateIdentifier();
-  }
-  /**
-   * Get slotted element
-   * Check if it already contain an interactive element, if not we need to add a tabIndex attribute
-   * We need to attach the focused element to the tooltip (aria-describedby)
-   */
-  componentDidLoad() {
-    var _a;
-    // get slotted element wich is not the tooltip
-    const slotElement = this.element.querySelector(`*:not(#${this.identifier})`);
-    // Get interactive element
-    const interactiveElement = slotElement.matches(focusableElements) ? slotElement : (_a = slotElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(focusableElements);
-    // define selected element to become tooltip selector
-    this.tooltipedElement = interactiveElement || slotElement;
-    // Check if slotted element is a disabled mg-button
-    // In this case we wrap the mg-button into a div to enable the tooltip
-    if (isButton(slotElement)) {
-      new MutationObserver(mutationList => {
-        if (mutationList.some(mutation => ['aria-disabled', 'disabled'].includes(mutation.attributeName))) {
-          this.setMgButtonWrapper(slotElement);
-          // Since Firefox doesn't trigger a "blur" event when the "disabled" attribute is added or removed from a button
-          // we have to manually unlock the guard because the "blur" handler of the tooltipedElement won't do it.
-          this.resetGuard();
-          this.initTooltip(slotElement, interactiveElement);
-        }
-      }).observe(slotElement, { attributes: true });
-      this.setMgButtonWrapper(slotElement);
+    /**
+     * Render
+     * @returns HTML Element
+     */
+    render() {
+        return (h(Host, null, h("slot", null), h("slot", { name: "content" })));
     }
-    // Init Tooltip
-    this.initTooltip(slotElement, interactiveElement);
-    this.handleDisplay(this.display);
-  }
-  /**
-   * update popper position after props change on component did update hook to benefit from render ended
-   */
-  componentDidUpdate() {
-    this.popper.update();
-  }
-  /**
-   * Render
-   * @returns HTML Element
-   */
-  render() {
-    return (h(Host, null, h("slot", null), h("slot", { name: "content" })));
-  }
-  get element() { return this; }
-  static get watchers() { return {
-    "identifier": ["validateIdentifier"],
-    "message": ["validateMessage"],
-    "display": ["handleDisplay"],
-    "disabled": ["validateDisabled"]
-  }; }
-  static get style() { return mgTooltipCss; }
+    get element() { return this; }
+    static get watchers() { return {
+        "identifier": ["validateIdentifier"],
+        "message": ["validateMessage"],
+        "display": ["handleDisplay"],
+        "disabled": ["validateDisabled"]
+    }; }
+    static get style() { return mgTooltipCss; }
 }, [1, "mg-tooltip", {
-    "identifier": [1],
-    "message": [1],
-    "placement": [1],
-    "display": [1028],
-    "disabled": [4]
-  }, undefined, {
-    "identifier": ["validateIdentifier"],
-    "message": ["validateMessage"],
-    "display": ["handleDisplay"],
-    "disabled": ["validateDisabled"]
-  }]);
+        "identifier": [1],
+        "message": [1],
+        "placement": [1],
+        "display": [1028],
+        "disabled": [4]
+    }, undefined, {
+        "identifier": ["validateIdentifier"],
+        "message": ["validateMessage"],
+        "display": ["handleDisplay"],
+        "disabled": ["validateDisabled"]
+    }]);
 function defineCustomElement() {
-  if (typeof customElements === "undefined") {
-    return;
-  }
-  const components = ["mg-tooltip", "mg-tooltip-content"];
-  components.forEach(tagName => { switch (tagName) {
-    case "mg-tooltip":
-      if (!customElements.get(tagName)) {
-        customElements.define(tagName, MgTooltip);
-      }
-      break;
-    case "mg-tooltip-content":
-      if (!customElements.get(tagName)) {
-        defineCustomElement$1();
-      }
-      break;
-  } });
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["mg-tooltip", "mg-tooltip-content"];
+    components.forEach(tagName => { switch (tagName) {
+        case "mg-tooltip":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, MgTooltip);
+            }
+            break;
+        case "mg-tooltip-content":
+            if (!customElements.get(tagName)) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
 }
 defineCustomElement();