@vaadin/context-menu 25.3.0-alpha6 → 25.3.0-alpha8

package/src/vaadin-context-menu-mixin.d.ts

@@ -5,11 +5,11 @@
  */
 import type { Constructor } from '@open-wc/dedupe-mixin';
 import type { ContextMenuRenderer } from './vaadin-context-menu.js';
-import type { ContextMenuItem, ItemsMixinClass } from './vaadin-contextmenu-items-mixin.js';
+import type { ContextMenuItemData, ItemsMixinClass } from './vaadin-contextmenu-items-mixin.js';
 
 export declare function ContextMenuMixin<
   T extends Constructor<HTMLElement>,
-  TItem extends ContextMenuItem = ContextMenuItem,
+  TItem extends ContextMenuItemData = ContextMenuItemData,
 >(base: T): Constructor<ContextMenuMixinClass> & Constructor<ItemsMixinClass<TItem>> & T;
 
 export declare class ContextMenuMixinClass {
@@ -52,6 +52,8 @@ export declare class ContextMenuMixinClass {
    * - `context` The object with the menu context, contains:
    *   - `context.target`  the target of the menu opening event,
    *   - `context.detail` the menu opening event detail.
+   *
+   * @deprecated Use a slotted `<vaadin-context-menu-list-box>` or the `items` property instead
    */
   renderer: ContextMenuRenderer | null | undefined;
 
@@ -83,5 +85,5 @@ export declare class ContextMenuMixinClass {
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export declare interface ContextMenuMixinClass<
-  TItem extends ContextMenuItem = ContextMenuItem,
+  TItem extends ContextMenuItemData = ContextMenuItemData,
 > extends ItemsMixinClass<TItem> {}

package/src/vaadin-context-menu-mixin.js

@@ -81,12 +81,22 @@ export const ContextMenuMixin = (superClass) =>
          *   - `context.target`  the target of the menu opening event,
          *   - `context.detail` the menu opening event detail.
          * @type {ContextMenuRenderer | undefined}
+         * @deprecated Use a slotted `<vaadin-context-menu-list-box>` or the `items` property instead
          */
         renderer: {
           type: Function,
           sync: true,
         },
 
+        /**
+         * The `<vaadin-context-menu-list-box>` slotted directly into the overlay slot.
+         * @private
+         */
+        __slottedListBox: {
+          type: Object,
+          sync: true,
+        },
+
         /**
          * When true, the menu overlay is modeless.
          * @protected
@@ -119,11 +129,7 @@ export const ContextMenuMixin = (superClass) =>
     }
 
     static get observers() {
-      return [
-        '_targetOrOpenOnChanged(listenOn, openOn)',
-        '_rendererChanged(renderer, items)',
-        '_fullscreenChanged(_fullscreen)',
-      ];
+      return ['_targetOrOpenOnChanged(listenOn, openOn)', '_fullscreenChanged(_fullscreen)'];
     }
 
     constructor() {
@@ -188,6 +194,25 @@ export const ContextMenuMixin = (superClass) =>
       }
     }
 
+    /** @protected */
+    updated(props) {
+      super.updated(props);
+
+      if (props.has('renderer') || props.has('items') || props.has('__slottedListBox')) {
+        const contentSources = [this.items, this.renderer, this.__slottedListBox].filter(Boolean);
+        if (contentSources.length > 1) {
+          throw new Error(
+            'The "items", "renderer", and slotted "<vaadin-context-menu-list-box>" cannot be used together.',
+          );
+        }
+
+        // With items property, menu closes on item selection or items-outside-click.
+        if (this.items && this.closeOn === 'click') {
+          this.closeOn = '';
+        }
+      }
+    }
+
     /**
      * Runs before overlay is fully rendered
      * @private
@@ -319,19 +344,6 @@ export const ContextMenuMixin = (superClass) =>
       this.__restoreMenuState();
     }
 
-    /** @private */
-    _rendererChanged(renderer, items) {
-      if (items) {
-        if (renderer) {
-          throw new Error('The items API cannot be used together with a renderer');
-        }
-
-        if (this.closeOn === 'click') {
-          this.closeOn = '';
-        }
-      }
-    }
-
     /**
      * Closes the overlay.
      */
@@ -401,7 +413,7 @@ export const ContextMenuMixin = (superClass) =>
 
     /** @private */
     __preserveMenuState() {
-      const listBox = this.__getListBox();
+      const listBox = this._menuListBox;
       if (listBox) {
         this.__focusedIndex = listBox.items.indexOf(listBox.focused);
 
@@ -417,11 +429,11 @@ export const ContextMenuMixin = (superClass) =>
       const subMenuIndex = this.__subMenuIndex;
       const selectedIndex = this.__selectedIndex;
 
-      const listBox = this.__getListBox();
+      const listBox = this._menuListBox;
 
       if (listBox) {
         // Initialize menu items synchronously
-        listBox._observer.flush();
+        listBox._observer?.flush();
 
         if (subMenuIndex > -1) {
           const itemToOpen = listBox.items[subMenuIndex];
@@ -458,6 +470,17 @@ export const ContextMenuMixin = (superClass) =>
       }
     }
 
+    /**
+     * Detects a `<vaadin-context-menu-list-box>` slotted directly into the overlay
+     * slot (instead of the default one rendered into slotted `div` element).
+     *
+     * @param {!Event} e
+     * @private
+     */
+    __onOverlaySlotChange(e) {
+      this.__slottedListBox = e.target.assignedElements().find((el) => el._hasVaadinListMixin);
+    }
+
     /** @private */
     __onScroll() {
       if (!this.opened || this.position) {

package/src/vaadin-context-menu-overlay.js

@@ -16,6 +16,7 @@ import { MenuOverlayMixin } from './vaadin-menu-overlay-mixin.js';
 /**
  * An element used internally by `<vaadin-context-menu>`. Not intended to be used separately.
  *
+ * @attr {string} theme - The theme variants to apply to the component.
  * @customElement vaadin-context-menu-overlay
  * @extends HTMLElement
  * @protected

package/src/vaadin-context-menu.d.ts

@@ -6,9 +6,9 @@
 import type { ElementMixinClass } from '@vaadin/component-base/src/element-mixin.js';
 import type { ThemePropertyMixinClass } from '@vaadin/vaadin-themable-mixin/vaadin-theme-property-mixin.js';
 import type { ContextMenuMixinClass } from './vaadin-context-menu-mixin.js';
-import type { ContextMenuItem } from './vaadin-contextmenu-items-mixin.js';
+import type { ContextMenuItem, ContextMenuItemData } from './vaadin-contextmenu-items-mixin.js';
 
-export { ContextMenuItem };
+export { ContextMenuItem, ContextMenuItemData };
 
 export type ContextMenuPosition =
   | 'bottom-end'
@@ -43,7 +43,7 @@ export type ContextMenuOpenedChangedEvent = CustomEvent<{ value: boolean }>;
 /**
  * Fired when an item is selected when the context menu is populated using the `items` API.
  */
-export type ContextMenuItemSelectedEvent<TItem extends ContextMenuItem = ContextMenuItem> = CustomEvent<{
+export type ContextMenuItemSelectedEvent<TItem extends ContextMenuItemData = ContextMenuItemData> = CustomEvent<{
   value: TItem;
 }>;
 
@@ -52,7 +52,7 @@ export type ContextMenuItemSelectedEvent<TItem extends ContextMenuItem = Context
  */
 export type ContextMenuClosedEvent = CustomEvent;
 
-export interface ContextMenuCustomEventMap<TItem extends ContextMenuItem = ContextMenuItem> {
+export interface ContextMenuCustomEventMap<TItem extends ContextMenuItemData = ContextMenuItemData> {
   'opened-changed': ContextMenuOpenedChangedEvent;
 
   'item-selected': ContextMenuItemSelectedEvent<TItem>;
@@ -64,7 +64,7 @@ export interface ContextMenuCustomEventMap<TItem extends ContextMenuItem = Conte
   closed: ContextMenuClosedEvent;
 }
 
-export interface ContextMenuEventMap<TItem extends ContextMenuItem = ContextMenuItem>
+export interface ContextMenuEventMap<TItem extends ContextMenuItemData = ContextMenuItemData>
   extends HTMLElementEventMap, ContextMenuCustomEventMap<TItem> {}
 
 /**
@@ -134,6 +134,23 @@ export interface ContextMenuEventMap<TItem extends ContextMenuItem = ContextMenu
  * </vaadin-context-menu>
  * ```
  *
+ * ### Slotted list-box
+ *
+ * The content of the menu can also be populated by providing a custom
+ * `<vaadin-context-menu-list-box>` with the `overlay` slot:
+ *
+ * ```html
+ * <vaadin-context-menu>
+ *   <vaadin-context-menu-list-box slot="overlay">
+ *     <vaadin-context-menu-item>Edit</vaadin-context-menu-item>
+ *     <vaadin-context-menu-item>Delete</vaadin-context-menu-item>
+ *   </vaadin-context-menu-list-box>
+ * </vaadin-context-menu>
+ * ```
+ *
+ * **Note:** slotted list-box supports a single root-level menu only and
+ * cannot be combined with the `items` or `renderer` API.
+ *
  * ### Rendering
  *
  * The content of the menu can be populated by using the renderer callback function.
@@ -276,19 +293,12 @@ export interface ContextMenuEventMap<TItem extends ContextMenuItem = ContextMenu
  *
  * See [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.
  *
- * ### Internal components
- *
- * When using `items` API the following internal components are themable:
- *
- * - `<vaadin-context-menu-item>` - has the same API as [`<vaadin-item>`](#/elements/vaadin-item).
- * - `<vaadin-context-menu-list-box>` - has the same API as [`<vaadin-list-box>`](#/elements/vaadin-list-box).
+ * ### Related components
  *
- * The `<vaadin-context-menu-item>` sub-menu elements have the following additional state attributes
- * on top of the built-in `<vaadin-item>` state attributes:
+ * In addition to `<vaadin-context-menu>` itself, the following components are themable:
  *
- * Attribute  | Description
- * ---------- |-------------
- * `expanded` | Expanded parent item.
+ * - [`<vaadin-context-menu-item>`](#/elements/vaadin-context-menu-item) - an item element.
+ * - [`<vaadin-context-menu-list-box>`](#/elements/vaadin-context-menu-list-box) - a list-box element.
  *
  * @fires {CustomEvent} opened-changed - Fired when the `opened` property changes.
  * @fires {CustomEvent} item-selected - Fired when an item is selected when the context menu is populated using the `items` API.
@@ -296,7 +306,7 @@ export interface ContextMenuEventMap<TItem extends ContextMenuItem = ContextMenu
  * @fires {CustomEvent} close-all-menus - Fired when all menus should close, e.g., after pressing Tab or on submenu close.
  * @fires {CustomEvent} items-outside-click - Fired when a click happens outside any open sub-menus.
  */
-declare class ContextMenu<TItem extends ContextMenuItem = ContextMenuItem> extends HTMLElement {
+declare class ContextMenu<TItem extends ContextMenuItemData = ContextMenuItemData> extends HTMLElement {
   /**
    * Position of the overlay with respect to the target.
    * Supported values: null, `top-start`, `top`, `top-end`,
@@ -318,7 +328,7 @@ declare class ContextMenu<TItem extends ContextMenuItem = ContextMenuItem> exten
   ): void;
 }
 
-interface ContextMenu<TItem extends ContextMenuItem = ContextMenuItem>
+interface ContextMenu<TItem extends ContextMenuItemData = ContextMenuItemData>
   extends ContextMenuMixinClass<TItem>, ElementMixinClass, ThemePropertyMixinClass {}
 
 declare global {

package/src/vaadin-context-menu.js

@@ -82,6 +82,23 @@ import { ContextMenuMixin } from './vaadin-context-menu-mixin.js';
  * </vaadin-context-menu>
  * ```
  *
+ * ### Slotted list-box
+ *
+ * The content of the menu can also be populated by providing a custom
+ * `<vaadin-context-menu-list-box>` with the `overlay` slot:
+ *
+ * ```html
+ * <vaadin-context-menu>
+ *   <vaadin-context-menu-list-box slot="overlay">
+ *     <vaadin-context-menu-item>Edit</vaadin-context-menu-item>
+ *     <vaadin-context-menu-item>Delete</vaadin-context-menu-item>
+ *   </vaadin-context-menu-list-box>
+ * </vaadin-context-menu>
+ * ```
+ *
+ * **Note:** slotted list-box supports a single root-level menu only and
+ * cannot be combined with the `items` or `renderer` API.
+ *
  * ### Rendering
  *
  * The content of the menu can be populated by using the renderer callback function.
@@ -224,19 +241,12 @@ import { ContextMenuMixin } from './vaadin-context-menu-mixin.js';
  *
  * See [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.
  *
- * ### Internal components
- *
- * When using `items` API the following internal components are themable:
- *
- * - `<vaadin-context-menu-item>` - has the same API as [`<vaadin-item>`](#/elements/vaadin-item).
- * - `<vaadin-context-menu-list-box>` - has the same API as [`<vaadin-list-box>`](#/elements/vaadin-list-box).
+ * ### Related components
  *
- * The `<vaadin-context-menu-item>` sub-menu elements have the following additional state attributes
- * on top of the built-in `<vaadin-item>` state attributes:
+ * In addition to `<vaadin-context-menu>` itself, the following components are themable:
  *
- * Attribute  | Description
- * ---------- |-------------
- * `expanded` | Expanded parent item.
+ * - [`<vaadin-context-menu-item>`](#/elements/vaadin-context-menu-item) - an item element.
+ * - [`<vaadin-context-menu-list-box>`](#/elements/vaadin-context-menu-list-box) - a list-box element.
  *
  * @fires {CustomEvent} opened-changed - Fired when the `opened` property changes.
  * @fires {CustomEvent} item-selected - Fired when an item is selected when the context menu is populated using the `items` API.
@@ -244,6 +254,7 @@ import { ContextMenuMixin } from './vaadin-context-menu-mixin.js';
  * @fires {CustomEvent} close-all-menus - Fired when all menus should close, e.g., after pressing Tab or on submenu close.
  * @fires {CustomEvent} items-outside-click - Fired when a click happens outside any open sub-menus.
  *
+ * @attr {string} theme - The theme variants to apply to the component.
  * @customElement vaadin-context-menu
  * @extends HTMLElement
  */
@@ -290,7 +301,7 @@ class ContextMenu extends ContextMenuMixin(ElementMixin(ThemePropertyMixin(Polyl
         .opened="${this.opened}"
         .model="${context}"
         .modeless="${this._modeless}"
-        .renderer="${this.items ? this.__itemsRenderer : this.renderer}"
+        .renderer="${this.__slottedListBox ? undefined : this.items ? this.__itemsRenderer : this.renderer}"
         .position="${position}"
         .positionTarget="${position ? context?.target : this._positionTarget}"
         .horizontalAlign="${this.__computeHorizontalAlign(position)}"
@@ -305,7 +316,7 @@ class ContextMenu extends ContextMenuMixin(ElementMixin(ThemePropertyMixin(Polyl
         @vaadin-overlay-open="${this._onVaadinOverlayOpen}"
         @vaadin-overlay-closed="${this._onVaadinOverlayClosed}"
       >
-        <slot name="overlay"></slot>
+        <slot name="overlay" @slotchange="${this.__onOverlaySlotChange}"></slot>
         <slot name="submenu" slot="submenu"></slot>
       </vaadin-context-menu-overlay>
 

package/src/vaadin-contextmenu-items-mixin.d.ts

@@ -7,7 +7,7 @@ import './vaadin-context-menu-item.js';
 import './vaadin-context-menu-list-box.js';
 import type { Constructor } from '@open-wc/dedupe-mixin';
 
-export type ContextMenuItem<TItemData extends object = object> = {
+export type ContextMenuItemData<TItemData extends object = object> = {
   text?: string;
   /**
    * Text to be set as the menu item's tooltip.
@@ -28,12 +28,17 @@ export type ContextMenuItem<TItemData extends object = object> = {
   keepOpen?: boolean;
   theme?: string[] | string;
   className?: string;
-  children?: Array<ContextMenuItem<TItemData>>;
+  children?: Array<ContextMenuItemData<TItemData>>;
 } & TItemData;
 
+/**
+ * @deprecated Use `ContextMenuItemData` instead.
+ */
+export type ContextMenuItem<TItemData extends object = object> = ContextMenuItemData<TItemData>;
+
 export declare function ItemsMixin<T extends Constructor<HTMLElement>>(base: T): Constructor<ItemsMixinClass> & T;
 
-export declare class ItemsMixinClass<TItem extends ContextMenuItem = ContextMenuItem> {
+export declare class ItemsMixinClass<TItem extends ContextMenuItemData = ContextMenuItemData> {
   /**
    * Defines a (hierarchical) menu structure for the component.
    * If a menu item has a non-empty `children` set, a sub-menu with the child items is opened

package/src/vaadin-contextmenu-items-mixin.js

@@ -11,7 +11,7 @@ export const ItemsMixin = (superClass) =>
     static get properties() {
       return {
         /**
-         * @typedef ContextMenuItem
+         * @typedef ContextMenuItemData
          * @type {object}
          * @property {string} text - Text to be set as the menu item component's textContent
          * @property {string} tooltip - Text to be set as the menu item's tooltip.
@@ -28,7 +28,7 @@ export const ItemsMixin = (superClass) =>
          * @property {boolean} keepOpen - If true, the menu will not be closed on item selection
          * @property {string} className - A space-delimited list of CSS class names to be set on the menu item component.
          * @property {string | string[]} theme - If set, sets the given theme(s) as an attribute to the menu item component, overriding any theme set on the context menu.
-         * @property {ContextMenuItem[]} children - Array of child menu items
+         * @property {ContextMenuItemData[]} children - Array of child menu items
          */
 
         /**
@@ -71,7 +71,7 @@ export const ItemsMixin = (superClass) =>
          * </vaadin-context-menu>
          * ```
          *
-         * @type {!Array<!ContextMenuItem> | undefined}
+         * @type {!Array<!ContextMenuItemData> | undefined}
          */
         items: {
           type: Array,
@@ -140,7 +140,7 @@ export const ItemsMixin = (superClass) =>
     /** @protected */
     __forwardFocus() {
       const overlay = this._overlayElement;
-      const child = overlay._contentRoot.firstElementChild;
+      const child = this._menuListBox ?? overlay._contentRoot.firstElementChild;
       // If parent item is not focused, do not focus submenu
       if (overlay.parentOverlay) {
         const parent = overlay.parentOverlay._contentRoot.querySelector('[expanded]');
@@ -192,7 +192,7 @@ export const ItemsMixin = (superClass) =>
     }
 
     /**
-     * @param {!ContextMenuItem} item
+     * @param {!ContextMenuItemData} item
      * @return {HTMLElement}
      * @private
      */
@@ -460,9 +460,17 @@ export const ItemsMixin = (superClass) =>
       }
     }
 
-    /** @protected */
-    __getListBox() {
-      return this._overlayElement._contentRoot.querySelector(`${this._tagNamePrefix}-list-box`);
+    /**
+     * The list-box holding the menu items: either one slotted directly into the
+     * overlay slot, or the one created inside the renderer root by the `items`
+     * path.
+     * @protected
+     * @return {HTMLElement | null | undefined}
+     */
+    get _menuListBox() {
+      return (
+        this.__slottedListBox ?? this._overlayElement._contentRoot.querySelector(`${this._tagNamePrefix}-list-box`)
+      );
     }
 
     /**

package/src/vaadin-menu-overlay-mixin.js

@@ -67,7 +67,7 @@ export const MenuOverlayMixin = (superClass) =>
 
       this.addEventListener('keydown', (e) => {
         if (!e.defaultPrevented && e.composedPath()[0] === this.$.overlay && [38, 40].indexOf(e.keyCode) > -1) {
-          const child = this._contentRoot.firstElementChild;
+          const child = this.owner._menuListBox ?? this._contentRoot.firstElementChild;
           if (child && Array.isArray(child.items) && child.items.length) {
             e.preventDefault();
             if (e.keyCode === 38) {

package/vaadin-context-menu-item.d.ts

@@ -0,0 +1 @@
+export * from './src/vaadin-context-menu-item.js';

package/vaadin-context-menu-item.js

@@ -0,0 +1,2 @@
+import './src/vaadin-context-menu-item.js';
+export * from './src/vaadin-context-menu-item.js';

package/vaadin-context-menu-list-box.d.ts

@@ -0,0 +1 @@
+export * from './src/vaadin-context-menu-list-box.js';

package/vaadin-context-menu-list-box.js

@@ -0,0 +1,2 @@
+import './src/vaadin-context-menu-list-box.js';
+export * from './src/vaadin-context-menu-list-box.js';

package/web-types.json

@@ -1,14 +1,135 @@
 {
   "$schema": "https://json.schemastore.org/web-types",
   "name": "@vaadin/context-menu",
-  "version": "25.3.0-alpha6",
+  "version": "25.3.0-alpha8",
   "description-markup": "markdown",
   "contributions": {
     "html": {
       "elements": [
+        {
+          "name": "vaadin-context-menu-item",
+          "description": "`<vaadin-context-menu-item>` is a Web Component for creating `<vaadin-context-menu>` items.\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name    | Description\n-------------|----------------\n`checkmark`  | The graphical checkmark shown for a checked item\n`content`    | The element that wraps the slot\n\nThe following state attributes are available for styling:\n\nAttribute    | Description\n-------------|-------------\n`active`     | Set when the item is pressed down, either with mouse, touch or the keyboard.\n`disabled`   | Set when the item is disabled.\n`focus-ring` | Set when the item is focused using the keyboard.\n`focused`    | Set when the item is focused.\n`expanded`   | Set when the item has a sub-menu and it is opened.\n\nThe following custom CSS properties are available for styling:\n\nCustom CSS property                |\n:----------------------------------|\n| `--vaadin-item-border-radius`    |\n| `--vaadin-item-checkmark-color`  |\n| `--vaadin-item-gap`              |\n| `--vaadin-item-height`           |\n| `--vaadin-item-padding`          |\n| `--vaadin-item-text-align`       |\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.",
+          "attributes": [
+            {
+              "name": "disabled",
+              "description": "If true, the user cannot interact with this element.",
+              "value": {
+                "type": [
+                  "boolean"
+                ]
+              }
+            },
+            {
+              "name": "selected",
+              "description": "If true, the item is in selected state.",
+              "value": {
+                "type": [
+                  "boolean"
+                ]
+              }
+            },
+            {
+              "name": "theme",
+              "description": "The theme variants to apply to the component.",
+              "value": {
+                "type": [
+                  "string"
+                ]
+              }
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "disabled",
+                "description": "If true, the user cannot interact with this element.",
+                "value": {
+                  "type": [
+                    "boolean"
+                  ]
+                }
+              },
+              {
+                "name": "selected",
+                "description": "If true, the item is in selected state.",
+                "value": {
+                  "type": [
+                    "boolean"
+                  ]
+                }
+              },
+              {
+                "name": "value",
+                "description": "Submittable string value. The default value is the trimmed text content of the element.",
+                "value": {
+                  "type": [
+                    "string"
+                  ]
+                }
+              }
+            ],
+            "events": []
+          }
+        },
+        {
+          "name": "vaadin-context-menu-list-box",
+          "description": "`<vaadin-context-menu-list-box>` is a Web Component for wrapping `<vaadin-context-menu>` items.\n\n```html\n<vaadin-context-menu>\n  <vaadin-context-menu-list-box slot=\"overlay\">\n    <vaadin-context-menu-item>Edit</vaadin-context-menu-item>\n    <vaadin-context-menu-item>Delete</vaadin-context-menu-item>\n  </vaadin-context-menu-list-box>\n</vaadin-context-menu>\n```\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name         | Description\n------------------|------------------------\n`items`           | The items container\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.",
+          "attributes": [
+            {
+              "name": "disabled",
+              "description": "If true, the user cannot interact with this element.\nWhen the element is disabled, the selected item is\nnot updated when `selected` property is changed.",
+              "value": {
+                "type": [
+                  "boolean"
+                ]
+              }
+            },
+            {
+              "name": "selected",
+              "description": "The index of the item selected in the items array.\nNote: Not updated when used in `multiple` selection mode.",
+              "value": {
+                "type": [
+                  "number"
+                ]
+              }
+            },
+            {
+              "name": "theme",
+              "description": "The theme variants to apply to the component.",
+              "value": {
+                "type": [
+                  "string"
+                ]
+              }
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "disabled",
+                "description": "If true, the user cannot interact with this element.\nWhen the element is disabled, the selected item is\nnot updated when `selected` property is changed.",
+                "value": {
+                  "type": [
+                    "boolean"
+                  ]
+                }
+              },
+              {
+                "name": "selected",
+                "description": "The index of the item selected in the items array.\nNote: Not updated when used in `multiple` selection mode.",
+                "value": {
+                  "type": [
+                    "number"
+                  ]
+                }
+              }
+            ],
+            "events": []
+          }
+        },
         {
           "name": "vaadin-context-menu",
-          "description": "`<vaadin-context-menu>` is a Web Component for creating context menus.\n\n### Items\n\nItems is a higher level convenience API for defining a (hierarchical) menu structure for the component.\nIf a menu item has a non-empty `children` set, a sub-menu with the child items is opened\nnext to the parent menu on mouseover, tap or a right arrow keypress.\n\nWhen an item is selected, `<vaadin-context-menu>` dispatches an \"item-selected\" event\nwith the selected item as `event.detail.value` property.\nIf item does not have `keepOpen` property the menu will be closed.\n\n```javascript\ncontextMenu.items = [\n  { text: 'Menu Item 1', theme: 'primary', className: 'first', children:\n    [\n      { text: 'Menu Item 1-1', checked: true, keepOpen: true },\n      { text: 'Menu Item 1-2' }\n    ]\n  },\n  { component: 'hr' },\n  { text: 'Menu Item 2', children:\n    [\n      { text: 'Menu Item 2-1' },\n      { text: 'Menu Item 2-2', disabled: true }\n    ]\n  },\n  { text: 'Menu Item 3', disabled: true, className: 'last' }\n];\n\ncontextMenu.addEventListener('item-selected', e => {\n  const item = e.detail.value;\n  console.log(`${item.text} selected`);\n});\n```\n\n**NOTE:** when the `items` array is defined, the renderer cannot be used.\n\n#### Disabled menu items\n\nWhen disabled, menu items are rendered as \"dimmed\".\n\nBy default, disabled items are not focusable and don't react to hover.\nAs a result, they are hidden from assistive technologies, and it's not\npossible to show a tooltip to explain why they are disabled. This can\nbe addressed by enabling the feature flag `accessibleDisabledMenuItems`,\nwhich makes disabled items focusable and hoverable, while still\npreventing them from being activated:\n\n```js\n// Set before any context menu is attached to the DOM.\nwindow.Vaadin.featureFlags.accessibleDisabledMenuItems = true;\n```\n\n#### Item tooltips\n\nMenu items can have tooltips that are shown on hover and keyboard\nfocus. To enable them, add a slotted `<vaadin-tooltip>` element\nand set the `tooltip` property on each item that should have one:\n\n```html\n<vaadin-context-menu>\n  <vaadin-tooltip slot=\"tooltip\"></vaadin-tooltip>\n</vaadin-context-menu>\n```\n\n### Rendering\n\nThe content of the menu can be populated by using the renderer callback function.\n\nThe renderer function provides `root`, `contextMenu`, `model` arguments when applicable.\nGenerate DOM content by using `model` object properties if needed, append it to the `root`\nelement and control the state of the host element by accessing `contextMenu`. Before generating\nnew content, the renderer function should check if there is already content in `root` for reusing it.\n\n```html\n<vaadin-context-menu id=\"contextMenu\">\n <p>This paragraph has a context menu.</p>\n</vaadin-context-menu>\n```\n```js\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.renderer = (root, contextMenu, context) => {\n  let listBox = root.firstElementChild;\n  if (!listBox) {\n    listBox = document.createElement('vaadin-list-box');\n    root.appendChild(listBox);\n  }\n\n  let item = listBox.querySelector('vaadin-item');\n  if (!item) {\n    item = document.createElement('vaadin-item');\n    listBox.appendChild(item);\n  }\n  item.textContent = 'Content of the selector: ' + context.target.textContent;\n};\n```\n\nYou can access the menu context inside the renderer using\n`context.target` and `context.detail`.\n\nRenderer is called on the opening of the context-menu and each time the related context is updated.\nDOM generated during the renderer call can be reused\nin the next renderer call and will be provided with the `root` argument.\nOn first call it will be empty.\n\n### `vaadin-contextmenu` Gesture Event\n\n`vaadin-contextmenu` is a gesture event (a custom event),\nwhich is dispatched after either `contextmenu` or long touch events.\nThis enables support for both mouse and touch environments in a uniform way.\n\n`<vaadin-context-menu>` opens the menu overlay on the `vaadin-contextmenu`\nevent by default.\n\n### Menu Listener\n\nBy default, the `<vaadin-context-menu>` element listens for the menu opening\nevent on itself. In case if you do not want to wrap the target, you can listen for\nevents on an element outside the `<vaadin-context-menu>` by setting the\n`listenOn` property:\n\n```html\n<vaadin-context-menu id=\"contextMenu\"></vaadin-context-menu>\n\n<div id=\"menuListener\">The element that listens for the contextmenu event.</div>\n```\n```javascript\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.listenOn = document.querySelector('#menuListener');\n```\n\n### Filtering Menu Targets\n\nBy default, the listener element and all its descendants open the context\nmenu. You can filter the menu targets to a smaller set of elements inside\nthe listener element by setting the `selector` property.\n\nIn the following example, only the elements matching `.has-menu` will open the context menu:\n\n```html\n<vaadin-context-menu selector=\".has-menu\">\n  <p class=\"has-menu\">This paragraph opens the context menu</p>\n  <p>This paragraph does not open the context menu</p>\n</vaadin-context-menu>\n```\n\n### Menu Context\n\nThe following properties are available in the `context` argument:\n\n- `target` is the menu opening event target, which is the element that\nthe user has called the context menu for\n- `detail` is the menu opening event detail\n\nIn the following example, the menu item text is composed with the contents\nof the element that opened the menu:\n\n```html\n<vaadin-context-menu selector=\"li\" id=\"contextMenu\">\n  <ul>\n    <li>Foo</li>\n    <li>Bar</li>\n    <li>Baz</li>\n  </ul>\n</vaadin-context-menu>\n```\n```js\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.renderer = (root, contextMenu, context) => {\n  let listBox = root.firstElementChild;\n  if (!listBox) {\n    listBox = document.createElement('vaadin-list-box');\n    root.appendChild(listBox);\n  }\n\n  let item = listBox.querySelector('vaadin-item');\n  if (!item) {\n    item = document.createElement('vaadin-item');\n    listBox.appendChild(item);\n  }\n  item.textContent = 'The menu target: ' + context.target.textContent;\n};\n```\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name        | Description\n-----------------|-------------------------------------------\n`backdrop`       | Backdrop of the overlay\n`overlay`        | The overlay container\n`content`        | The overlay content\n\n### Custom CSS Properties\n\nThe following custom CSS properties are available for styling:\n\nCustom CSS property                   | Description\n--------------------------------------|-------------\n`--vaadin-context-menu-offset-top`    | Used as an offset when using `position` and the context menu is aligned vertically below the target\n`--vaadin-context-menu-offset-bottom` | Used as an offset when using `position` and the context menu is aligned vertically above the target\n`--vaadin-context-menu-offset-start`  | Used as an offset when using `position` and the context menu is aligned horizontally after the target\n`--vaadin-context-menu-offset-end`    | Used as an offset when using `position` and the context menu is aligned horizontally before the target\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.\n\n### Internal components\n\nWhen using `items` API the following internal components are themable:\n\n- `<vaadin-context-menu-item>` - has the same API as [`<vaadin-item>`](https://cdn.vaadin.com/vaadin-web-components/25.3.0-alpha6/#/elements/vaadin-item).\n- `<vaadin-context-menu-list-box>` - has the same API as [`<vaadin-list-box>`](https://cdn.vaadin.com/vaadin-web-components/25.3.0-alpha6/#/elements/vaadin-list-box).\n\nThe `<vaadin-context-menu-item>` sub-menu elements have the following additional state attributes\non top of the built-in `<vaadin-item>` state attributes:\n\nAttribute  | Description\n---------- |-------------\n`expanded` | Expanded parent item.",
+          "description": "`<vaadin-context-menu>` is a Web Component for creating context menus.\n\n### Items\n\nItems is a higher level convenience API for defining a (hierarchical) menu structure for the component.\nIf a menu item has a non-empty `children` set, a sub-menu with the child items is opened\nnext to the parent menu on mouseover, tap or a right arrow keypress.\n\nWhen an item is selected, `<vaadin-context-menu>` dispatches an \"item-selected\" event\nwith the selected item as `event.detail.value` property.\nIf item does not have `keepOpen` property the menu will be closed.\n\n```javascript\ncontextMenu.items = [\n  { text: 'Menu Item 1', theme: 'primary', className: 'first', children:\n    [\n      { text: 'Menu Item 1-1', checked: true, keepOpen: true },\n      { text: 'Menu Item 1-2' }\n    ]\n  },\n  { component: 'hr' },\n  { text: 'Menu Item 2', children:\n    [\n      { text: 'Menu Item 2-1' },\n      { text: 'Menu Item 2-2', disabled: true }\n    ]\n  },\n  { text: 'Menu Item 3', disabled: true, className: 'last' }\n];\n\ncontextMenu.addEventListener('item-selected', e => {\n  const item = e.detail.value;\n  console.log(`${item.text} selected`);\n});\n```\n\n**NOTE:** when the `items` array is defined, the renderer cannot be used.\n\n#### Disabled menu items\n\nWhen disabled, menu items are rendered as \"dimmed\".\n\nBy default, disabled items are not focusable and don't react to hover.\nAs a result, they are hidden from assistive technologies, and it's not\npossible to show a tooltip to explain why they are disabled. This can\nbe addressed by enabling the feature flag `accessibleDisabledMenuItems`,\nwhich makes disabled items focusable and hoverable, while still\npreventing them from being activated:\n\n```js\n// Set before any context menu is attached to the DOM.\nwindow.Vaadin.featureFlags.accessibleDisabledMenuItems = true;\n```\n\n#### Item tooltips\n\nMenu items can have tooltips that are shown on hover and keyboard\nfocus. To enable them, add a slotted `<vaadin-tooltip>` element\nand set the `tooltip` property on each item that should have one:\n\n```html\n<vaadin-context-menu>\n  <vaadin-tooltip slot=\"tooltip\"></vaadin-tooltip>\n</vaadin-context-menu>\n```\n\n### Slotted list-box\n\nThe content of the menu can also be populated by providing a custom\n`<vaadin-context-menu-list-box>` with the `overlay` slot:\n\n```html\n<vaadin-context-menu>\n  <vaadin-context-menu-list-box slot=\"overlay\">\n    <vaadin-context-menu-item>Edit</vaadin-context-menu-item>\n    <vaadin-context-menu-item>Delete</vaadin-context-menu-item>\n  </vaadin-context-menu-list-box>\n</vaadin-context-menu>\n```\n\n**Note:** slotted list-box supports a single root-level menu only and\ncannot be combined with the `items` or `renderer` API.\n\n### Rendering\n\nThe content of the menu can be populated by using the renderer callback function.\n\nThe renderer function provides `root`, `contextMenu`, `model` arguments when applicable.\nGenerate DOM content by using `model` object properties if needed, append it to the `root`\nelement and control the state of the host element by accessing `contextMenu`. Before generating\nnew content, the renderer function should check if there is already content in `root` for reusing it.\n\n```html\n<vaadin-context-menu id=\"contextMenu\">\n <p>This paragraph has a context menu.</p>\n</vaadin-context-menu>\n```\n```js\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.renderer = (root, contextMenu, context) => {\n  let listBox = root.firstElementChild;\n  if (!listBox) {\n    listBox = document.createElement('vaadin-list-box');\n    root.appendChild(listBox);\n  }\n\n  let item = listBox.querySelector('vaadin-item');\n  if (!item) {\n    item = document.createElement('vaadin-item');\n    listBox.appendChild(item);\n  }\n  item.textContent = 'Content of the selector: ' + context.target.textContent;\n};\n```\n\nYou can access the menu context inside the renderer using\n`context.target` and `context.detail`.\n\nRenderer is called on the opening of the context-menu and each time the related context is updated.\nDOM generated during the renderer call can be reused\nin the next renderer call and will be provided with the `root` argument.\nOn first call it will be empty.\n\n### `vaadin-contextmenu` Gesture Event\n\n`vaadin-contextmenu` is a gesture event (a custom event),\nwhich is dispatched after either `contextmenu` or long touch events.\nThis enables support for both mouse and touch environments in a uniform way.\n\n`<vaadin-context-menu>` opens the menu overlay on the `vaadin-contextmenu`\nevent by default.\n\n### Menu Listener\n\nBy default, the `<vaadin-context-menu>` element listens for the menu opening\nevent on itself. In case if you do not want to wrap the target, you can listen for\nevents on an element outside the `<vaadin-context-menu>` by setting the\n`listenOn` property:\n\n```html\n<vaadin-context-menu id=\"contextMenu\"></vaadin-context-menu>\n\n<div id=\"menuListener\">The element that listens for the contextmenu event.</div>\n```\n```javascript\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.listenOn = document.querySelector('#menuListener');\n```\n\n### Filtering Menu Targets\n\nBy default, the listener element and all its descendants open the context\nmenu. You can filter the menu targets to a smaller set of elements inside\nthe listener element by setting the `selector` property.\n\nIn the following example, only the elements matching `.has-menu` will open the context menu:\n\n```html\n<vaadin-context-menu selector=\".has-menu\">\n  <p class=\"has-menu\">This paragraph opens the context menu</p>\n  <p>This paragraph does not open the context menu</p>\n</vaadin-context-menu>\n```\n\n### Menu Context\n\nThe following properties are available in the `context` argument:\n\n- `target` is the menu opening event target, which is the element that\nthe user has called the context menu for\n- `detail` is the menu opening event detail\n\nIn the following example, the menu item text is composed with the contents\nof the element that opened the menu:\n\n```html\n<vaadin-context-menu selector=\"li\" id=\"contextMenu\">\n  <ul>\n    <li>Foo</li>\n    <li>Bar</li>\n    <li>Baz</li>\n  </ul>\n</vaadin-context-menu>\n```\n```js\nconst contextMenu = document.querySelector('#contextMenu');\ncontextMenu.renderer = (root, contextMenu, context) => {\n  let listBox = root.firstElementChild;\n  if (!listBox) {\n    listBox = document.createElement('vaadin-list-box');\n    root.appendChild(listBox);\n  }\n\n  let item = listBox.querySelector('vaadin-item');\n  if (!item) {\n    item = document.createElement('vaadin-item');\n    listBox.appendChild(item);\n  }\n  item.textContent = 'The menu target: ' + context.target.textContent;\n};\n```\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name        | Description\n-----------------|-------------------------------------------\n`backdrop`       | Backdrop of the overlay\n`overlay`        | The overlay container\n`content`        | The overlay content\n\n### Custom CSS Properties\n\nThe following custom CSS properties are available for styling:\n\nCustom CSS property                   | Description\n--------------------------------------|-------------\n`--vaadin-context-menu-offset-top`    | Used as an offset when using `position` and the context menu is aligned vertically below the target\n`--vaadin-context-menu-offset-bottom` | Used as an offset when using `position` and the context menu is aligned vertically above the target\n`--vaadin-context-menu-offset-start`  | Used as an offset when using `position` and the context menu is aligned horizontally after the target\n`--vaadin-context-menu-offset-end`    | Used as an offset when using `position` and the context menu is aligned horizontally before the target\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.\n\n### Related components\n\nIn addition to `<vaadin-context-menu>` itself, the following components are themable:\n\n- [`<vaadin-context-menu-item>`](https://cdn.vaadin.com/vaadin-web-components/25.3.0-alpha8/#/elements/vaadin-context-menu-item) - an item element.\n- [`<vaadin-context-menu-list-box>`](https://cdn.vaadin.com/vaadin-web-components/25.3.0-alpha8/#/elements/vaadin-context-menu-list-box) - a list-box element.",
           "attributes": [
             {
               "name": "close-on",
@@ -51,9 +172,7 @@
               "description": "The theme variants to apply to the component.",
               "value": {
                 "type": [
-                  "string",
-                  "null",
-                  "undefined"
+                  "string"
                 ]
               }
             }
@@ -74,7 +193,7 @@
                 "description": "Defines a (hierarchical) menu structure for the component.\nIf a menu item has a non-empty `children` set, a sub-menu with the child items is opened\nnext to the parent menu on mouseover, tap or a right arrow keypress.\n\nThe items API can't be used together with a renderer!\n\n#### Example\n\n```javascript\ncontextMenu.items = [\n  { text: 'Menu Item 1', theme: 'primary', className: 'first', children:\n    [\n      { text: 'Menu Item 1-1', checked: true, keepOpen: true },\n      { text: 'Menu Item 1-2' }\n    ]\n  },\n  { component: 'hr' },\n  { text: 'Menu Item 2', children:\n    [\n      { text: 'Menu Item 2-1' },\n      { text: 'Menu Item 2-2', disabled: true }\n    ]\n  },\n  { text: 'Menu Item 3', disabled: true, className: 'last' }\n];\n```\n\n#### Item tooltips\n\nMenu items can have tooltips that are shown on hover and keyboard\nfocus. To enable them, add a slotted `<vaadin-tooltip>` element\nand set the `tooltip` property on each item that should have one:\n\n```html\n<vaadin-context-menu>\n  <vaadin-tooltip slot=\"tooltip\"></vaadin-tooltip>\n</vaadin-context-menu>\n```",
                 "value": {
                   "type": [
-                    "Array<ContextMenuItem>",
+                    "Array<ContextMenuItemData>",
                     "undefined"
                   ]
                 }