@mgdis/mg-components 5.6.0 → 5.8.0

package/dist/components/mg-item-more.js

@@ -0,0 +1,336 @@
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { i as initLocales } from './index2.js';
+import { D as Direction } from './mg-menu.conf.js';
+import { d as defineCustomElement$8 } from './mg-badge2.js';
+import { d as defineCustomElement$7 } from './mg-button2.js';
+import { d as defineCustomElement$6 } from './mg-card2.js';
+import { d as defineCustomElement$5 } from './mg-icon2.js';
+import { d as defineCustomElement$4 } from './mg-menu2.js';
+import { d as defineCustomElement$3 } from './mg-menu-item2.js';
+import { d as defineCustomElement$2 } from './mg-popover2.js';
+
+/**
+ * MgItemMore type guard
+ *
+ * @param {HTMLElement} element element to control type
+ * @returns {boolean} truthy if element is mg-item-more
+ */
+const isMgItemMore = (element) => element.nodeName === 'MG-ITEM-MORE';
+var OverflowBehaviorElements;
+(function (OverflowBehaviorElements) {
+  OverflowBehaviorElements["BASE_INDEX"] = "data-overflow-base-index";
+  OverflowBehaviorElements["PROXY_INDEX"] = "data-overflow-proxy-index";
+})(OverflowBehaviorElements || (OverflowBehaviorElements = {}));
+class OverflowBehavior {
+  constructor(element, render) {
+    this.element = element;
+    this.render = render;
+    /**********
+     * Public *
+     **********/
+    /**
+     * Disconnect ResizeObserver
+     *
+     * @returns {void}
+     */
+    this.disconnect = () => {
+      this._resizeObserver.disconnect();
+    };
+    /************
+     * Internal *
+     ************/
+    /**
+     * run overflow behavior
+     *
+     * @param {number} width width of the container. Optional.
+     * @returns {void}
+     */
+    this.run = (width) => {
+      if (this._moreElement === undefined) {
+        // set moreElement
+        this._moreElement = this.render();
+        // set children
+        this._baseChildren = this.getInteractiveItems(this.element);
+        if (isMgItemMore(this._moreElement)) {
+          this._proxyChildren = this.getInteractiveItems(this._moreElement.shadowRoot.querySelector('mg-menu'));
+        }
+        // update children
+        this._baseChildren.forEach((child, index) => {
+          child.setAttribute(OverflowBehaviorElements.BASE_INDEX, `${index}`);
+          // set moreElement children
+          this._proxyChildren[index].setAttribute(OverflowBehaviorElements.PROXY_INDEX, `${index}`);
+        });
+      }
+      if (width !== undefined)
+        this.updateDisplayedItems(width);
+    };
+    /**
+     * Get interactive children filtred by authorized nodeName ['MG-MENU-ITEM', 'MG-BUTTON']
+     *
+     * @param {Element} element element to parse
+     * @returns {Element[]} children
+     */
+    this.getInteractiveItems = (element) => { var _a; return (((_a = element.children) === null || _a === void 0 ? void 0 : _a.length) > 0 ? Array.from(element.children) : []).filter(element => ['MG-MENU-ITEM', 'MG-BUTTON'].includes(element.nodeName)); };
+    /**
+     * Update displayed items in container from a given available space
+     *
+     * @param {number} availableWidth available width in container to display child items
+     * @returns {void}
+     */
+    this.updateDisplayedItems = (availableWidth) => {
+      this.restoreItems();
+      const acc = { accWidth: 0, previousItem: null };
+      [...this._baseChildren, this._moreElement].forEach((child) => {
+        acc.accWidth += child.offsetWidth;
+        const isPreviousItemHidden = acc.previousItem !== null && acc.previousItem.getAttribute('hidden') !== null;
+        // if previous item is hidden AND is NOT more element we hidde current
+        // OR if item has an overflow we hidde current
+        // OR if current item is more element AND have NOT previous hidden items, current more element item is an hidden item
+        // ELSE current is a display item
+        this.toggleItem(child, (isPreviousItemHidden && !this.isMoreElement(child)) || this.isOverflowElement(acc.accWidth, child, availableWidth) || (this.isMoreElement(child) && !isPreviousItemHidden));
+        // update previous item with current item
+        acc.previousItem = child;
+      });
+    };
+    /**
+     * Utility method to know if item overflow partialy or totaly in the container
+     *
+     * @param {number} cumulateWidth previous sibling elements cumulate width + item width
+     * @param {HTMLElement} item item HTML element
+     * @param {number} availableWidth container available width
+     * @returns {boolean} truthy if element is overflow
+     */
+    this.isOverflowElement = (cumulateWidth, item, availableWidth) => {
+      if (item.previousElementSibling === null || this.isMoreElement(item))
+        return false;
+      else if (!this.isMoreElement(item.nextElementSibling))
+        return cumulateWidth + this._moreElement.offsetWidth > availableWidth;
+      else
+        return cumulateWidth > availableWidth;
+    };
+    /**
+     * Utility method to know if a given element is the 'MORE' element
+     *
+     * @param {Element} element element to match with 'MORE' element
+     * @returns {boolean} truthy if element is the 'MORE' element
+     */
+    this.isMoreElement = (element) => element.nodeName === 'MG-ITEM-MORE';
+    /**
+     * Toggle display item element
+     *
+     * @param {HTMLElement} item item to control
+     * @param {boolean} isHidden is item hidden
+     * @returns {void}
+     */
+    this.toggleItem = (item, isHidden) => {
+      const mgActionMenuindex = Number(item.getAttribute(OverflowBehaviorElements.BASE_INDEX));
+      if (this.isMoreElement(item))
+        this.toggleElement(this._moreElement, isHidden);
+      else if (mgActionMenuindex >= 0) {
+        this.toggleElement(item, isHidden);
+        this.toggleElement(this._proxyChildren[mgActionMenuindex], !isHidden);
+      }
+    };
+    /**
+     * Toggle element's hidde attribute
+     *
+     * @param {Element} element element to toggle
+     * @param {boolean} isHidden element is hidden
+     * @returns {void}
+     */
+    this.toggleElement = (element, isHidden) => {
+      if (isHidden)
+        element.setAttribute('hidden', '');
+      else
+        element.removeAttribute('hidden');
+    };
+    /**
+     * Remove hidden attributes on all items
+     *
+     * @returns {void}
+     */
+    this.restoreItems = () => {
+      [...this._baseChildren, this._moreElement].forEach(item => item.removeAttribute('hidden'));
+    };
+    if (this._resizeObserver === undefined) {
+      // add resize observer
+      this._resizeObserver = new ResizeObserver(entries => {
+        entries.forEach(entry => {
+          this.run(entry.contentRect.width);
+        });
+      });
+      this._resizeObserver.observe(this.element);
+    }
+    this.run();
+  }
+}
+
+const mgItemMoreCss = ".sr-only{border:0 !important;clip:rect(1px, 1px, 1px, 1px) !important;-webkit-clip-path:inset(50%) !important;clip-path:inset(50%) !important;height:1px !important;margin:-1px !important;overflow:hidden !important;padding:0 !important;position:absolute !important;width:1px !important;white-space:nowrap !important}*:focus:not(:focus-visible){outline:none}@media (prefers-reduced-motion){.mg-a11y-animation{animation:none !important;transition:none !important}}:host{display:flex}";
+
+const MgItemMore$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.__attachShadow();
+    /************
+     * Internal *
+     ************/
+    this.name = 'mg-item-more';
+    /***********
+     * Methods *
+     ***********/
+    /**
+     * render mg-item-more overflow element
+     *
+     * @returns {HTMLMgItemMoreElement} mg-item-more element
+     */
+    this.renderMgMenuItemOverflowElement = () => {
+      // create menu items proxy element from item clones
+      const moreElementMenuItem = this.element.shadowRoot.querySelector('mg-menu-item');
+      this.menuItems.forEach((child) => {
+        moreElementMenuItem.querySelector('mg-menu').appendChild(child.cloneNode(true));
+      });
+      const allMenuItem = Array.from(this.parentMenu.querySelectorAll('mg-menu-item:not([data-overflow-more])'));
+      Array.from(moreElementMenuItem.querySelectorAll('mg-menu-item:not([data-overflow-more])')).forEach((proxy, index) => {
+        // manage click on proxy to mirror it on initial element
+        proxy.addEventListener('click', () => {
+          (allMenuItem[index].shadowRoot.querySelector('a') || allMenuItem[index].shadowRoot.querySelector('button')).dispatchEvent(new MouseEvent('click', { bubbles: true }));
+        });
+        // add id suffix to prevent duplicate key. default html id is: '';
+        if (proxy.id.trim() !== '')
+          proxy.id = `${proxy.id}-proxy`;
+        // manage status change miror in proxy
+        allMenuItem[index].addEventListener('status-change', (event) => {
+          proxy.setAttribute('status', event.detail);
+        });
+      });
+      return this.element;
+    };
+    this.icon = { icon: 'ellipsis-vertical' };
+    this.slotlabel = { display: false };
+    this.size = undefined;
+    this.parentMenu = undefined;
+  }
+  validateIcon(newValue) {
+    if (typeof newValue !== 'object' || (typeof newValue === 'object' && typeof newValue.icon !== 'string'))
+      throw new Error(`<${this.name}> prop "icon" must match MgItemMore['icon'] type.`);
+  }
+  validateSlotLabel(newValue) {
+    if (typeof newValue !== 'object' || (typeof newValue === 'object' && typeof newValue.display !== 'boolean'))
+      throw new Error(`<${this.name}> prop "slotlabel" must match MgItemMore['slotlabel'] type.`);
+    else if (typeof newValue.label !== 'string')
+      this.slotlabel.label = this.messages.moreLabel;
+  }
+  validateSize(newValue) {
+    if (newValue && typeof newValue !== 'string')
+      throw new Error(`<${this.name}> prop "size" must match MgItemMore['size'] type.`);
+  }
+  /*************
+   * Lifecycle *
+   *************/
+  /**
+   * Disconnect overflow ResizeObserver
+   *
+   * @returns {void} run overflow resize obeserver disconnexion
+   */
+  disconnectedCallback() {
+    this.overflowBehavior.disconnect();
+  }
+  /**
+   * Set variables and validate props
+   *
+   * @returns {void}
+   */
+  componentWillLoad() {
+    // init variables
+    this.messages = initLocales(this.element).messages.plusMenu;
+    this.parentMenu = this.element.closest('mg-menu');
+    this.menuItems = Array.from(this.parentMenu.children).filter(item => item.nodeName === 'MG-MENU-ITEM');
+    // validate props
+    this.validateIcon(this.icon);
+    this.validateSlotLabel(this.slotlabel);
+    this.validateSize(this.size);
+  }
+  /**
+   * Add overflow behavior
+   *
+   * @returns {void}
+   */
+  componentDidLoad() {
+    this.overflowBehavior = new OverflowBehavior(this.parentMenu, this.renderMgMenuItemOverflowElement);
+  }
+  /**
+   * Render
+   *
+   * @returns {HTMLElement} HTML Element
+   */
+  render() {
+    return (h(Host, { role: "menuitem", "aria-haspopup": "true" }, h("mg-menu-item", { "data-overflow-more": true, "data-size": this.parentMenu.size }, h("mg-icon", { icon: this.icon.icon, slot: "image" }), h("span", { class: { 'sr-only': !this.slotlabel.display }, slot: "label" }, this.slotlabel.label), h("mg-menu", { direction: Direction.VERTICAL, label: this.messages.moreLabel, size: this.size }))));
+  }
+  get element() { return this; }
+  static get watchers() { return {
+    "icon": ["validateIcon"],
+    "slotlabel": ["validateSlotLabel"],
+    "size": ["validateSize"]
+  }; }
+  static get style() { return mgItemMoreCss; }
+}, [1, "mg-item-more", {
+    "icon": [16],
+    "slotlabel": [16],
+    "size": [1],
+    "parentMenu": [32]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["mg-item-more", "mg-badge", "mg-button", "mg-card", "mg-icon", "mg-menu", "mg-menu-item", "mg-popover"];
+  components.forEach(tagName => { switch (tagName) {
+    case "mg-item-more":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, MgItemMore$1);
+      }
+      break;
+    case "mg-badge":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$8();
+      }
+      break;
+    case "mg-button":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$7();
+      }
+      break;
+    case "mg-card":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$6();
+      }
+      break;
+    case "mg-icon":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$5();
+      }
+      break;
+    case "mg-menu":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$4();
+      }
+      break;
+    case "mg-menu-item":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$3();
+      }
+      break;
+    case "mg-popover":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const MgItemMore = MgItemMore$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { MgItemMore, defineCustomElement };