@mgdis/mg-components 5.5.0 → 5.7.0

package/dist/collection/components/molecules/menu/mg-menu-item/mg-menu-item.js

@@ -1,7 +1,9 @@
 import { h, Host } from '@stencil/core';
+import { OverflowBehaviorElements } from '../../../../utils/behaviors.utils';
 import { ClassList } from '../../../../utils/components.utils';
+import { initLocales } from '../../../../locales';
 import { Direction } from '../mg-menu/mg-menu.conf';
-import { sizes, Status } from './mg-menu-item.conf';
+import { Status } from './mg-menu-item.conf';
 export class MgMenuItem {
   constructor() {
     /************
@@ -9,9 +11,9 @@ export class MgMenuItem {
      ************/
     this.name = 'mg-menu-item';
     this.navigationButton = `${this.name}__navigation-button`;
-    /************
+    /***********
      * Methods *
-     ************/
+     **********/
     /**
      * Toggle expanded prop value
      *
@@ -21,20 +23,20 @@ export class MgMenuItem {
       this.expanded = !this.expanded;
     };
     /**
-     * Does an HTMLElement contain child with given Status
+     * Does an Element have given Status
      *
-     * @param {HTMLElement} element to parse
+     * @param {HTMLMgMenuItemElement} mgMenuItemElement to parse
      * @param {MgMenuItem['status']} status to check
      * @returns {boolean} true if element with status is found
      */
-    this.hasChildElementStatus = (element, status) => element.querySelector(`${this.name}[status="${status}"]`) !== null;
+    this.hasStatus = (mgMenuItemElement, status) => mgMenuItemElement.status === status;
     /**
      * Is component contextual direction match the given direction
      *
      * @param {MgMenuItem['direction']} direction in parent menu
      * @returns {boolean} true is direction match the direction propertie
      */
-    this.isdirection = (direction) => this.direction === direction;
+    this.isDirection = (direction) => this.direction === direction;
     /************
      * Handlers *
      ************/
@@ -45,7 +47,7 @@ export class MgMenuItem {
      * @returns {void}
      */
     this.handleElementCLick = (event) => {
-      if (this.hasChildren || this.status === Status.DISABLED) {
+      if ((this.hasChildren && !this.isInMainMenu) || this.status === Status.DISABLED) {
         event.preventDefault();
         event.stopPropagation();
       }
@@ -53,27 +55,60 @@ export class MgMenuItem {
       if (this.hasChildren)
         this.toggleExpanded();
     };
+    /**
+     * Handle popover element display-change event
+     *
+     * @param {CustomEvent} event popover display event
+     * @returns {void}
+     */
+    this.handlePopoverDisplay = (event) => {
+      this.expanded = event.detail;
+    };
+    /**
+     * Update displayNotificationBadge
+     * current component notification badge have priority over the slot badge when submenu contain badge
+     *
+     * @returns {void} update displayNotificationBadge value
+     */
+    this.updateDisplayNotificationBadge = () => {
+      const childMenu = this.element.querySelector('mg-menu');
+      this.displayNotificationBadge =
+        childMenu !== null &&
+          Array.from(childMenu.children).some((subItem) => subItem.querySelector('mg-badge') !== null && subItem.getAttribute('hidden') === null);
+    };
+    /**
+     * Method to control if one of component children have active status
+     *
+     * @returns {boolean} truthy if component has active child
+     */
+    this.hasActiveChild = () => {
+      var _a;
+      return Array.from(((_a = this.element.querySelector('mg-menu')) === null || _a === void 0 ? void 0 : _a.children) || [])
+        .filter(element => element.nodeName === 'MG-MENU-ITEM')
+        .some((element) => this.hasStatus(element, Status.ACTIVE) && element.getAttribute('hidden') === null);
+    };
+    /**
+     * Render slot
+     *
+     * @returns {HTMLElement} HTML Element
+     */
+    this.renderSlot = () => h("slot", null);
     this.href = undefined;
     this.status = Status.VISIBLE;
-    this.size = 'large';
     this.expanded = false;
+    this.size = 'regular';
     this.navigationButtonClassList = new ClassList([this.navigationButton]);
     this.direction = undefined;
     this.isInMainMenu = undefined;
     this.hasChildren = false;
+    this.displayNotificationBadge = undefined;
   }
   validateStatus(newValue, oldValue) {
     if (oldValue !== undefined) {
       this.navigationButtonClassList.delete(`${this.navigationButton}--${oldValue}`);
     }
     this.navigationButtonClassList.add(`${this.navigationButton}--${newValue}`);
-  }
-  validateSize(newValue, oldValue) {
-    if (!sizes.includes(newValue)) {
-      throw new Error(`<${this.name}> prop "size" must be one of : ${sizes.join(', ')}.`);
-    }
-    this.navigationButtonClassList.delete(`${this.navigationButton}--size-${oldValue}`);
-    this.navigationButtonClassList.add(`${this.navigationButton}--size-${newValue}`);
+    this.statusChange.emit(newValue);
   }
   validateExpanded(newValue) {
     if (typeof newValue !== 'boolean')
@@ -87,16 +122,20 @@ export class MgMenuItem {
           item.expanded = false;
         });
       }
-      else if (newValue && this.hasChildElementStatus(this.element, Status.ACTIVE)) {
+      else if (this.element.querySelector(`${this.name}[status="${Status.ACTIVE}"]`) !== null) {
         // - when expanded and contain an active item parents are expended too
         subItems.forEach(item => {
-          if (this.hasChildElementStatus(item, Status.ACTIVE)) {
+          if (this.hasStatus(item, Status.ACTIVE)) {
             item.expanded = true;
           }
         });
       }
     }
   }
+  validateSize(newValue, oldValue) {
+    this.navigationButtonClassList.delete(`${this.navigationButton}--size-${oldValue}`);
+    this.navigationButtonClassList.add(`${this.navigationButton}--size-${newValue}`);
+  }
   validateHasChildren(newValue) {
     if (newValue && this.element.href !== undefined) {
       throw new Error(`<${this.name}> prop "href" is unauthorizied when element is a parent.`);
@@ -111,13 +150,14 @@ export class MgMenuItem {
    * @returns {void}
    */
   componentWillLoad() {
-    // has children items that is NOT [slot="illustration"] || [slot="information"] element
+    // has children items that is NOT [slot='image' | 'information' | 'label' | 'metadata'] element
     // we store only matching elements
-    this.hasChildren = Array.from(this.element.children).filter(child => !['illustration', 'information', 'label', 'metadata'].includes(child.getAttribute('slot'))).length > 0;
+    this.hasChildren = Array.from(this.element.children).some(child => !['image', 'information', 'label', 'metadata'].includes(child.getAttribute('slot')));
     // Validate props
     this.validateSize(this.size);
     this.validateStatus(this.status);
     this.validateExpanded(this.expanded);
+    this.badgeLabel = initLocales(this.element).messages.plusMenu.badgeLabel;
   }
   /**
    * Check if component slots configuration
@@ -141,49 +181,76 @@ export class MgMenuItem {
     // return a promise to process action only in the FIRST render().
     // https://stenciljs.com/docs/component-lifecycle#componentwillload
     return setTimeout(() => {
-      var _a, _b;
+      var _a;
       // define menu-item context states
-      if (this.element.parentElement.nodeName === 'MG-MENU') {
-        this.direction = this.element.parentElement.direction;
-      }
-      this.isInMainMenu = this.element.parentElement.className.includes('mg-menu-item') === false;
-      const hasNextMenuItem = ((_a = this.element.nextElementSibling) === null || _a === void 0 ? void 0 : _a.nodeName) === 'MG-MENU-ITEM';
-      const hasPreviousMenuItem = ((_b = this.element.previousElementSibling) === null || _b === void 0 ? void 0 : _b.nodeName) === 'MG-MENU-ITEM';
-      // manage last menu item
-      if (!hasNextMenuItem && hasPreviousMenuItem && this.isdirection(Direction.HORIZONTAL)) {
-        this.element.setAttribute('data-style-position-last', '');
-      }
+      const menu = this.element.closest('mg-menu');
+      this.direction = this.element.getAttribute(OverflowBehaviorElements.MORE) !== null || menu === null ? Direction.HORIZONTAL : menu.direction;
+      this.size = menu === null || menu === void 0 ? void 0 : menu.size;
+      this.isInMainMenu = this.element.parentElement.closest('mg-menu-item') === null;
       // when main menu item contain an active item it will get the active style
       // AND if item is in vertical menu it will be expanded
-      if (this.isInMainMenu && this.hasChildElementStatus(this.element, Status.ACTIVE)) {
+      if (this.hasActiveChild()) {
         this.status = Status.ACTIVE;
-        this.expanded = this.direction === Direction.VERTICAL;
+        if (this.isInMainMenu)
+          this.expanded = this.isDirection(Direction.VERTICAL);
       }
       // manage menu items style depending to parent menu horientation
       this.element.setAttribute(`data-style-direction-${this.direction}`, '');
       this.navigationButtonClassList.add(`${this.navigationButton}--${this.direction}`);
-      // manage child items level
-      const childItems = Array.from(this.element.querySelectorAll('mg-menu-item'));
+      this.updateDisplayNotificationBadge();
+      // manage all sub levels child menu-items level with data-level attribut
+      if (this.isDirection(Direction.VERTICAL)) {
+        Array.from(this.element.querySelectorAll('mg-menu-item')).forEach(item => {
+          item.dataset.level = `${(Number(item.dataset.level) || 1) + 1}`;
+        });
+      }
+      // manage first sub-level menu-items
+      const childItems = Array.from(((_a = this.element.querySelector('mg-menu')) === null || _a === void 0 ? void 0 : _a.children) || []).filter(item => item.nodeName === 'MG-MENU-ITEM');
       childItems.forEach(item => {
-        if (this.direction === Direction.VERTICAL) {
-          const itemLevel = Number(item.getAttribute('data-level')) || 1;
-          item.setAttribute('data-level', `${itemLevel + 1}`);
-        }
+        const updateStatus = () => {
+          if (![Status.HIDDEN, Status.DISABLED].includes(this.status)) {
+            this.status = this.hasActiveChild() ? Status.ACTIVE : Status.VISIBLE;
+          }
+        };
+        // manage child menu listener
+        item.addEventListener('status-change', () => {
+          updateStatus();
+        });
+        new MutationObserver(mutationsList => {
+          if (mutationsList.some(mutation => mutation.attributeName === 'hidden'))
+            updateStatus();
+          this.updateDisplayNotificationBadge();
+        }).observe(item, { attributes: true });
       });
     }, 0);
   }
   /**
-   * Render
+   * Render ineractive element
    *
    * @returns {HTMLElement} HTML Element
    */
-  render() {
+  renderInteractiveElement() {
     const TagName = this.href !== undefined ? 'a' : 'button';
-    return (h(Host, { role: "menuitem", "aria-haspopup": this.hasChildren.toString() }, h(TagName, { href: this.href, class: this.navigationButtonClassList.join(), tabindex: [Status.DISABLED, Status.HIDDEN].includes(this.status) ? -1 : 0, disabled: this.status === Status.DISABLED, "aria-expanded": this.hasChildren && this.expanded.toString(), "aria-current": this.status === Status.ACTIVE && 'page', onClick: this.handleElementCLick }, h("slot", { name: "illustration" }), h("div", { class: `${this.navigationButton}-center` }, h("div", { class: `${this.navigationButton}-text-content` }, h("slot", { name: "label" }), h("slot", { name: "information" })), h("slot", { name: "metadata" })), this.hasChildren && this.href === undefined && (h("span", { class: {
+    return (h(TagName, { href: this.href, class: this.navigationButtonClassList.join(), tabindex: [Status.DISABLED, Status.HIDDEN].includes(this.status) ? -1 : 0, disabled: this.status === Status.DISABLED, hidden: this.status === Status.HIDDEN, "aria-expanded": this.hasChildren && this.expanded.toString(), "aria-current": this.status === Status.ACTIVE && 'page', onClick: this.handleElementCLick }, h("slot", { name: "image" }), h("div", { class: `${this.navigationButton}-center` }, h("div", { class: `${this.navigationButton}-text-content` }, h("slot", { name: "label" }), !this.displayNotificationBadge && h("slot", { name: "information" }), this.displayNotificationBadge && (h("span", { class: "mg-menu-item__navigation-button-text-content-notification" }, h("mg-badge", { label: this.badgeLabel, value: "!", variant: "text-color", slot: "information" })))), this.size !== 'regular' && h("slot", { name: "metadata" })), this.hasChildren && this.href === undefined && (h("span", { class: {
         [`${this.navigationButton}-chevron`]: true,
         [`${this.navigationButton}-chevron--rotate`]: this.expanded === true,
         'mg-a11y-animation': true,
-      } }, h("mg-icon", { icon: "chevron-down" })))), h("div", { class: { [`${this.name}__collapse-container`]: true, [`${this.name}__collapse-container--first-level`]: this.isInMainMenu && this.isdirection(Direction.HORIZONTAL) }, hidden: !this.expanded }, h("slot", null))));
+      } }, h("mg-icon", { icon: "chevron-down" })))));
+  }
+  /**
+   * Render
+   *
+   * @returns {HTMLElement} HTML Element
+   */
+  render() {
+    const getContainerClasses = () => ({
+      [`${this.name}__collapse-container`]: true,
+      [`${this.name}__collapse-container--first-level`]: this.isInMainMenu && this.isDirection(Direction.HORIZONTAL),
+    });
+    return (h(Host, { role: "menuitem", "aria-haspopup": this.hasChildren.toString() }, this.isDirection(Direction.HORIZONTAL) && this.hasChildren && this.href === undefined ? (h("mg-popover", { display: this.expanded, placement: "bottom-start", arrowHide: true, "onDisplay-change": this.handlePopoverDisplay }, this.renderInteractiveElement(), h("div", { class: getContainerClasses(), slot: "content" }, this.renderSlot()))) : ([
+      this.renderInteractiveElement(),
+      h("div", { key: "vertical-container", class: getContainerClasses(), hidden: !this.expanded }, this.renderSlot()),
+    ])));
   }
   static get is() { return "mg-menu-item"; }
   static get encapsulation() { return "shadow"; }
@@ -211,7 +278,7 @@ export class MgMenuItem {
         "optional": false,
         "docs": {
           "tags": [],
-          "text": "Define menu-item badge\nwhen defined menu-item contain an anchor instead of button"
+          "text": "Define menu-item href\nwhen defined menu-item contain an anchor instead of button"
         },
         "attribute": "href",
         "reflect": false
@@ -239,29 +306,6 @@ export class MgMenuItem {
         "reflect": true,
         "defaultValue": "Status.VISIBLE"
       },
-      "size": {
-        "type": "string",
-        "mutable": false,
-        "complexType": {
-          "original": "MenuItemSizeType",
-          "resolved": "\"large\" | \"medium\" | \"regular\"",
-          "references": {
-            "MenuItemSizeType": {
-              "location": "import",
-              "path": "./mg-menu-item.conf"
-            }
-          }
-        },
-        "required": false,
-        "optional": false,
-        "docs": {
-          "tags": [],
-          "text": "Define menu-item size. Default: \"large\"."
-        },
-        "attribute": "size",
-        "reflect": false,
-        "defaultValue": "'large'"
-      },
       "expanded": {
         "type": "boolean",
         "mutable": true,
@@ -284,23 +328,47 @@ export class MgMenuItem {
   }
   static get states() {
     return {
+      "size": {},
       "navigationButtonClassList": {},
       "direction": {},
       "isInMainMenu": {},
-      "hasChildren": {}
+      "hasChildren": {},
+      "displayNotificationBadge": {}
     };
   }
+  static get events() {
+    return [{
+        "method": "statusChange",
+        "name": "status-change",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Emited event when status change"
+        },
+        "complexType": {
+          "original": "MgMenuItem['status']",
+          "resolved": "Status.ACTIVE | Status.DISABLED | Status.HIDDEN | Status.VISIBLE",
+          "references": {
+            "MgMenuItem": {
+              "location": "global"
+            }
+          }
+        }
+      }];
+  }
   static get elementRef() { return "element"; }
   static get watchers() {
     return [{
         "propName": "status",
         "methodName": "validateStatus"
-      }, {
-        "propName": "size",
-        "methodName": "validateSize"
       }, {
         "propName": "expanded",
         "methodName": "validateExpanded"
+      }, {
+        "propName": "size",
+        "methodName": "validateSize"
       }, {
         "propName": "hasChildren",
         "methodName": "validateHasChildren"

package/dist/collection/components/molecules/mg-action-more/mg-action-more.conf.js

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

package/dist/collection/components/molecules/mg-action-more/mg-action-more.css

@@ -0,0 +1,38 @@
+/**
+ * A11Y
+ */
+.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 {
+  --mg-popover-padding-vertical: 1rem;
+  --mg-popover-padding-horizontal: 0;
+}
+
+.mg-action-more__chevron {
+  transition: 200ms;
+}
+.mg-action-more__chevron--rotate.mg-action-more__chevron {
+  transform: rotate(180deg);
+}

package/dist/collection/components/molecules/mg-action-more/mg-action-more.js

@@ -0,0 +1,252 @@
+import { h, Host } from '@stencil/core';
+import { initLocales } from '../../../locales';
+import { Status } from '../menu/mg-menu-item/mg-menu-item.conf';
+import { Direction } from '../menu/mg-menu/mg-menu.conf';
+import { createID } from '../../../utils/components.utils';
+/**
+ * MgActionMore['items'] type guard
+ *
+ * @param {unknown} prop commponent items prop
+ * @returns {boolean} return true if type is valid
+ */
+const isMgActionMoreItems = (prop) => {
+  const items = prop;
+  return typeof items === 'object' && items.every(item => typeof item === 'object' && typeof item.label === 'string' && typeof item.mouseEventHandler === 'function');
+};
+/**
+ * MgActionMore['button'] type guard
+ *
+ * @param {unknown} prop commponent button prop
+ * @returns {boolean} return true if type is valid
+ */
+const isMgActionMoreButton = (prop) => {
+  const button = prop;
+  return typeof button === 'object' && typeof button.variant === 'string' && typeof button.isIcon === 'boolean';
+};
+/**
+ * MgActionMore['icon'] type guard
+ *
+ * @param {unknown} prop commponent icon prop
+ * @returns {boolean} return true if type is valid
+ */
+const isMgActionMoreIcon = (prop) => {
+  const icon = prop;
+  return typeof icon === 'object' && typeof icon.icon === 'string';
+};
+export class MgActionMore {
+  constructor() {
+    /************
+     * Internal *
+     ************/
+    this.name = 'mg-action-more';
+    this.mgPopoverIdentifier = createID(this.name);
+    /************
+     * Merthods *
+     ***********/
+    /**
+     * Toogle expanded props
+     *
+     * @returns {void}
+     */
+    this.toggleExpanded = () => {
+      this.expanded = !this.expanded;
+    };
+    /**
+     * Button click handler
+     *
+     * @returns {void}
+     */
+    this.handleButton = () => {
+      this.toggleExpanded();
+    };
+    /**
+     * Item click handler
+     *
+     * @param {MouseEvent} event click event
+     * @param {MgActionMoreItemType['mouseEventHandler']} customHandler item['mouseEventHandler']
+     * @returns {void}
+     */
+    this.handleItemClick = (event, customHandler) => {
+      this.expanded = false;
+      customHandler(event);
+    };
+    this.icon = { icon: 'ellipsis' };
+    this.button = { variant: 'flat', isIcon: true };
+    this.items = undefined;
+    this.displayChevron = undefined;
+    this.expanded = false;
+  }
+  validateIcon(newValue) {
+    if (newValue && !isMgActionMoreIcon(newValue)) {
+      throw new Error(`<${this.name}> prop icon must match MgActionMoreIconType.`);
+    }
+  }
+  validateButton(newValue) {
+    if (newValue && !isMgActionMoreButton(newValue)) {
+      throw new Error(`<${this.name}> prop button must match MgActionMoreButtonType.`);
+    }
+  }
+  validateItems(newValue) {
+    if (!isMgActionMoreItems(newValue)) {
+      throw new Error(`<${this.name}> prop "items" is required and all values must be the same type, MgActionMoreItemType.`);
+    }
+  }
+  validateDisplayChevron(newValue) {
+    if (newValue && this.button.isIcon === true) {
+      throw new Error(`<${this.name}> prop "displayChevron" can't be used with a 'button" prop "isIcon" attribute.`);
+    }
+  }
+  /*************
+   * Lifecycle *
+   *************/
+  /**
+   * Validate props
+   *
+   * @returns {void}
+   */
+  componentWillLoad() {
+    this.messages = initLocales(this.element).messages.actionMore;
+    this.validateItems(this.items);
+    this.validateButton(this.button);
+    this.validateIcon(this.icon);
+    this.validateDisplayChevron(this.displayChevron);
+  }
+  /**
+   * Render
+   *
+   * @returns {HTMLElement} HTML Element
+   */
+  render() {
+    const buttonLabel = this.button.label || this.messages.label;
+    const buttonContent = [buttonLabel];
+    if (!this.button.isIcon && this.displayChevron) {
+      buttonContent.push(h("span", { class: {
+          [`${this.name}__chevron`]: true,
+          [`${this.name}__chevron--rotate`]: this.expanded === true,
+          'mg-a11y-animation': true,
+        } }, h("mg-icon", { icon: "chevron-down", size: "small" })));
+    }
+    return (h(Host, { "data-mg-popover-guard": this.mgPopoverIdentifier }, h("span", { class: "mg-action-more" }, h("mg-popover", { identifier: this.mgPopoverIdentifier, display: this.expanded }, h("mg-button", { variant: this.button.variant, isIcon: this.button.isIcon, type: "button", label: buttonLabel, onClick: this.handleButton }, h("mg-icon", Object.assign({}, this.icon)), !this.button.isIcon && buttonContent), h("div", { slot: "content" }, h("mg-menu", { direction: Direction.VERTICAL, label: this.messages.label }, this.items.map(item => {
+      var _a;
+      return (
+      // eslint-disable-next-line react/jsx-no-bind
+      h("mg-menu-item", { key: item.label, status: item.status || Status.VISIBLE, onClick: e => this.handleItemClick(e, item.mouseEventHandler), href: item.href }, item.icon && h("mg-icon", { icon: item.icon, slot: "image" }), h("span", { slot: "label" }, item.label), ((_a = item.badge) === null || _a === void 0 ? void 0 : _a.label) && h("mg-badge", { label: item.badge.label, value: item.badge.value, slot: "information", variant: "text-color" })));
+    })))))));
+  }
+  static get is() { return "mg-action-more"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["mg-action-more.scss"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["mg-action-more.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "icon": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "MgActionMoreIconType",
+          "resolved": "{ icon: string; }",
+          "references": {
+            "MgActionMoreIconType": {
+              "location": "import",
+              "path": "./mg-action-more.conf"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define displaied icon\nDefault: {icon: 'ellipsis'}"
+        },
+        "defaultValue": "{ icon: 'ellipsis' }"
+      },
+      "button": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "MgActionMoreButtonType",
+          "resolved": "{ isIcon: boolean; variant: \"flat\" | \"info\" | \"success\" | \"link\" | \"primary\" | \"secondary\" | \"danger\" | \"danger-alt\"; label?: string; }",
+          "references": {
+            "MgActionMoreButtonType": {
+              "location": "import",
+              "path": "./mg-action-more.conf"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define button properties\nDefault: {variant: 'flat', isIcon: true}."
+        },
+        "defaultValue": "{ variant: 'flat', isIcon: true }"
+      },
+      "items": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "MgActionMoreItemType[]",
+          "resolved": "MgActionMoreItemType[]",
+          "references": {
+            "MgActionMoreItemType": {
+              "location": "import",
+              "path": "./mg-action-more.conf"
+            }
+          }
+        },
+        "required": true,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define the menu-items elements"
+        }
+      },
+      "displayChevron": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Define if chevron is display"
+        },
+        "attribute": "display-chevron",
+        "reflect": false
+      }
+    };
+  }
+  static get states() {
+    return {
+      "expanded": {}
+    };
+  }
+  static get elementRef() { return "element"; }
+  static get watchers() {
+    return [{
+        "propName": "icon",
+        "methodName": "validateIcon"
+      }, {
+        "propName": "button",
+        "methodName": "validateButton"
+      }, {
+        "propName": "items",
+        "methodName": "validateItems"
+      }, {
+        "propName": "displayChevron",
+        "methodName": "validateDisplayChevron"
+      }];
+  }
+}

package/dist/collection/components/molecules/mg-form/mg-form.js

@@ -23,12 +23,12 @@ export class MgForm {
         // All fields are required
         // mg-input-toggle can not be required
         if (requiredInputs.length > 0 && requiredInputs.length === this.mgInputs.filter(input => input.nodeName !== 'MG-INPUT-TOGGLE').length) {
-          this.requiredMessage = this.messages.form.allRequired;
+          this.requiredMessage = requiredInputs.length === 1 ? this.messages.form.allRequiredSingle : this.messages.form.allRequired;
           this.classList.add(this.classAllRequired);
         }
         // Some fields are required
         else if (requiredInputs.length > 0) {
-          this.requiredMessage = this.messages.form.required;
+          this.requiredMessage = requiredInputs.length === 1 ? this.messages.form.requiredSingle : this.messages.form.required;
         }
       }
     };