@progress/kendo-angular-menu 3.0.5 → 4.0.0-dev.202204131917

package/esm2015/rendering/list.component.js

@@ -0,0 +1,546 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, Input } from '@angular/core';
+import { HostBinding, ViewChild } from '@angular/core';
+import { isDocumentAvailable } from '@progress/kendo-angular-common';
+import { POPUP_CONTAINER, PopupService } from '@progress/kendo-angular-popup';
+import { NODE_INDEX } from '../constants';
+import { closest, closestItem, hasClass, inMenu, isFocusable, nodeIndex } from '../dom-queries';
+import { bodyFactory } from '../utils';
+import { POPUP_SETTINGS, POPUP_SETTINGS_RTL } from './popup-settings';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/items.service";
+import * as i2 from "../services/hover.service";
+import * as i3 from "../services/actions.service";
+import * as i4 from "../services/navigation.service";
+import * as i5 from "@angular/common";
+import * as i6 from "@progress/kendo-angular-popup";
+/* eslint-disable @angular-eslint/component-selector */
+/**
+ * @hidden
+ */
+export class ListComponent {
+    constructor(itemsService, hover, actions, navigation, renderer, ngZone, element) {
+        this.itemsService = itemsService;
+        this.hover = hover;
+        this.actions = actions;
+        this.navigation = navigation;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.element = element;
+        this.animate = true;
+    }
+    hierarchyIndex(index) {
+        return this.itemsService.itemIndex(this.index, index);
+    }
+    ngOnInit() {
+        this.itemsService.addList(this);
+        this.initDomEvents();
+    }
+    ngOnDestroy() {
+        this.itemsService.removeList(this);
+        if (this.domSubscriptions) {
+            this.domSubscriptions();
+        }
+    }
+    initDomEvents() {
+        if (!isDocumentAvailable() || !this.element) {
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            const element = this.element.nativeElement;
+            const container = this.level > 0 ? closest(element, (node) => hasClass(node, 'k-popup')) : element;
+            const overSubscription = this.renderer.listen(element, 'mouseover', (e) => {
+                if (e.target === element && this.level === 0) {
+                    this.onLeave();
+                }
+                else {
+                    const item = this.nodeItem(e.target) || this.itemsService.get(this.index);
+                    if (item && !(this.openOnClick && this.openOnClick.toggle === 'click' && item.level === 0 && !item.hasContent)) {
+                        this.hover.over(item);
+                    }
+                }
+            });
+            const leaveSubscription = this.renderer.listen(container, 'mouseleave', (e) => {
+                if (this.leavesMenu(e)) {
+                    this.onLeave();
+                }
+            });
+            const keydownSubscription = this.renderer.listen(element, 'keydown', (e) => {
+                if (hasClass(e.target, 'k-menu-item')) {
+                    this.navigation.keydown(e);
+                }
+            });
+            const blurSubscription = this.renderer.listen(element, 'focusout', (e) => {
+                if (this.leavesMenu(e)) {
+                    this.navigation.focusLeave();
+                }
+            });
+            /**
+             * Handle focus/blur open/close for iOS devices since it behaves inconsistently with the rest
+             * Refer to: https://developer.apple.com/library/archive/documentation/AppleApplications/Reference/SafariWebContent/HandlingEvents/HandlingEvents.html
+             */
+            const touchSubscription = this.renderer.listen(document, 'touchstart', (e) => {
+                if (inMenu(e.target, this.itemsService)) {
+                    const item = this.nodeItem(e.target);
+                    // Needs to be called because the 'click' handler will be called only on secondary tap and the item will remain unfocused
+                    this.navigation.focus(item);
+                    // This is needed since the 'mouseover' event is not always dispatched
+                    if (!item.opened) {
+                        this.hover.over(item);
+                    }
+                }
+                else if (this.navigation.focusedIdx) {
+                    // If the touch is outside of the menu and the menu is not currently in focus
+                    const activeItem = this.itemsService.get(this.navigation.activeIndex);
+                    this.onLeave(); // needs to be called explicitly since mouseleave event is not triggered
+                    activeItem.blur(); // needs to be called explicitly otherwise the item remains focused => triggers focusout
+                }
+            });
+            const clickSubscription = this.renderer.listen(element, 'click', this.clickHandler.bind(this));
+            this.domSubscriptions = () => {
+                overSubscription();
+                leaveSubscription();
+                keydownSubscription();
+                blurSubscription();
+                clickSubscription();
+                touchSubscription();
+            };
+        });
+    }
+    leavesMenu(e) {
+        if (!e.relatedTarget) {
+            return true;
+        }
+        return !inMenu(e.relatedTarget, this.itemsService);
+    }
+    onLeave() {
+        const openOnClick = this.openOnClick;
+        if (!openOnClick || openOnClick.toggle !== 'click') {
+            this.hover.leave(openOnClick && openOnClick.toggle === 'leave');
+        }
+    }
+    nodeItem(target) {
+        const node = closestItem(target, this.element.nativeElement);
+        if (node) {
+            const index = nodeIndex(node);
+            return this.itemsService.get(index);
+        }
+    }
+    clickHandler(e) {
+        if (isFocusable(e.target) && !hasClass(e.target, 'k-menu-item')) {
+            return;
+        }
+        const item = this.nodeItem(e.target);
+        if (!item || item.isContent || item.navigating) {
+            return;
+        }
+        if (item.disabled) {
+            e.preventDefault();
+            return;
+        }
+        this.actions.select(item, e, () => {
+            e.preventDefault();
+        });
+        this.navigation.focus(item);
+        if (item.level > 0 && !item.hasContent) {
+            this.actions.closeToRoot(item);
+        }
+        if (this.openOnClick) {
+            const hover = this.hover;
+            if (item.opened) {
+                if (item.level === 0) {
+                    hover.openOnOver = false;
+                    this.actions.close(item);
+                }
+            }
+            else if (item.hasContent) {
+                hover.openOnOver = true;
+                this.actions.closeOthers(item);
+                this.actions.open(item);
+            }
+            else {
+                hover.openOnOver = false;
+                if (item.level === 0 && this.openOnClick.toggle === 'click') {
+                    this.hover.closeCurrent();
+                }
+            }
+        }
+        this.actions.execute();
+    }
+}
+ListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ListComponent, deps: [{ token: i1.ItemsService }, { token: i2.HoverService }, { token: i3.ActionsService }, { token: i4.NavigationService }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+ListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ListComponent, selector: "[kendoMenuList]", inputs: { items: "items", level: "level", index: "index", animate: "animate", vertical: "vertical", rtl: "rtl", openOnClick: "openOnClick", itemTemplate: "itemTemplate", itemLinkTemplate: "itemLinkTemplate" }, ngImport: i0, template: "\n        <ng-container *ngFor=\"let item of items; let idx = index\">\n            <li *ngIf=\"!item.separator\" kendoMenuItem\n                [item]=\"item\" [level]=\"level\" [vertical]=\"vertical\" [animate]=\"animate\" [rtl]=\"rtl\"\n                [itemTemplate]=\"itemTemplate\" [itemLinkTemplate]=\"itemLinkTemplate\" [openOnClick]=\"openOnClick\"\n                [index]=\"hierarchyIndex(idx)\" [siblingIndex]=\"idx\" [attr.data-kendo-menu-index]=\"hierarchyIndex(idx)\"\n                [ngClass]=\"item.cssClass\" [ngStyle]=\"item.cssStyle\"\n                role=\"menuitem\"\n                class=\"k-item k-menu-item\"\n                [class.k-first]=\"idx === 0\" [class.k-last]=\"idx === items.length - 1\"\n                [class.k-state-disabled]=\"item.disabled\"></li>\n            <li *ngIf=\"item.separator\" class=\"k-separator k-item\"\n                role=\"separator\" [ngClass]=\"item.cssClass\" [ngStyle]=\"item.cssStyle\">\n                &nbsp;\n            </li>\n        </ng-container>\n    ", isInline: true, components: [{ type: i0.forwardRef(function () { return ItemComponent; }), selector: "[kendoMenuItem]", inputs: ["item", "level", "index", "siblingIndex", "animate", "vertical", "rtl", "openOnClick", "itemTemplate", "itemLinkTemplate"] }], directives: [{ type: i0.forwardRef(function () { return i5.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i0.forwardRef(function () { return i5.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i0.forwardRef(function () { return i5.NgClass; }), selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i0.forwardRef(function () { return i5.NgStyle; }), selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[kendoMenuList]',
+                    template: `
+        <ng-container *ngFor="let item of items; let idx = index">
+            <li *ngIf="!item.separator" kendoMenuItem
+                [item]="item" [level]="level" [vertical]="vertical" [animate]="animate" [rtl]="rtl"
+                [itemTemplate]="itemTemplate" [itemLinkTemplate]="itemLinkTemplate" [openOnClick]="openOnClick"
+                [index]="hierarchyIndex(idx)" [siblingIndex]="idx" [attr.${NODE_INDEX}]="hierarchyIndex(idx)"
+                [ngClass]="item.cssClass" [ngStyle]="item.cssStyle"
+                role="menuitem"
+                class="k-item k-menu-item"
+                [class.k-first]="idx === 0" [class.k-last]="idx === items.length - 1"
+                [class.k-state-disabled]="item.disabled"></li>
+            <li *ngIf="item.separator" class="k-separator k-item"
+                role="separator" [ngClass]="item.cssClass" [ngStyle]="item.cssStyle">
+                &nbsp;
+            </li>
+        </ng-container>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ItemsService }, { type: i2.HoverService }, { type: i3.ActionsService }, { type: i4.NavigationService }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i0.ElementRef }]; }, propDecorators: { items: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], animate: [{
+                type: Input
+            }], vertical: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], openOnClick: [{
+                type: Input
+            }], itemTemplate: [{
+                type: Input
+            }], itemLinkTemplate: [{
+                type: Input
+            }] } });
+/**
+ * @hidden
+ */
+export class ItemComponent {
+    constructor(itemsService, navigation, changeDetector, renderer, popupService, element) {
+        this.itemsService = itemsService;
+        this.navigation = navigation;
+        this.changeDetector = changeDetector;
+        this.renderer = renderer;
+        this.popupService = popupService;
+        this.element = element;
+        this.animate = true;
+        this.openOnClick = false;
+        this.opened = false;
+        this.navigating = false;
+        this.destroyed = false;
+    }
+    set index(index) {
+        if (this._index && this._index !== index) {
+            this.itemsService.remove(this);
+            this._index = index;
+            this.itemsService.add(this);
+        }
+        else {
+            this._index = index;
+        }
+        this.childId = this.itemsService.childId(index);
+    }
+    get index() {
+        return this._index;
+    }
+    get disabled() {
+        return this.item.disabled;
+    }
+    get hasPopup() {
+        return this.hasContent ? true : null;
+    }
+    get expanded() {
+        return this.hasContent ? this.opened : null;
+    }
+    get label() {
+        return this.item.text ? this.item.text : null;
+    }
+    get activeId() {
+        return this.index === this.navigation.activeIndex ? '0' : '-1';
+    }
+    get popupSettings() {
+        const settings = this.rtl ? POPUP_SETTINGS_RTL : POPUP_SETTINGS;
+        return this.horizontal ? settings.horizontal : settings.vertical;
+    }
+    get horizontal() {
+        return this.vertical || this.level > 0;
+    }
+    get hasLink() {
+        return Boolean(this.item.url);
+    }
+    get linkTemplate() {
+        return this.item.linkTemplate || this.itemLinkTemplate;
+    }
+    get hasContent() {
+        const items = this.item.items;
+        return items && items.length || this.item.contentTemplate;
+    }
+    get isContent() {
+        return Boolean(this.item.content);
+    }
+    get iconClass() {
+        return `k-i-${this.item.icon}`;
+    }
+    get children() {
+        const item = this.item;
+        if (item.contentTemplate) {
+            if (!this.contentItems) {
+                this.contentItems = [{
+                        content: item.contentTemplate,
+                        owner: item,
+                        ownerIndex: this.index
+                    }];
+            }
+            return this.contentItems;
+        }
+        return item.items;
+    }
+    get template() {
+        return this.item.template || this.itemTemplate;
+    }
+    hasContentTemplates() {
+        const item = this.item;
+        return this.itemTemplate || item.contentTemplate || this.itemLinkTemplate ||
+            (item.items && item.items.find(current => current.template || current.linkTemplate));
+    }
+    ngOnInit() {
+        this.itemsService.add(this);
+    }
+    ngOnDestroy() {
+        this.itemsService.remove(this);
+        this.destroyed = true;
+        if (this.popupRef) {
+            this.popupRef.close();
+            this.popupRef = null;
+        }
+    }
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    blur() {
+        this.element.nativeElement.blur();
+    }
+    toggleActive(isActive) {
+        if (isActive) {
+            this.setAttribute('tabindex', '0');
+        }
+        else {
+            this.setAttribute('tabindex', '-1');
+        }
+    }
+    open() {
+        if (!this.destroyed && this.hasContent && !this.opened) {
+            const popupSettings = this.popupSettings;
+            const animate = this.animate ? Object.assign({}, this.animate, {
+                direction: popupSettings.animate
+            }) : false;
+            this.opened = true;
+            this.popupRef = this.popupService.open({
+                popupAlign: popupSettings.popup,
+                anchorAlign: popupSettings.anchor,
+                collision: popupSettings.collision,
+                anchor: this.element,
+                positionMode: 'absolute',
+                content: this.popupTemplate,
+                popupClass: {
+                    'k-rtl': this.rtl,
+                    'k-menu-popup': true
+                },
+                animate: animate
+            });
+            this.setAttribute('aria-expanded', 'true');
+            this.setAttribute('aria-owns', this.childId);
+            this.changeDetector.detectChanges();
+        }
+    }
+    close() {
+        if (!this.destroyed && this.opened) {
+            this.opened = false;
+            if (this.popupRef) {
+                this.popupRef.close();
+                this.popupRef = null;
+            }
+            this.changeDetector.detectChanges();
+            this.setAttribute('aria-expanded', 'false');
+            this.renderer.removeAttribute(this.element.nativeElement, 'aria-owns');
+        }
+    }
+    navigate() {
+        let link;
+        if (this.linkTemplate) {
+            link = this.element.nativeElement.querySelector('a.k-menu-link');
+        }
+        else if (this.hasLink) {
+            link = this.link.nativeElement;
+        }
+        if (link) {
+            this.navigating = true;
+            link.click();
+            this.navigating = false;
+        }
+    }
+    setAttribute(name, value) {
+        this.renderer.setAttribute(this.element.nativeElement, name, value);
+    }
+}
+ItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ItemComponent, deps: [{ token: i1.ItemsService }, { token: i4.NavigationService }, { token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i6.PopupService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+ItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ItemComponent, selector: "[kendoMenuItem]", inputs: { item: "item", level: "level", index: "index", siblingIndex: "siblingIndex", animate: "animate", vertical: "vertical", rtl: "rtl", openOnClick: "openOnClick", itemTemplate: "itemTemplate", itemLinkTemplate: "itemLinkTemplate" }, host: { properties: { "attr.aria-disabled": "this.disabled", "attr.aria-haspopup": "this.hasPopup", "attr.aria-expanded": "this.expanded", "attr.aria-label": "this.label", "attr.tabindex": "this.activeId" } }, providers: [PopupService, {
+            provide: POPUP_CONTAINER,
+            useFactory: bodyFactory
+        }], viewQueries: [{ propertyName: "link", first: true, predicate: ["link"], descendants: true }, { propertyName: "popupTemplate", first: true, predicate: ["popupTemplate"], descendants: true, static: true }], ngImport: i0, template: `
+    <span *ngIf="!hasLink && !item.content && !linkTemplate" class="k-link k-menu-link" #link
+        [class.k-state-active]="opened" role="presentation">
+        <ng-template [ngTemplateOutlet]="itemcontent">
+        </ng-template>
+    </span>
+    <a *ngIf="item.url && !linkTemplate" class="k-link k-menu-link" #link [attr.href]="item.url"
+        [class.k-state-active]="opened" tabindex="-1" role="presentation">
+        <ng-template [ngTemplateOutlet]="itemcontent">
+        </ng-template>
+    </a>
+    <ng-template *ngIf="linkTemplate && !item.content" [ngTemplateOutlet]="linkTemplate"
+        [ngTemplateOutletContext]="{ item: item, index: index }">
+    </ng-template>
+
+    <div class="k-content" *ngIf="item.content" role="presentation">
+        <ng-template [ngTemplateOutlet]="item.content" [ngTemplateOutletContext]="{ item: item.owner, index: item.ownerIndex }">
+        </ng-template>
+    </div>
+
+    <ng-template #popupTemplate>
+        <ul kendoMenuList
+            [attr.id]="childId"
+            [animate]="animate"
+            [rtl]="rtl"
+            [vertical]="vertical"
+            [openOnClick]="openOnClick"
+            [items]="children"
+            [level]="level + 1"
+            [index]="index"
+            [itemTemplate]="itemTemplate"
+            [itemLinkTemplate]="itemLinkTemplate"
+            role="menu"
+            class="k-group k-menu-group k-reset">
+        </ul>
+    </ng-template>
+
+    <ng-template #itemcontent>
+        <span *ngIf="item.icon" class="k-icon" [ngClass]="iconClass" role="presentation"></span>
+        <ng-container *ngIf="!template">
+            <span class="k-menu-link-text">{{ item.text }}</span>
+        </ng-container>
+        <ng-template *ngIf="template" [ngTemplateOutlet]="template" [ngTemplateOutletContext]="{ item: item, index: index }">
+        </ng-template>
+        <span class="k-icon k-menu-expand-arrow" *ngIf="hasContent"
+            role="presentation"
+            [class.k-i-arrow-60-down]="!horizontal"
+            [class.k-i-arrow-60-right]="horizontal && !rtl"
+            [class.k-i-arrow-60-left]="horizontal && rtl">
+        </span>
+    </ng-template>
+  `, isInline: true, components: [{ type: ListComponent, selector: "[kendoMenuList]", inputs: ["items", "level", "index", "animate", "vertical", "rtl", "openOnClick", "itemTemplate", "itemLinkTemplate"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [PopupService, {
+                            provide: POPUP_CONTAINER,
+                            useFactory: bodyFactory
+                        }],
+                    selector: '[kendoMenuItem]',
+                    template: `
+    <span *ngIf="!hasLink && !item.content && !linkTemplate" class="k-link k-menu-link" #link
+        [class.k-state-active]="opened" role="presentation">
+        <ng-template [ngTemplateOutlet]="itemcontent">
+        </ng-template>
+    </span>
+    <a *ngIf="item.url && !linkTemplate" class="k-link k-menu-link" #link [attr.href]="item.url"
+        [class.k-state-active]="opened" tabindex="-1" role="presentation">
+        <ng-template [ngTemplateOutlet]="itemcontent">
+        </ng-template>
+    </a>
+    <ng-template *ngIf="linkTemplate && !item.content" [ngTemplateOutlet]="linkTemplate"
+        [ngTemplateOutletContext]="{ item: item, index: index }">
+    </ng-template>
+
+    <div class="k-content" *ngIf="item.content" role="presentation">
+        <ng-template [ngTemplateOutlet]="item.content" [ngTemplateOutletContext]="{ item: item.owner, index: item.ownerIndex }">
+        </ng-template>
+    </div>
+
+    <ng-template #popupTemplate>
+        <ul kendoMenuList
+            [attr.id]="childId"
+            [animate]="animate"
+            [rtl]="rtl"
+            [vertical]="vertical"
+            [openOnClick]="openOnClick"
+            [items]="children"
+            [level]="level + 1"
+            [index]="index"
+            [itemTemplate]="itemTemplate"
+            [itemLinkTemplate]="itemLinkTemplate"
+            role="menu"
+            class="k-group k-menu-group k-reset">
+        </ul>
+    </ng-template>
+
+    <ng-template #itemcontent>
+        <span *ngIf="item.icon" class="k-icon" [ngClass]="iconClass" role="presentation"></span>
+        <ng-container *ngIf="!template">
+            <span class="k-menu-link-text">{{ item.text }}</span>
+        </ng-container>
+        <ng-template *ngIf="template" [ngTemplateOutlet]="template" [ngTemplateOutletContext]="{ item: item, index: index }">
+        </ng-template>
+        <span class="k-icon k-menu-expand-arrow" *ngIf="hasContent"
+            role="presentation"
+            [class.k-i-arrow-60-down]="!horizontal"
+            [class.k-i-arrow-60-right]="horizontal && !rtl"
+            [class.k-i-arrow-60-left]="horizontal && rtl">
+        </span>
+    </ng-template>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ItemsService }, { type: i4.NavigationService }, { type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i6.PopupService }, { type: i0.ElementRef }]; }, propDecorators: { item: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], siblingIndex: [{
+                type: Input
+            }], animate: [{
+                type: Input
+            }], vertical: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], openOnClick: [{
+                type: Input
+            }], itemTemplate: [{
+                type: Input
+            }], itemLinkTemplate: [{
+                type: Input
+            }], link: [{
+                type: ViewChild,
+                args: ['link', { static: false }]
+            }], popupTemplate: [{
+                type: ViewChild,
+                args: ['popupTemplate', { static: true }]
+            }], disabled: [{
+                type: HostBinding,
+                args: ['attr.aria-disabled']
+            }], hasPopup: [{
+                type: HostBinding,
+                args: ['attr.aria-haspopup']
+            }], expanded: [{
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], label: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], activeId: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }] } });

package/{dist/es2015 → esm2015}/services/actions.service.js

@@ -2,17 +2,25 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
 import { NgZone, Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { MenuEvent } from '../menu-event';
-import { hasObservers } from '@progress/kendo-angular-common';
+import { hasObservers, PreventableEvent } from '@progress/kendo-angular-common';
+import * as i0 from "@angular/core";
+import * as i1 from "./items.service";
 const canPerformAction = (item, action) => !((action === 'open' && item.opened) || (action === 'close' && !item.opened));
-const ɵ0 = canPerformAction;
 /**
+ * Used to remove cyclic dependency error. Dublicates MenuEvent
  * @hidden
  */
-let ActionsService = class ActionsService {
+export class MenuStateEvent extends PreventableEvent {
+    constructor(args) {
+        super();
+        Object.assign(this, args);
+    }
+}
+/**
+ * @hidden
+ */
+export class ActionsService {
     constructor(ngZone, items) {
         this.ngZone = ngZone;
         this.items = items;
@@ -81,7 +89,7 @@ let ActionsService = class ActionsService {
     }
     emit(name, item, domEvent) {
         const owner = this.owner;
-        const eventArgs = new MenuEvent({
+        const eventArgs = new MenuStateEvent({
             sender: owner,
             item: item.item,
             index: item.index,
@@ -160,10 +168,9 @@ let ActionsService = class ActionsService {
             this.close(items[idx]);
         }
     }
-};
-ActionsService = tslib_1.__decorate([
-    Injectable(),
-    tslib_1.__metadata("design:paramtypes", [NgZone, ItemsService])
-], ActionsService);
-export { ActionsService };
-export { ɵ0 };
+}
+ActionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ActionsService, deps: [{ token: i0.NgZone }, { token: i1.ItemsService }], target: i0.ɵɵFactoryTarget.Injectable });
+ActionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ActionsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ActionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.ItemsService }]; } });

package/{dist/es2015 → esm2015}/services/hover.service.js

@@ -2,15 +2,15 @@
 * Copyright © 2021 Progress Software Corporation. All rights reserved.
 * Licensed under commercial license. See LICENSE.md in the project root for more information
 *-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
 import { Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { ActionsService } from './actions.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./actions.service";
+import * as i2 from "./items.service";
 const DISABLE_OPEN_ON_OVER_DELAY = 500;
 /**
  * @hidden
  */
-let HoverService = class HoverService {
+export class HoverService {
     constructor(actions, items) {
         this.actions = actions;
         this.items = items;
@@ -114,9 +114,9 @@ let HoverService = class HoverService {
             }
         }
     }
-};
-HoverService = tslib_1.__decorate([
-    Injectable(),
-    tslib_1.__metadata("design:paramtypes", [ActionsService, ItemsService])
-], HoverService);
-export { HoverService };
+}
+HoverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HoverService, deps: [{ token: i1.ActionsService }, { token: i2.ItemsService }], target: i0.ɵɵFactoryTarget.Injectable });
+HoverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HoverService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HoverService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ActionsService }, { type: i2.ItemsService }]; } });