@progress/kendo-vue-layout 3.5.0 → 3.5.1-dev.202208100944

package/dist/esm/main.d.ts

@@ -0,0 +1,49 @@
+export * from './tabstrip/TabStrip';
+export * from './tabstrip/TabStripContent';
+export * from './tabstrip/TabStripNavigation';
+export * from './tabstrip/TabStripNavigationItem';
+export * from './tabstrip/TabStripTab';
+export * from './card/Card';
+export * from './card/CardHeader';
+export * from './card/CardTitle';
+export * from './card/CardBody';
+export * from './card/CardActions';
+export * from './card/CardImage';
+export * from './card/CardSubtitle';
+export * from './card/CardFooter';
+export * from './card/Avatar';
+export * from './drawer/Drawer';
+export * from './drawer/interfaces/DrawerProps';
+export * from './drawer/DrawerNavigation';
+export * from './drawer/interfaces/DrawerNavigationProps';
+export * from './drawer/DrawerContent';
+export * from './drawer/interfaces/DrawerContentProps';
+export * from './drawer/DrawerItem';
+export * from './drawer/interfaces/DrawerItemHandle';
+export * from './drawer/interfaces/DrawerItemProps';
+export * from './drawer/interfaces/DrawerSelectEvent';
+export * from './drawer/interfaces/DrawerAnimation';
+export * from './stepper/Stepper';
+export * from './stepper/interfaces/StepperProps';
+export * from './stepper/interfaces/StepperHandle';
+export * from './stepper/interfaces/StepperChangeEvent';
+export * from './stepper/interfaces/StepperFocusEvent';
+export * from './stepper/Step';
+export * from './stepper/interfaces/StepProps';
+export * from './stepper/interfaces/StepHandle';
+export * from './stepper/interfaces/StepChangeEvent';
+export * from './stepper/interfaces/StepFocusEvent';
+export * from './menu/components/Menu';
+export * from './menu/components/MenuItemLink';
+export * from './menu/components/MenuItemArrow';
+export * from './menu/models/MenuItemModel';
+export * from './menu/events';
+export * from './splitter/Splitter';
+export * from './splitter/SplitterPane';
+export * from './panelbar/PanelBar';
+export * from './panelbar/PanelBarItem';
+export * from './panelbar/util';
+export * from './panelbar/interfaces/PanelBarProps';
+export * from './panelbar/interfaces/PanelBarItemProps';
+export * from './panelbar/interfaces/RenderPanelBarItem';
+export * from './panelbar/interfaces/PanelBarSelectEventArguments';

package/dist/esm/main.js

@@ -0,0 +1,49 @@
+export * from './tabstrip/TabStrip.js';
+export * from './tabstrip/TabStripContent.js';
+export * from './tabstrip/TabStripNavigation.js';
+export * from './tabstrip/TabStripNavigationItem.js';
+export * from './tabstrip/TabStripTab.js';
+export * from './card/Card.js';
+export * from './card/CardHeader.js';
+export * from './card/CardTitle.js';
+export * from './card/CardBody.js';
+export * from './card/CardActions.js';
+export * from './card/CardImage.js';
+export * from './card/CardSubtitle.js';
+export * from './card/CardFooter.js';
+export * from './card/Avatar.js';
+export * from './drawer/Drawer.js';
+export * from './drawer/interfaces/DrawerProps.js';
+export * from './drawer/DrawerNavigation.js';
+export * from './drawer/interfaces/DrawerNavigationProps.js';
+export * from './drawer/DrawerContent.js';
+export * from './drawer/interfaces/DrawerContentProps.js';
+export * from './drawer/DrawerItem.js';
+export * from './drawer/interfaces/DrawerItemHandle.js';
+export * from './drawer/interfaces/DrawerItemProps.js';
+export * from './drawer/interfaces/DrawerSelectEvent.js';
+export * from './drawer/interfaces/DrawerAnimation.js';
+export * from './stepper/Stepper.js';
+export * from './stepper/interfaces/StepperProps.js';
+export * from './stepper/interfaces/StepperHandle.js';
+export * from './stepper/interfaces/StepperChangeEvent.js';
+export * from './stepper/interfaces/StepperFocusEvent.js';
+export * from './stepper/Step.js';
+export * from './stepper/interfaces/StepProps.js';
+export * from './stepper/interfaces/StepHandle.js';
+export * from './stepper/interfaces/StepChangeEvent.js';
+export * from './stepper/interfaces/StepFocusEvent.js';
+export * from './menu/components/Menu.js';
+export * from './menu/components/MenuItemLink.js';
+export * from './menu/components/MenuItemArrow.js';
+export * from './menu/models/MenuItemModel.js';
+export * from './menu/events.js';
+export * from './splitter/Splitter.js';
+export * from './splitter/SplitterPane.js';
+export * from './panelbar/PanelBar.js';
+export * from './panelbar/PanelBarItem.js';
+export * from './panelbar/util.js';
+export * from './panelbar/interfaces/PanelBarProps.js';
+export * from './panelbar/interfaces/PanelBarItemProps.js';
+export * from './panelbar/interfaces/RenderPanelBarItem.js';
+export * from './panelbar/interfaces/PanelBarSelectEventArguments.js';

package/dist/esm/menu/BaseMenuItemInternalProps.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @hidden
+ */
+export interface BaseMenuItemInternalProps {
+    focusedItemId: string;
+    lastItemIdToBeOpened: string;
+    tabbableItemId: string;
+    itemRender?: any;
+    linkRender?: any;
+    isMenuVertical: boolean;
+    isDirectionRightToLeft?: boolean;
+    menuGuid: string;
+    onMouseOver?: any;
+    onMouseLeave?: any;
+    onMouseDown?: any;
+    onFocus?: any;
+    onClick?: any;
+    onBlur?: any;
+    originalItemNeeded?: any;
+}

package/dist/esm/menu/BaseMenuItemInternalProps.js

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

package/dist/esm/menu/MenuProps.d.ts

@@ -0,0 +1,51 @@
+import { MenuItemModel } from './models/MenuItemModel';
+import { MenuSelectEvent } from './events';
+/**
+ * The properties of the [Kendo UI for Vue Menu component]({% slug overview_menu %}).
+ */
+export interface MenuProps {
+    /**
+     * Specifies whether the Menu will be vertical ([see example]({% slug vertical_menu %})).
+     */
+    vertical?: boolean;
+    /**
+     * Sets the Menu items.
+     */
+    items?: MenuItemModel[];
+    /**
+     * Sets the direction of the Menu.
+     */
+    dir?: string;
+    /**
+     * Specifies the delay in milliseconds before the Menu items are opened on item mouse-hover ([see example]({% slug opening_closing_menu %}#toc-delay-on-hover)). Defaults to `100`. If `openOnClick` is `true`, defaults to `0`.
+     */
+    hoverOpenDelay?: number;
+    /**
+     * Specifies the delay in milliseconds before the Menu items are closed on item mouse-leave ([see example]({% slug opening_closing_menu %}#toc-delay-on-hover)). Used to avoid accidental closure on leaving. Defaults to `100`.
+     */
+    hoverCloseDelay?: number;
+    /**
+     * If `openOnClick` is set to `true`, the items are opened on mouse hover only after an initial click.
+     */
+    openOnClick?: boolean;
+    /**
+     * A Vue functional or class component which is used for rendering the innermost part of the Menu item ([see example]({% slug rendering_menu %}#toc-items)). By default, the innermost item part includes only the text for the item.
+     */
+    itemRender?: any;
+    /**
+     * A Vue functional or class component which is used for rendering the link of the item ([see example]({% slug rendering_menu %}#toc-links)). The item link is a part of the visual representation of the item which, by default, includes an arrow, icon, and text.
+     */
+    linkRender?: any;
+    /**
+     * Sets the ids of the Menu items that will not be closed on mouse-leave. The ids are hierarchical and zero-based. The first root item has a `0` id. If the first root item has children, the first child item acquires a `0_0` id and the second acquires a `0_1` id.
+     */
+    customCloseItemIds?: string[];
+    /**
+     * Adds a custom className to the Menu top element.
+     */
+    className?: string;
+    /**
+     * Fires when a Menu item is selected.
+     */
+    onSelect?: (event: MenuSelectEvent) => void;
+}

package/dist/esm/menu/MenuProps.js

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

package/dist/esm/menu/components/Menu.d.ts

@@ -0,0 +1,79 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { MenuItemInternalModel, MenuItemModel } from '../models/MenuItemModel';
+import { MenuProps } from '../MenuProps';
+import { MouseOverHandler } from '../utils/MouseOverHandler';
+/**
+ * @hidden
+ */
+export interface MenuState {
+    itemHoverRequest: any;
+    itemLeaveRequest: any;
+    menuWrapperEl: any;
+    guid: string;
+    directionHolder: any;
+    inputItems: MenuItemModel[];
+    currentItems: MenuItemInternalModel[];
+    mouseOverHandler: MouseOverHandler;
+}
+/**
+ * @hidden
+ */
+export interface MenuComputed {
+    menuClassName: object;
+}
+/**
+ * @hidden
+ */
+export interface MenuMethods {
+    [key: string]: any;
+    reset: () => void;
+    onKeyDown: (event: any) => void;
+    onItemMouseOver: (itemId: string) => void;
+    onItemMouseLeave: (itemId: string) => void;
+    onItemMouseDown: () => void;
+    onItemFocus: (itemId: string) => void;
+    onItemClick: (event: any, itemId: string) => void;
+    onItemBlur: (itemId: string) => void;
+    getInputItem: (itemId: string) => void;
+    setFocusedItemId: (focusedItemId: string) => void;
+    setHoveredItemId: (hoveredItemId: string) => void;
+    getMenuWrapperClassName: () => object;
+    clearItemHoverAndLeaveRequestsIfApplicable: () => void;
+    isItemWithDefaultClose: (itemId: string) => boolean;
+    checkIsDirectionRightToLeft: () => any;
+    prepareItems: () => void;
+    dispatchSelectEventIfWired: (event: any, itemId: string) => void;
+}
+/**
+ * @hidden
+ */
+export interface MenuData {
+    focusedItemId: string;
+    hoveredItemId: string;
+    tabbableItemId: string;
+    isFirstRender: boolean;
+}
+/**
+ * @hidden
+ */
+export interface MenuAll extends Vue2type, MenuMethods, MenuData, MenuComputed, MenuState {
+}
+/**
+ * @hidden
+ */
+declare let MenuVue2: ComponentOptions<MenuAll, DefaultData<MenuData>, DefaultMethods<MenuAll>, MenuComputed, RecordPropsDefinition<MenuProps>>;
+/**
+ *
+ * Represents the [Kendo UI for Vue Menu component]({% slug overview_menu %}).
+ *
+ *
+ * ### props <span class='code'>Readonly&lt;[MenuProps]({% slug api_layout_menuprops %})&gt;</span>
+ * The props of the Menu component.
+ *
+ */
+declare const Menu: DefineComponent<MenuProps, any, MenuData, MenuComputed, MenuMethods, {}, {}, {}, string, MenuProps, MenuProps, {}>;
+export { Menu, MenuVue2 };

package/dist/esm/menu/components/Menu.js

@@ -0,0 +1,322 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { templateRendering, getListeners, setRef, getRef } from '@progress/kendo-vue-common';
+import { Keys, guid, validatePackage } from '@progress/kendo-vue-common';
+import { getDirectParentId, isIdEmptyOrZeroLevel, EMPTY_ID, ZERO_LEVEL_ZERO_ITEM_ID, getRootParentId, getItemById } from '../utils/itemsIdsUtils.js';
+import { prepareInputItemsForInternalWork } from '../utils/prepareInputItemsForInternalWork.js';
+import { getNewItemIdUponKeyboardNavigation } from '../utils/getNewItemIdUponKeyboardNavigation.js';
+import { getHoverOpenDelay, getHoverCloseDelay } from '../utils/hoverDelay.js';
+import { MenuItemInternalsList } from './MenuItemInternalsList.js';
+import { DirectionHolder } from '../utils/DirectionHolder.js';
+import { MouseOverHandler } from '../utils/MouseOverHandler.js';
+import { packageMetadata } from '../../package-metadata.js';
+/**
+ * @hidden
+ */
+
+var MenuVue2 = {
+  name: 'KendoMenu',
+  props: {
+    vertical: {
+      type: Boolean,
+      default: false
+    },
+    items: Array,
+    dir: String,
+    hoverOpenDelay: {
+      type: Number,
+      default: undefined
+    },
+    hoverCloseDelay: {
+      type: Number,
+      default: undefined
+    },
+    openOnClick: Boolean,
+    itemRender: [String, Object, Function],
+    linkRender: [String, Object, Function],
+    customCloseItemIds: Array
+  },
+  created: function created() {
+    validatePackage(packageMetadata);
+    this.mouseOverHandler = new MouseOverHandler(this.$props.openOnClick, this.reset, this.onItemMouseOver); // private itemHoverRequest: any;
+    // private itemLeaveRequest: any;
+    // private menuWrapperEl: any;
+
+    this.guid = guid();
+    this.directionHolder = new DirectionHolder();
+    this.inputItems = [];
+    this.currentItems = []; // private mouseOverHandler: MouseOverHandler;
+  },
+  mounted: function mounted() {
+    this.isFirstRender = false;
+    this.menuWrapperEl = getRef(this, 'menuWrapper');
+  },
+  updated: function updated() {
+    // Reset the Menu upon big UI changes
+    // to avoid misleading the user and to
+    // keep the component consistent.
+    // if (Boolean(prevProps.vertical) !== Boolean(this.$props.vertical) ||
+    //     this.directionHolder.hasDirectionChanged()) {
+    //     this.reset();
+    // }
+    this.mouseOverHandler.OpenOnClick = this.$props.openOnClick;
+  },
+  destroyed: !!isV3 ? undefined : function () {
+    this.clearItemHoverAndLeaveRequestsIfApplicable();
+  },
+  // @ts-ignore
+  unmounted: function unmounted() {
+    this.clearItemHoverAndLeaveRequestsIfApplicable();
+  },
+  data: function data() {
+    return {
+      focusedItemId: EMPTY_ID,
+      hoveredItemId: EMPTY_ID,
+      tabbableItemId: ZERO_LEVEL_ZERO_ITEM_ID,
+      isFirstRender: true
+    };
+  },
+  computed: {
+    menuClassName: function menuClassName() {
+      return {
+        'k-widget': true,
+        'k-reset': true,
+        'k-header': true,
+        'k-menu': true,
+        'k-menu-horizontal': !this.$props.vertical,
+        'k-menu-vertical': this.$props.vertical
+      };
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  render: function render(createElement) {
+    var h = gh || createElement;
+    this.prepareItems();
+
+    if (!this.isFirstRender) {
+      this.directionHolder.setIsDirectionRightToLeft(this.checkIsDirectionRightToLeft());
+    }
+
+    var lastItemIdToBeOpened = this.hoveredItemId ? this.hoveredItemId : this.focusedItemId ? getDirectParentId(this.focusedItemId) : EMPTY_ID;
+    return h("div", {
+      "class": this.getMenuWrapperClassName(),
+      ref: setRef(this, 'menuWrapper')
+    }, [// @ts-ignore
+    h(MenuItemInternalsList, {
+      "class": this.menuClassName,
+      "aria-orientation": this.$props.vertical ? 'vertical' : undefined,
+      attrs: this.v3 ? undefined : {
+        "aria-orientation": this.$props.vertical ? 'vertical' : undefined,
+        items: this.currentItems,
+        isMenuVertical: this.$props.vertical,
+        isDirectionRightToLeft: this.directionHolder.getIsDirectionRightToLeft(),
+        focusedItemId: this.focusedItemId,
+        lastItemIdToBeOpened: lastItemIdToBeOpened,
+        tabbableItemId: this.tabbableItemId,
+        itemRender: templateRendering.call(this, this.$props.itemRender, getListeners.call(this)),
+        linkRender: templateRendering.call(this, this.$props.linkRender, getListeners.call(this)),
+        menuGuid: this.guid,
+        originalItemNeeded: this.getInputItem
+      },
+      items: this.currentItems,
+      isMenuVertical: this.$props.vertical,
+      isDirectionRightToLeft: this.directionHolder.getIsDirectionRightToLeft(),
+      focusedItemId: this.focusedItemId,
+      lastItemIdToBeOpened: lastItemIdToBeOpened,
+      tabbableItemId: this.tabbableItemId,
+      itemRender: templateRendering.call(this, this.$props.itemRender, getListeners.call(this)),
+      linkRender: templateRendering.call(this, this.$props.linkRender, getListeners.call(this)),
+      menuGuid: this.guid,
+      onMouseleave: this.onItemMouseLeave,
+      on: this.v3 ? undefined : {
+        "mouseleave": this.onItemMouseLeave,
+        "mouseover": this.onItemMouseOver,
+        "mousedown": this.onItemMouseDown,
+        "keydown": this.onKeyDown,
+        "focus": this.onItemFocus,
+        "click": this.onItemClick,
+        "blur": this.onItemBlur
+      },
+      onMouseover: this.onItemMouseOver,
+      onMousedown: this.onItemMouseDown,
+      onKeydown: this.onKeyDown,
+      onFocus: this.onItemFocus,
+      onClick: this.onItemClick,
+      onBlur: this.onItemBlur,
+      originalItemNeeded: this.getInputItem
+    })]);
+  },
+  methods: {
+    reset: function reset() {
+      this.clearItemHoverAndLeaveRequestsIfApplicable();
+      this.focusedItemId = EMPTY_ID;
+      this.hoveredItemId = EMPTY_ID;
+      this.tabbableItemId = ZERO_LEVEL_ZERO_ITEM_ID;
+    },
+    onKeyDown: function onKeyDown(event) {
+      // The focusedItemId may be empty when contentRender is used.
+      // For example, content with input.
+      if (this.focusedItemId !== EMPTY_ID) {
+        var currentItem = getItemById(this.focusedItemId, this.currentItems);
+        var newItemId = getNewItemIdUponKeyboardNavigation(this.currentItems, currentItem.id, event.keyCode, event.key, this.$props.vertical, this.directionHolder.getIsDirectionRightToLeft());
+
+        if (currentItem.id !== newItemId) {
+          event.preventDefault();
+          this.setFocusedItemId(newItemId);
+        }
+
+        if ((event.keyCode === Keys.enter || event.keyCode === Keys.space) && !currentItem.disabled) {
+          this.mouseOverHandler.handleItemSelectedViaKeyboard();
+          this.dispatchSelectEventIfWired(event, currentItem.id);
+
+          if (!event.defaultPrevented && currentItem.items.length === 0 && currentItem.url) {
+            window.location.assign(currentItem.url);
+          }
+        }
+      }
+    },
+    onItemMouseOver: function onItemMouseOver(itemId) {
+      if (this.mouseOverHandler.IsMouseOverEnabled) {
+        // The `over` event can get fired even without actually leaving the item.
+        // For example, move the mouse little by little over the item content.
+        this.clearItemHoverAndLeaveRequestsIfApplicable();
+        var that_1 = this;
+        this.itemHoverRequest = window.setTimeout(function () {
+          that_1.setHoveredItemId(itemId);
+          that_1.itemHoverRequest = null;
+        }, getHoverOpenDelay(__assign({}, this.$props)));
+      }
+    },
+    onItemMouseLeave: function onItemMouseLeave(itemId) {
+      if (this.mouseOverHandler.IsMouseOverEnabled && this.isItemWithDefaultClose(itemId)) {
+        // Both the `leave` and `hover` requests are cleared
+        // to be defensive and consistent with the `over` handler.
+        this.clearItemHoverAndLeaveRequestsIfApplicable();
+        var that_2 = this;
+        this.itemLeaveRequest = window.setTimeout(function () {
+          that_2.setHoveredItemId(EMPTY_ID);
+          that_2.itemLeaveRequest = null;
+        }, getHoverCloseDelay(__assign({}, this.$props)));
+      }
+    },
+    onItemMouseDown: function onItemMouseDown() {
+      this.mouseOverHandler.handleItemMouseDown();
+    },
+    onItemFocus: function onItemFocus(itemId) {
+      this.setFocusedItemId(itemId);
+      this.mouseOverHandler.handleItemFocus();
+    },
+    onItemClick: function onItemClick(event, itemId) {
+      var item = getItemById(itemId, this.currentItems);
+
+      if (!item.disabled) {
+        this.setFocusedItemId(itemId);
+        this.mouseOverHandler.handleItemClick(itemId, this.isItemWithDefaultClose(itemId));
+        this.dispatchSelectEventIfWired(event, itemId);
+
+        if (!event.defaultPrevented && item.url) {
+          window.location.assign(item.url);
+        }
+      }
+    },
+    onItemBlur: function onItemBlur(itemId) {
+      if (this.isItemWithDefaultClose(itemId)) {
+        this.setFocusedItemId(EMPTY_ID);
+      }
+    },
+    getInputItem: function getInputItem(itemId) {
+      return getItemById(itemId, this.inputItems);
+    },
+    setFocusedItemId: function setFocusedItemId(focusedItemId) {
+      var tabbableItemId = focusedItemId === EMPTY_ID ? this.tabbableItemId : getRootParentId(focusedItemId);
+      var hoveredItemId = focusedItemId === EMPTY_ID || isIdEmptyOrZeroLevel(this.hoveredItemId) && isIdEmptyOrZeroLevel(focusedItemId) ? this.hoveredItemId : EMPTY_ID;
+      this.hoveredItemId = hoveredItemId;
+      this.focusedItemId = focusedItemId;
+      this.tabbableItemId = tabbableItemId;
+    },
+    setHoveredItemId: function setHoveredItemId(hoveredItemId) {
+      if (isIdEmptyOrZeroLevel(hoveredItemId) && isIdEmptyOrZeroLevel(this.focusedItemId)) {
+        this.hoveredItemId = hoveredItemId;
+      } else {
+        this.hoveredItemId = hoveredItemId;
+        this.focusedItemId = EMPTY_ID;
+        this.tabbableItemId = ZERO_LEVEL_ZERO_ITEM_ID;
+      }
+    },
+    getMenuWrapperClassName: function getMenuWrapperClassName() {
+      return {
+        'k-rtl': this.directionHolder.getIsDirectionRightToLeft()
+      };
+    },
+    clearItemHoverAndLeaveRequestsIfApplicable: function clearItemHoverAndLeaveRequestsIfApplicable() {
+      if (this.itemHoverRequest) {
+        clearTimeout(this.itemHoverRequest);
+        this.itemHoverRequest = null;
+      }
+
+      if (this.itemLeaveRequest) {
+        clearTimeout(this.itemLeaveRequest);
+        this.itemLeaveRequest = null;
+      }
+    },
+    isItemWithDefaultClose: function isItemWithDefaultClose(itemId) {
+      return !this.$props.customCloseItemIds || this.$props.customCloseItemIds.indexOf(itemId) === -1;
+    },
+    checkIsDirectionRightToLeft: function checkIsDirectionRightToLeft() {
+      return this.$props.dir !== undefined ? this.$props.dir === 'rtl' : this.menuWrapperEl && getComputedStyle(this.menuWrapperEl).direction === 'rtl';
+    },
+    prepareItems: function prepareItems() {
+      var _a = prepareInputItemsForInternalWork.call(this, this.$props.items),
+          items = _a.items,
+          inputItems = _a.inputItems;
+
+      this.currentItems = items;
+      this.inputItems = inputItems;
+    },
+    dispatchSelectEventIfWired: function dispatchSelectEventIfWired(event, itemId) {
+      this.$emit('select', {
+        event: event,
+        compontent: this,
+        item: this.getInputItem(itemId),
+        itemId: itemId
+      });
+    }
+  }
+};
+/**
+ *
+ * Represents the [Kendo UI for Vue Menu component]({% slug overview_menu %}).
+ *
+ *
+ * ### props <span class='code'>Readonly&lt;[MenuProps]({% slug api_layout_menuprops %})&gt;</span>
+ * The props of the Menu component.
+ *
+ */
+
+var Menu = MenuVue2;
+export { Menu, MenuVue2 };

package/dist/esm/menu/components/MenuItemArrow.d.ts

@@ -0,0 +1,70 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * The properties of the Kendo UI for Vue MenuItemArrow component.
+ */
+export interface MenuItemArrowProps {
+    /**
+     * Sets the item id of the MenuItemArrow component.
+     */
+    itemId: string;
+    /**
+     * Sets the direction of the MenuItemArrow component.
+     */
+    dir: 'ltr' | 'rtl' | string;
+    /**
+     * Specifies whether the Menu which holds the MenuItemArrow component is vertical.
+     */
+    verticalMenu?: boolean;
+}
+/**
+ * @hidden
+ */
+export declare const downArrowClass = "k-i-arrow-60-down";
+/**
+ * @hidden
+ */
+export declare const rightArrowClass = "k-i-arrow-60-right";
+/**
+ * @hidden
+ */
+export declare const leftArrowClass = "k-i-arrow-60-left";
+/**
+ * @hidden
+ */
+export interface MenuItemArrowState {
+}
+/**
+ * @hidden
+ */
+export interface MenuItemArrowComputed {
+}
+/**
+ * @hidden
+ */
+export interface MenuItemArrowMethods {
+    [key: string]: any;
+    getArrowClassName: () => object;
+}
+/**
+ * @hidden
+ */
+export interface MenuItemArrowData {
+}
+/**
+ * @hidden
+ */
+export interface MenuItemArrowAll extends Vue2type, MenuItemArrowMethods, MenuItemArrowData, MenuItemArrowComputed, MenuItemArrowState {
+}
+/**
+ * @hidden
+ */
+declare let MenuItemArrowVue2: ComponentOptions<MenuItemArrowAll, DefaultData<MenuItemArrowData>, DefaultMethods<MenuItemArrowAll>, MenuItemArrowComputed, RecordPropsDefinition<MenuItemArrowProps>>;
+/**
+ * @hidden
+ */
+declare const MenuItemArrow: DefineComponent<MenuItemArrowProps, any, MenuItemArrowData, MenuItemArrowComputed, MenuItemArrowMethods, {}, {}, {}, string, MenuItemArrowProps, MenuItemArrowProps, {}>;
+export { MenuItemArrow, MenuItemArrowVue2 };