@avdbrink/ngx-contextmenu/fesm5/ngx-contextmenu.js

An Angular component to show a context menu on an arbitrary component

import { Directive, ElementRef, EventEmitter, Input, Output, TemplateRef, InjectionToken, ChangeDetectorRef, Component, Inject, Optional, Renderer, ViewChild, ViewChildren, QueryList, HostListener, Injectable, ContentChildren, ViewEncapsulation, NgModule } from '@angular/core';
import { __assign } from 'tslib';
import { Overlay, ScrollStrategyOptions, OverlayModule } from '@angular/cdk/overlay';
import { Subscription, Subject } from 'rxjs';
import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
import { ComponentPortal } from '@angular/cdk/portal';
import { first } from 'rxjs/operators';
import { CommonModule } from '@angular/common';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ContextMenuItemDirective = /** @class */ (function () {
    function ContextMenuItemDirective(template, elementRef) {
        this.template = template;
        this.elementRef = elementRef;
        this.divider = false;
        this.enabled = true;
        this.passive = false;
        this.visible = true;
        this.execute = new EventEmitter();
        this.isActive = false;
        this.isActiveParent = false;
    }
    Object.defineProperty(ContextMenuItemDirective.prototype, "disabled", {
        get: /**
         * @return {?}
         */
        function () {
            return this.passive ||
                this.divider ||
                !this.evaluateIfFunction(this.enabled, this.currentItem);
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @param {?} value
     * @param {?} item
     * @return {?}
     */
    ContextMenuItemDirective.prototype.evaluateIfFunction = /**
     * @param {?} value
     * @param {?} item
     * @return {?}
     */
    function (value, item) {
        if (value instanceof Function) {
            return value(item);
        }
        return value;
    };
    /**
     * @return {?}
     */
    ContextMenuItemDirective.prototype.setActiveStyles = /**
     * @return {?}
     */
    function () {
        this.isActive = true;
    };
    /**
     * @return {?}
     */
    ContextMenuItemDirective.prototype.setInactiveStyles = /**
     * @return {?}
     */
    function () {
        this.isActive = false;
    };
    /**
     * @return {?}
     */
    ContextMenuItemDirective.prototype.setActiveParentStyles = /**
     * @return {?}
     */
    function () {
        this.isActiveParent = true;
    };
    /**
     * @return {?}
     */
    ContextMenuItemDirective.prototype.setInActiveParentStyles = /**
     * @return {?}
     */
    function () {
        this.isActiveParent = false;
    };
    /**
     * @param {?} item
     * @param {?=} $event
     * @return {?}
     */
    ContextMenuItemDirective.prototype.triggerExecute = /**
     * @param {?} item
     * @param {?=} $event
     * @return {?}
     */
    function (item, $event) {
        if (!this.evaluateIfFunction(this.enabled, item)) {
            return;
        }
        this.execute.emit({ event: $event, item: item });
    };
    ContextMenuItemDirective.decorators = [
        { type: Directive, args: [{
                    /* tslint:disable:directive-selector-type */
                    selector: '[contextMenuItem]',
                },] },
    ];
    /** @nocollapse */
    ContextMenuItemDirective.ctorParameters = function () { return [
        { type: TemplateRef },
        { type: ElementRef }
    ]; };
    ContextMenuItemDirective.propDecorators = {
        subMenu: [{ type: Input }],
        divider: [{ type: Input }],
        enabled: [{ type: Input }],
        passive: [{ type: Input }],
        visible: [{ type: Input }],
        execute: [{ type: Output }]
    };
    return ContextMenuItemDirective;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var /** @type {?} */ CONTEXT_MENU_OPTIONS = new InjectionToken('CONTEXT_MENU_OPTIONS');

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var /** @type {?} */ ARROW_LEFT_KEYCODE = 37;
var ContextMenuContentComponent = /** @class */ (function () {
    function ContextMenuContentComponent(changeDetector, elementRef, options, renderer) {
        this.changeDetector = changeDetector;
        this.elementRef = elementRef;
        this.options = options;
        this.renderer = renderer;
        this.menuItems = [];
        this.isLeaf = false;
        this.execute = new EventEmitter();
        this.openSubMenu = new EventEmitter();
        this.closeLeafMenu = new EventEmitter();
        this.closeAllMenus = new EventEmitter();
        this.autoFocus = false;
        this.useBootstrap4 = false;
        this.highlightParentItems = false;
        this.subscription = new Subscription();
        if (options) {
            this.autoFocus = options.autoFocus;
            this.useBootstrap4 = options.useBootstrap4;
            this.highlightParentItems = options.highlightParentItems;
        }
    }
    /**
     * @return {?}
     */
    ContextMenuContentComponent.prototype.ngOnInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this.menuItems.forEach(function (menuItem) {
            menuItem.currentItem = _this.item;
            _this.subscription.add(menuItem.execute.subscribe(function (event) { return _this.execute.emit(__assign({}, event, { menuItem: menuItem })); }));
        });
        var /** @type {?} */ queryList = new QueryList();
        queryList.reset(this.menuItems);
        this._keyManager = new ActiveDescendantKeyManager(queryList).withWrap();
    };
    /**
     * @return {?}
     */
    ContextMenuContentComponent.prototype.ngAfterViewInit = /**
     * @return {?}
     */
    function () {
        var _this = this;
        if (this.autoFocus) {
            setTimeout(function () { return _this.focus(); });
        }
        this.overlay.updatePosition();
    };
    /**
     * @return {?}
     */
    ContextMenuContentComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this.subscription.unsubscribe();
    };
    /**
     * @return {?}
     */
    ContextMenuContentComponent.prototype.focus = /**
     * @return {?}
     */
    function () {
        if (this.autoFocus) {
            this.menuElement.nativeElement.focus();
        }
    };
    /**
     * @param {?} $event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.stopEvent = /**
     * @param {?} $event
     * @return {?}
     */
    function ($event) {
        $event.stopPropagation();
    };
    /**
     * @param {?} menuItem
     * @return {?}
     */
    ContextMenuContentComponent.prototype.isMenuItemEnabled = /**
     * @param {?} menuItem
     * @return {?}
     */
    function (menuItem) {
        return this.evaluateIfFunction(menuItem && menuItem.enabled);
    };
    /**
     * @param {?} menuItem
     * @return {?}
     */
    ContextMenuContentComponent.prototype.isMenuItemVisible = /**
     * @param {?} menuItem
     * @return {?}
     */
    function (menuItem) {
        return this.evaluateIfFunction(menuItem && menuItem.visible);
    };
    /**
     * @param {?} value
     * @return {?}
     */
    ContextMenuContentComponent.prototype.evaluateIfFunction = /**
     * @param {?} value
     * @return {?}
     */
    function (value) {
        if (value instanceof Function) {
            return value(this.item);
        }
        return value;
    };
    /**
     * @param {?} link
     * @return {?}
     */
    ContextMenuContentComponent.prototype.isDisabled = /**
     * @param {?} link
     * @return {?}
     */
    function (link) {
        return link.enabled && !link.enabled(this.item);
    };
    /**
     * @param {?} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.onKeyEvent = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (!this.isLeaf) {
            return;
        }
        this._keyManager.onKeydown(event);
    };
    /**
     * @param {?=} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.keyboardOpenSubMenu = /**
     * @param {?=} event
     * @return {?}
     */
    function (event) {
        if (!this.isLeaf) {
            return;
        }
        this.cancelEvent(event);
        var /** @type {?} */ menuItem = this.menuItems[this._keyManager.activeItemIndex];
        if (menuItem) {
            this.onOpenSubMenu(menuItem);
        }
    };
    /**
     * @param {?=} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.keyboardMenuItemSelect = /**
     * @param {?=} event
     * @return {?}
     */
    function (event) {
        if (!this.isLeaf) {
            return;
        }
        this.cancelEvent(event);
        var /** @type {?} */ menuItem = this.menuItems[this._keyManager.activeItemIndex];
        if (menuItem) {
            this.onMenuItemSelect(menuItem, event);
        }
    };
    /**
     * @param {?} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.onCloseLeafMenu = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (!this.isLeaf) {
            return;
        }
        this.cancelEvent(event);
        this.closeLeafMenu.emit({ exceptRootMenu: event.keyCode === ARROW_LEFT_KEYCODE, event: event });
    };
    /**
     * @param {?} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.closeMenu = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (event.type === 'click' && event.button === 2) {
            return;
        }
        this.closeAllMenus.emit({ event: event });
    };
    /**
     * @param {?} menuItem
     * @param {?=} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.onOpenSubMenu = /**
     * @param {?} menuItem
     * @param {?=} event
     * @return {?}
     */
    function (menuItem, event) {
        var /** @type {?} */ anchorElementRef = this.menuItemElements.toArray()[this._keyManager.activeItemIndex];
        var /** @type {?} */ anchorElement = anchorElementRef && anchorElementRef.nativeElement;
        if (this.highlightParentItems) {
            this.menuItems.forEach(function (item) { return item.isActiveParent = (item === menuItem && menuItem.subMenu); });
        }
        this.openSubMenu.emit({
            anchorElement: anchorElement,
            contextMenu: menuItem.subMenu,
            event: event,
            item: this.item,
            parentContextMenu: this,
        });
    };
    /**
     * @param {?} menuItem
     * @param {?} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.onMenuItemSelect = /**
     * @param {?} menuItem
     * @param {?} event
     * @return {?}
     */
    function (menuItem, event) {
        event.preventDefault();
        event.stopPropagation();
        this.onOpenSubMenu(menuItem, event);
        if (!menuItem.subMenu) {
            menuItem.triggerExecute(this.item, event);
        }
    };
    /**
     * @param {?} event
     * @return {?}
     */
    ContextMenuContentComponent.prototype.cancelEvent = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (!event) {
            return;
        }
        var /** @type {?} */ target = event.target;
        if (['INPUT', 'TEXTAREA', 'SELECT'].indexOf(target.tagName) > -1 || target.isContentEditable) {
            return;
        }
        event.preventDefault();
        event.stopPropagation();
    };
    ContextMenuContentComponent.decorators = [
        { type: Component, args: [{
                    selector: 'context-menu-content',
                    styles: [
                        ".passive {\n       display: block;\n       padding: 3px 20px;\n       clear: both;\n       font-weight: normal;\n       line-height: @line-height-base;\n       white-space: nowrap;\n     }\n    .hasSubMenu:before {\n      content: \"\u25B6\";\n      float: right;\n    }\n    .activeParent {\n    text-decoration: none;\n      color: #262626;\n      background-color: #f5f5f5;\n    }",
                    ],
                    template: "<div class=\"dropdown open show ngx-contextmenu\" [ngClass]=\"menuClass\" tabindex=\"0\">\n      <ul #menu class=\"dropdown-menu show\" style=\"position: static; float: none;\" tabindex=\"0\">\n        <li #li *ngFor=\"let menuItem of menuItems; let i = index\" [class.disabled]=\"!isMenuItemEnabled(menuItem)\"\n            [class.divider]=\"menuItem.divider\" [class.dropdown-divider]=\"useBootstrap4 && menuItem.divider\"\n            [class.active]=\"menuItem.isActive && isMenuItemEnabled(menuItem)\"\n            [attr.role]=\"menuItem.divider ? 'separator' : undefined\">\n          <a *ngIf=\"!menuItem.divider && !menuItem.passive\" href [class.dropdown-item]=\"useBootstrap4\"\n            [class.active]=\"menuItem.isActive && isMenuItemEnabled(menuItem)\"\n            [class.activeParent]=\"highlightParentItems && menuItem.isActiveParent && isMenuItemEnabled(menuItem)\"\n            [class.disabled]=\"useBootstrap4 && !isMenuItemEnabled(menuItem)\" [class.hasSubMenu]=\"!!menuItem.subMenu\"\n            (click)=\"onMenuItemSelect(menuItem, $event)\" (mouseenter)=\"onOpenSubMenu(menuItem, $event)\">\n            <ng-template [ngTemplateOutlet]=\"menuItem.template\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-template>\n          </a>\n\n          <span (click)=\"stopEvent($event)\" (contextmenu)=\"stopEvent($event)\" class=\"passive\"\n                *ngIf=\"!menuItem.divider && menuItem.passive\" [class.dropdown-item]=\"useBootstrap4\"\n                [class.disabled]=\"useBootstrap4 && !isMenuItemEnabled(menuItem)\">\n            <ng-template [ngTemplateOutlet]=\"menuItem.template\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-template>\n          </span>\n        </li>\n      </ul>\n    </div>\n  ",
                },] },
    ];
    /** @nocollapse */
    ContextMenuContentComponent.ctorParameters = function () { return [
        { type: ChangeDetectorRef },
        { type: ElementRef },
        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CONTEXT_MENU_OPTIONS,] }] },
        { type: Renderer }
    ]; };
    ContextMenuContentComponent.propDecorators = {
        menuItems: [{ type: Input }],
        item: [{ type: Input }],
        event: [{ type: Input }],
        parentContextMenu: [{ type: Input }],
        menuClass: [{ type: Input }],
        overlay: [{ type: Input }],
        isLeaf: [{ type: Input }],
        execute: [{ type: Output }],
        openSubMenu: [{ type: Output }],
        closeLeafMenu: [{ type: Output }],
        closeAllMenus: [{ type: Output }],
        menuElement: [{ type: ViewChild, args: ['menu',] }],
        menuItemElements: [{ type: ViewChildren, args: ['li',] }],
        onKeyEvent: [{ type: HostListener, args: ['window:keydown.ArrowDown', ['$event'],] }, { type: HostListener, args: ['window:keydown.ArrowUp', ['$event'],] }],
        keyboardOpenSubMenu: [{ type: HostListener, args: ['window:keydown.ArrowRight', ['$event'],] }],
        keyboardMenuItemSelect: [{ type: HostListener, args: ['window:keydown.Enter', ['$event'],] }, { type: HostListener, args: ['window:keydown.Space', ['$event'],] }],
        onCloseLeafMenu: [{ type: HostListener, args: ['window:keydown.Escape', ['$event'],] }, { type: HostListener, args: ['window:keydown.ArrowLeft', ['$event'],] }],
        closeMenu: [{ type: HostListener, args: ['document:click', ['$event'],] }, { type: HostListener, args: ['document:contextmenu', ['$event'],] }]
    };
    return ContextMenuContentComponent;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ContextMenuService = /** @class */ (function () {
    function ContextMenuService(overlay, scrollStrategy) {
        this.overlay = overlay;
        this.scrollStrategy = scrollStrategy;
        this.isDestroyingLeafMenu = false;
        this.show = new Subject();
        this.triggerClose = new Subject();
        this.close = new Subject();
        this.overlays = [];
        this.fakeElement = {
            getBoundingClientRect: function () { return ({
                bottom: 0,
                height: 0,
                left: 0,
                right: 0,
                top: 0,
                width: 0,
            }); }
        };
    }
    /**
     * @param {?} context
     * @return {?}
     */
    ContextMenuService.prototype.openContextMenu = /**
     * @param {?} context
     * @return {?}
     */
    function (context) {
        var anchorElement = context.anchorElement, event = context.event, parentContextMenu = context.parentContextMenu;
        if (!parentContextMenu) {
            var /** @type {?} */ mouseEvent_1 = /** @type {?} */ (event);
            this.fakeElement.getBoundingClientRect = function () { return ({
                bottom: mouseEvent_1.clientY,
                height: 0,
                left: mouseEvent_1.clientX,
                right: mouseEvent_1.clientX,
                top: mouseEvent_1.clientY,
                width: 0,
            }); };
            this.closeAllContextMenus({ eventType: 'cancel', event: event });
            var /** @type {?} */ positionStrategy = this.overlay.position().connectedTo(new ElementRef(anchorElement || this.fakeElement), { originX: 'start', originY: 'bottom' }, { overlayX: 'start', overlayY: 'top' })
                .withFallbackPosition({ originX: 'start', originY: 'top' }, { overlayX: 'start', overlayY: 'bottom' })
                .withFallbackPosition({ originX: 'end', originY: 'top' }, { overlayX: 'start', overlayY: 'top' })
                .withFallbackPosition({ originX: 'start', originY: 'top' }, { overlayX: 'end', overlayY: 'top' })
                .withFallbackPosition({ originX: 'end', originY: 'center' }, { overlayX: 'start', overlayY: 'center' })
                .withFallbackPosition({ originX: 'start', originY: 'center' }, { overlayX: 'end', overlayY: 'center' });
            this.overlays = [this.overlay.create({
                    positionStrategy: positionStrategy,
                    panelClass: 'ngx-contextmenu',
                    scrollStrategy: this.scrollStrategy.close(),
                })];
            this.attachContextMenu(this.overlays[0], context);
        }
        else {
            var /** @type {?} */ positionStrategy = this.overlay.position().connectedTo(new ElementRef(event ? event.target : anchorElement), { originX: 'end', originY: 'top' }, { overlayX: 'start', overlayY: 'top' })
                .withFallbackPosition({ originX: 'start', originY: 'top' }, { overlayX: 'end', overlayY: 'top' })
                .withFallbackPosition({ originX: 'end', originY: 'bottom' }, { overlayX: 'start', overlayY: 'bottom' })
                .withFallbackPosition({ originX: 'start', originY: 'bottom' }, { overlayX: 'end', overlayY: 'bottom' });
            var /** @type {?} */ newOverlay = this.overlay.create({
                positionStrategy: positionStrategy,
                panelClass: 'ngx-contextmenu',
                scrollStrategy: this.scrollStrategy.close(),
            });
            this.destroySubMenus(parentContextMenu);
            this.overlays = this.overlays.concat(newOverlay);
            this.attachContextMenu(newOverlay, context);
        }
    };
    /**
     * @param {?} overlay
     * @param {?} context
     * @return {?}
     */
    ContextMenuService.prototype.attachContextMenu = /**
     * @param {?} overlay
     * @param {?} context
     * @return {?}
     */
    function (overlay, context) {
        var _this = this;
        var event = context.event, item = context.item, menuItems = context.menuItems, menuClass = context.menuClass;
        var /** @type {?} */ contextMenuContent = overlay.attach(new ComponentPortal(ContextMenuContentComponent));
        contextMenuContent.instance.event = event;
        contextMenuContent.instance.item = item;
        contextMenuContent.instance.menuItems = menuItems;
        contextMenuContent.instance.overlay = overlay;
        contextMenuContent.instance.isLeaf = true;
        contextMenuContent.instance.menuClass = menuClass;
        (/** @type {?} */ (overlay)).contextMenu = contextMenuContent.instance;
        var /** @type {?} */ subscriptions = new Subscription();
        subscriptions.add(contextMenuContent.instance.execute.asObservable()
            .subscribe(function (executeEvent) { return _this.closeAllContextMenus(__assign({ eventType: 'execute' }, executeEvent)); }));
        subscriptions.add(contextMenuContent.instance.closeAllMenus.asObservable()
            .subscribe(function (closeAllEvent) { return _this.closeAllContextMenus(__assign({ eventType: 'cancel' }, closeAllEvent)); }));
        subscriptions.add(contextMenuContent.instance.closeLeafMenu.asObservable()
            .subscribe(function (closeLeafMenuEvent) { return _this.destroyLeafMenu(closeLeafMenuEvent); }));
        subscriptions.add(contextMenuContent.instance.openSubMenu.asObservable()
            .subscribe(function (subMenuEvent) {
            _this.destroySubMenus(contextMenuContent.instance);
            if (!subMenuEvent.contextMenu) {
                contextMenuContent.instance.isLeaf = true;
                return;
            }
            contextMenuContent.instance.isLeaf = false;
            _this.show.next(subMenuEvent);
        }));
        contextMenuContent.onDestroy(function () {
            menuItems.forEach(function (menuItem) { return menuItem.isActive = false; });
            subscriptions.unsubscribe();
        });
        contextMenuContent.changeDetectorRef.detectChanges();
    };
    /**
     * @param {?} closeEvent
     * @return {?}
     */
    ContextMenuService.prototype.closeAllContextMenus = /**
     * @param {?} closeEvent
     * @return {?}
     */
    function (closeEvent) {
        if (this.overlays) {
            this.close.next(closeEvent);
            this.overlays.forEach(function (overlay, index) {
                overlay.detach();
                overlay.dispose();
            });
        }
        this.overlays = [];
    };
    /**
     * @return {?}
     */
    ContextMenuService.prototype.getLastAttachedOverlay = /**
     * @return {?}
     */
    function () {
        var /** @type {?} */ overlay = this.overlays[this.overlays.length - 1];
        while (this.overlays.length > 1 && overlay && !overlay.hasAttached()) {
            overlay.detach();
            overlay.dispose();
            this.overlays = this.overlays.slice(0, -1);
            overlay = this.overlays[this.overlays.length - 1];
        }
        return overlay;
    };
    /**
     * @param {?=} __0
     * @return {?}
     */
    ContextMenuService.prototype.destroyLeafMenu = /**
     * @param {?=} __0
     * @return {?}
     */
    function (_a) {
        var _this = this;
        var _b = _a === void 0 ? {} : _a, exceptRootMenu = _b.exceptRootMenu, event = _b.event;
        if (this.isDestroyingLeafMenu) {
            return;
        }
        this.isDestroyingLeafMenu = true;
        setTimeout(function () {
            var /** @type {?} */ overlay = _this.getLastAttachedOverlay();
            if (_this.overlays.length > 1 && overlay) {
                overlay.detach();
                overlay.dispose();
            }
            if (!exceptRootMenu && _this.overlays.length > 0 && overlay) {
                _this.close.next({ eventType: 'cancel', event: event });
                overlay.detach();
                overlay.dispose();
            }
            var /** @type {?} */ newLeaf = _this.getLastAttachedOverlay();
            if (newLeaf) {
                newLeaf.contextMenu.isLeaf = true;
            }
            _this.isDestroyingLeafMenu = false;
        });
    };
    /**
     * @param {?} contextMenu
     * @return {?}
     */
    ContextMenuService.prototype.destroySubMenus = /**
     * @param {?} contextMenu
     * @return {?}
     */
    function (contextMenu) {
        var /** @type {?} */ overlay = contextMenu.overlay;
        var /** @type {?} */ index = this.overlays.indexOf(overlay);
        this.overlays.slice(index + 1).forEach(function (subMenuOverlay) {
            subMenuOverlay.detach();
            subMenuOverlay.dispose();
        });
    };
    /**
     * @param {?} contextMenuContent
     * @return {?}
     */
    ContextMenuService.prototype.isLeafMenu = /**
     * @param {?} contextMenuContent
     * @return {?}
     */
    function (contextMenuContent) {
        var /** @type {?} */ overlay = this.getLastAttachedOverlay();
        return contextMenuContent.overlay === overlay;
    };
    ContextMenuService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    ContextMenuService.ctorParameters = function () { return [
        { type: Overlay },
        { type: ScrollStrategyOptions }
    ]; };
    return ContextMenuService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ContextMenuComponent = /** @class */ (function () {
    function ContextMenuComponent(_contextMenuService, changeDetector, elementRef, options) {
        var _this = this;
        this._contextMenuService = _contextMenuService;
        this.changeDetector = changeDetector;
        this.elementRef = elementRef;
        this.options = options;
        this.menuClass = "";
        this.autoFocus = false;
        this.useBootstrap4 = false;
        this.highlightParentItems = false;
        this.disabled = false;
        this.close = new EventEmitter();
        this.open = new EventEmitter();
        this.visibleMenuItems = [];
        this.links = [];
        this.subscription = new Subscription();
        if (options) {
            this.autoFocus = options.autoFocus;
            this.useBootstrap4 = options.useBootstrap4;
            this.highlightParentItems = options.highlightParentItems;
        }
        this.subscription.add(_contextMenuService.show.subscribe(function (menuEvent) {
            _this.onMenuEvent(menuEvent);
        }));
    }
    /**
     * @return {?}
     */
    ContextMenuComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this.subscription.unsubscribe();
    };
    /**
     * @param {?} menuEvent
     * @return {?}
     */
    ContextMenuComponent.prototype.onMenuEvent = /**
     * @param {?} menuEvent
     * @return {?}
     */
    function (menuEvent) {
        var _this = this;
        if (this.disabled) {
            return;
        }
        var contextMenu = menuEvent.contextMenu, event = menuEvent.event, item = menuEvent.item;
        if (contextMenu && contextMenu !== this) {
            return;
        }
        this.event = event;
        this.item = item;
        this.setVisibleMenuItems();
        this._contextMenuService.openContextMenu(__assign({}, menuEvent, { menuItems: this.visibleMenuItems, menuClass: this.menuClass }));
        this._contextMenuService.close.asObservable().pipe(first()).subscribe(function (closeEvent) { return _this.close.emit(closeEvent); });
        this.open.next(menuEvent);
    };
    /**
     * @param {?} menuItem
     * @return {?}
     */
    ContextMenuComponent.prototype.isMenuItemVisible = /**
     * @param {?} menuItem
     * @return {?}
     */
    function (menuItem) {
        return this.evaluateIfFunction(menuItem.visible);
    };
    /**
     * @return {?}
     */
    ContextMenuComponent.prototype.setVisibleMenuItems = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this.visibleMenuItems = this.menuItems.filter(function (menuItem) { return _this.isMenuItemVisible(menuItem); });
    };
    /**
     * @param {?} value
     * @return {?}
     */
    ContextMenuComponent.prototype.evaluateIfFunction = /**
     * @param {?} value
     * @return {?}
     */
    function (value) {
        if (value instanceof Function) {
            return value(this.item);
        }
        return value;
    };
    ContextMenuComponent.decorators = [
        { type: Component, args: [{
                    encapsulation: ViewEncapsulation.None,
                    selector: 'context-menu',
                    styles: ["\n  .cdk-overlay-container {\n    position: fixed;\n    z-index: 1000;\n    pointer-events: none;\n    top: 0;\n    left: 0;\n    width: 100%;\n    height: 100%;\n  }\n  .ngx-contextmenu.cdk-overlay-pane {\n    position: absolute;\n    pointer-events: auto;\n    box-sizing: border-box;\n  }\n"],
                    template: " ",
                },] },
    ];
    /** @nocollapse */
    ContextMenuComponent.ctorParameters = function () { return [
        { type: ContextMenuService },
        { type: ChangeDetectorRef },
        { type: ElementRef },
        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [CONTEXT_MENU_OPTIONS,] }] }
    ]; };
    ContextMenuComponent.propDecorators = {
        menuClass: [{ type: Input }],
        autoFocus: [{ type: Input }],
        useBootstrap4: [{ type: Input }],
        highlightParentItems: [{ type: Input }],
        disabled: [{ type: Input }],
        close: [{ type: Output }],
        open: [{ type: Output }],
        menuItems: [{ type: ContentChildren, args: [ContextMenuItemDirective,] }],
        menuElement: [{ type: ViewChild, args: ['menu',] }]
    };
    return ContextMenuComponent;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ContextMenuAttachDirective = /** @class */ (function () {
    function ContextMenuAttachDirective(contextMenuService) {
        this.contextMenuService = contextMenuService;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    ContextMenuAttachDirective.prototype.onContextMenu = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        if (!this.contextMenu.disabled) {
            this.contextMenuService.show.next({
                contextMenu: this.contextMenu,
                event: event,
                item: this.contextMenuSubject,
            });
            event.preventDefault();
            event.stopPropagation();
        }
    };
    ContextMenuAttachDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[contextMenu]',
                },] },
    ];
    /** @nocollapse */
    ContextMenuAttachDirective.ctorParameters = function () { return [
        { type: ContextMenuService }
    ]; };
    ContextMenuAttachDirective.propDecorators = {
        contextMenuSubject: [{ type: Input }],
        contextMenu: [{ type: Input }],
        onContextMenu: [{ type: HostListener, args: ['contextmenu', ['$event'],] }]
    };
    return ContextMenuAttachDirective;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ContextMenuModule = /** @class */ (function () {
    function ContextMenuModule() {
    }
    /**
     * @param {?=} options
     * @return {?}
     */
    ContextMenuModule.forRoot = /**
     * @param {?=} options
     * @return {?}
     */
    function (options) {
        return {
            ngModule: ContextMenuModule,
            providers: [
                ContextMenuService,
                {
                    provide: CONTEXT_MENU_OPTIONS,
                    useValue: options,
                },
            ],
        };
    };
    ContextMenuModule.decorators = [
        { type: NgModule, args: [{
                    declarations: [
                        ContextMenuAttachDirective,
                        ContextMenuComponent,
                        ContextMenuContentComponent,
                        ContextMenuItemDirective,
                    ],
                    entryComponents: [
                        ContextMenuContentComponent,
                    ],
                    exports: [
                        ContextMenuAttachDirective,
                        ContextMenuComponent,
                        ContextMenuItemDirective,
                    ],
                    imports: [
                        CommonModule,
                        OverlayModule,
                    ],
                },] },
    ];
    return ContextMenuModule;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */

export { ContextMenuModule, ContextMenuComponent, ContextMenuService, ContextMenuAttachDirective as ɵa, ContextMenuItemDirective as ɵb, CONTEXT_MENU_OPTIONS as ɵc, ContextMenuContentComponent as ɵd };

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-contextmenu.js.map","sources":["ng://ngx-contextmenu/lib/contextMenu.item.directive.ts","ng://ngx-contextmenu/lib/contextMenu.tokens.ts","ng://ngx-contextmenu/lib/contextMenuContent.component.ts","ng://ngx-contextmenu/lib/contextMenu.service.ts","ng://ngx-contextmenu/lib/contextMenu.component.ts","ng://ngx-contextmenu/lib/contextMenu.attach.directive.ts","ng://ngx-contextmenu/lib/ngx-contextmenu.ts"],"sourcesContent":["import { Highlightable } from '@angular/cdk/a11y';\nimport { Directive, ElementRef, EventEmitter, Input, Output, TemplateRef } from '@angular/core';\n\n@Directive({\n  /* tslint:disable:directive-selector-type */\n  selector: '[contextMenuItem]',\n  /* tslint:enable:directive-selector-type */\n})\nexport class ContextMenuItemDirective implements Highlightable {\n  @Input() public subMenu: any;\n  @Input() public divider = false;\n  @Input() public enabled: boolean | ((item: any) => boolean) = true;\n  @Input() public passive = false;\n  @Input() public visible: boolean | ((item: any) => boolean) = true;\n  @Output() public execute: EventEmitter<{ event: Event, item: any }> = new EventEmitter();\n\n  public currentItem: any;\n  public isActive = false;\n  public isActiveParent = false;\n  public get disabled() {\n    return this.passive ||\n      this.divider ||\n      !this.evaluateIfFunction(this.enabled, this.currentItem);\n  }\n\n  constructor(public template: TemplateRef<{ item: any }>, public elementRef: ElementRef) { }\n\n  public evaluateIfFunction(value: any, item: any): any {\n    if (value instanceof Function) {\n      return value(item);\n    }\n    return value;\n  }\n\n  public setActiveStyles(): void {\n    this.isActive = true;\n  }\n  public setInactiveStyles(): void {\n    this.isActive = false;\n  }\n\n  public setActiveParentStyles(): void {\n    this.isActiveParent = true;\n  }\n  public setInActiveParentStyles(): void {\n    this.isActiveParent = false;\n  }\n\n  public triggerExecute(item: any, $event?: MouseEvent | KeyboardEvent): void {\n    if (!this.evaluateIfFunction(this.enabled, item)) {\n      return;\n    }\n    this.execute.emit({ event: $event, item });\n  }\n}\n","import { InjectionToken } from '@angular/core';\n\nexport const CONTEXT_MENU_OPTIONS = new InjectionToken('CONTEXT_MENU_OPTIONS');\n","import { CloseLeafMenuEvent, IContextMenuClickEvent } from './contextMenu.service';\nimport { OverlayRef } from '@angular/cdk/overlay';\nimport {\n    AfterViewInit,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    Inject,\n    Input,\n    Optional,\n    Renderer,\n    ViewChild,\n    ViewChildren,\n} from '@angular/core';\nimport { EventEmitter, OnDestroy, OnInit, Output, QueryList, HostListener } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { ContextMenuItemDirective } from './contextMenu.item.directive';\nimport { IContextMenuOptions } from './contextMenu.options';\nimport { CONTEXT_MENU_OPTIONS } from './contextMenu.tokens';\nimport { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\n\nexport interface ILinkConfig {\n  click: (item: any, $event?: MouseEvent) => void;\n  enabled?: (item: any) => boolean;\n  html: (item: any) => string;\n}\n\nconst ARROW_LEFT_KEYCODE = 37;\n\n@Component({\n  selector: 'context-menu-content',\n  styles: [\n    `.passive {\n       display: block;\n       padding: 3px 20px;\n       clear: both;\n       font-weight: normal;\n       line-height: @line-height-base;\n       white-space: nowrap;\n     }\n    .hasSubMenu:before {\n      content: \"\\u25B6\";\n      float: right;\n    }\n    .activeParent {\n    text-decoration: none;\n      color: #262626;\n      background-color: #f5f5f5;\n    }`,\n  ],\n  template:\n  `<div class=\"dropdown open show ngx-contextmenu\" [ngClass]=\"menuClass\" tabindex=\"0\">\n      <ul #menu class=\"dropdown-menu show\" style=\"position: static; float: none;\" tabindex=\"0\">\n        <li #li *ngFor=\"let menuItem of menuItems; let i = index\" [class.disabled]=\"!isMenuItemEnabled(menuItem)\"\n            [class.divider]=\"menuItem.divider\" [class.dropdown-divider]=\"useBootstrap4 && menuItem.divider\"\n            [class.active]=\"menuItem.isActive && isMenuItemEnabled(menuItem)\"\n            [attr.role]=\"menuItem.divider ? 'separator' : undefined\">\n          <a *ngIf=\"!menuItem.divider && !menuItem.passive\" href [class.dropdown-item]=\"useBootstrap4\"\n            [class.active]=\"menuItem.isActive && isMenuItemEnabled(menuItem)\"\n            [class.activeParent]=\"highlightParentItems && menuItem.isActiveParent && isMenuItemEnabled(menuItem)\"\n            [class.disabled]=\"useBootstrap4 && !isMenuItemEnabled(menuItem)\" [class.hasSubMenu]=\"!!menuItem.subMenu\"\n            (click)=\"onMenuItemSelect(menuItem, $event)\" (mouseenter)=\"onOpenSubMenu(menuItem, $event)\">\n            <ng-template [ngTemplateOutlet]=\"menuItem.template\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-template>\n          </a>\n\n          <span (click)=\"stopEvent($event)\" (contextmenu)=\"stopEvent($event)\" class=\"passive\"\n                *ngIf=\"!menuItem.divider && menuItem.passive\" [class.dropdown-item]=\"useBootstrap4\"\n                [class.disabled]=\"useBootstrap4 && !isMenuItemEnabled(menuItem)\">\n            <ng-template [ngTemplateOutlet]=\"menuItem.template\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-template>\n          </span>\n        </li>\n      </ul>\n    </div>\n  `,\n})\nexport class ContextMenuContentComponent implements OnInit, OnDestroy, AfterViewInit {\n  @Input() public menuItems: ContextMenuItemDirective[] = [];\n  @Input() public item: any;\n  @Input() public event: MouseEvent | KeyboardEvent;\n  @Input() public parentContextMenu: ContextMenuContentComponent;\n  @Input() public menuClass: string;\n  @Input() public overlay: OverlayRef;\n  @Input() public isLeaf = false;\n  @Output() public execute: EventEmitter<{ event: MouseEvent | KeyboardEvent, item: any, menuItem: ContextMenuItemDirective }>\n    = new EventEmitter();\n  @Output() public openSubMenu: EventEmitter<IContextMenuClickEvent> = new EventEmitter();\n  @Output() public closeLeafMenu: EventEmitter<CloseLeafMenuEvent> = new EventEmitter();\n  @Output() public closeAllMenus: EventEmitter<{ event: MouseEvent }> = new EventEmitter();\n  @ViewChild('menu') public menuElement: ElementRef;\n  @ViewChildren('li') public menuItemElements: QueryList<ElementRef>;\n\n  public autoFocus = false;\n  public useBootstrap4 = false;\n  public highlightParentItems = false;\n  private _keyManager: ActiveDescendantKeyManager<ContextMenuItemDirective>;\n  private subscription: Subscription = new Subscription();\n  constructor(\n    private changeDetector: ChangeDetectorRef,\n    private elementRef: ElementRef,\n    @Optional()\n    @Inject(CONTEXT_MENU_OPTIONS) private options: IContextMenuOptions,\n    public renderer: Renderer,\n  ) {\n    if (options) {\n      this.autoFocus = options.autoFocus;\n      this.useBootstrap4 = options.useBootstrap4;\n      this.highlightParentItems = options.highlightParentItems;\n    }\n  }\n\n  ngOnInit(): void {\n    this.menuItems.forEach(menuItem => {\n      menuItem.currentItem = this.item;\n      this.subscription.add(menuItem.execute.subscribe(event => this.execute.emit({ ...event, menuItem })));\n    });\n    const queryList = new QueryList<ContextMenuItemDirective>();\n    queryList.reset(this.menuItems);\n    this._keyManager = new ActiveDescendantKeyManager<ContextMenuItemDirective>(queryList).withWrap();\n  }\n\n  ngAfterViewInit() {\n    if (this.autoFocus) {\n      setTimeout(() => this.focus());\n    }\n    this.overlay.updatePosition();\n  }\n\n  ngOnDestroy() {\n    this.subscription.unsubscribe();\n  }\n\n  focus(): void {\n    if (this.autoFocus) {\n      this.menuElement.nativeElement.focus();\n    }\n  }\n\n  stopEvent($event: MouseEvent) {\n    $event.stopPropagation();\n  }\n\n  public isMenuItemEnabled(menuItem: ContextMenuItemDirective): boolean {\n    return this.evaluateIfFunction(menuItem && menuItem.enabled);\n  }\n\n  public isMenuItemVisible(menuItem: ContextMenuItemDirective): boolean {\n    return this.evaluateIfFunction(menuItem && menuItem.visible);\n  }\n\n  public evaluateIfFunction(value: any): any {\n    if (value instanceof Function) {\n      return value(this.item);\n    }\n    return value;\n  }\n\n  public isDisabled(link: ILinkConfig): boolean {\n    return link.enabled && !link.enabled(this.item);\n  }\n\n  @HostListener('window:keydown.ArrowDown', ['$event'])\n  @HostListener('window:keydown.ArrowUp', ['$event'])\n  public onKeyEvent(event: KeyboardEvent): void {\n    if (!this.isLeaf) {\n      return;\n    }\n    this._keyManager.onKeydown(event);\n  }\n\n  @HostListener('window:keydown.ArrowRight', ['$event'])\n  public keyboardOpenSubMenu(event?: KeyboardEvent): void {\n    if (!this.isLeaf) {\n      return;\n    }\n    this.cancelEvent(event);\n    const menuItem = this.menuItems[this._keyManager.activeItemIndex];\n    if (menuItem) {\n      this.onOpenSubMenu(menuItem);\n    }\n  }\n\n  @HostListener('window:keydown.Enter', ['$event'])\n  @HostListener('window:keydown.Space', ['$event'])\n  public keyboardMenuItemSelect(event?: KeyboardEvent): void {\n    if (!this.isLeaf) {\n      return;\n    }\n    this.cancelEvent(event);\n    const menuItem = this.menuItems[this._keyManager.activeItemIndex];\n    if (menuItem) {\n      this.onMenuItemSelect(menuItem, event);\n    }\n  }\n\n  @HostListener('window:keydown.Escape', ['$event'])\n  @HostListener('window:keydown.ArrowLeft', ['$event'])\n  public onCloseLeafMenu(event: KeyboardEvent): void {\n    if (!this.isLeaf) {\n      return;\n    }\n    this.cancelEvent(event);\n    this.closeLeafMenu.emit({ exceptRootMenu: event.keyCode === ARROW_LEFT_KEYCODE, event });\n  }\n\n  @HostListener('document:click', ['$event'])\n  @HostListener('document:contextmenu', ['$event'])\n  public closeMenu(event: MouseEvent): void {\n    if (event.type === 'click' && event.button === 2) {\n      return;\n    }\n    this.closeAllMenus.emit({event});\n  }\n\n  public onOpenSubMenu(menuItem: ContextMenuItemDirective, event?: MouseEvent | KeyboardEvent): void {\n    const anchorElementRef = this.menuItemElements.toArray()[this._keyManager.activeItemIndex];\n    const anchorElement = anchorElementRef && anchorElementRef.nativeElement;\n    if (this.highlightParentItems) { \n      this.menuItems.forEach(item => item.isActiveParent = (item === menuItem && menuItem.subMenu) );\n    }\n    this.openSubMenu.emit({\n      anchorElement,\n      contextMenu: menuItem.subMenu,\n      event,\n      item: this.item,\n      parentContextMenu: this,\n    });\n  }\n\n  public onMenuItemSelect(menuItem: ContextMenuItemDirective, event: MouseEvent | KeyboardEvent): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.onOpenSubMenu(menuItem, event);\n    if (!menuItem.subMenu) {\n      menuItem.triggerExecute(this.item, event);\n    }\n  }\n\n  private cancelEvent(event): void {\n    if (!event) {\n      return;\n    }\n\n    const target: HTMLElement = event.target;\n    if (['INPUT', 'TEXTAREA', 'SELECT'].indexOf(target.tagName) > -1 || target.isContentEditable) {\n      return;\n    }\n\n    event.preventDefault();\n    event.stopPropagation();\n  }\n}\n","import { Overlay, OverlayRef, ScrollStrategyOptions } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { ComponentRef, Injectable, ElementRef } from '@angular/core';\nimport { Subject, Subscription } from 'rxjs';\n\nimport { ContextMenuComponent } from './contextMenu.component';\nimport { ContextMenuItemDirective } from './contextMenu.item.directive';\nimport { ContextMenuContentComponent } from './contextMenuContent.component';\n\nexport interface IContextMenuClickEvent {\n  anchorElement?: Element | EventTarget;\n  contextMenu?: ContextMenuComponent;\n  event?: MouseEvent | KeyboardEvent;\n  parentContextMenu?: ContextMenuContentComponent;\n  item: any;\n  activeMenuItemIndex?: number;\n}\nexport interface IContextMenuContext extends IContextMenuClickEvent {\n  menuItems: ContextMenuItemDirective[];\n  menuClass: string;\n}\nexport interface CloseLeafMenuEvent {\n  exceptRootMenu?: boolean;\n  event?: MouseEvent | KeyboardEvent;\n}\nexport interface OverlayRefWithContextMenu extends OverlayRef {\n  contextMenu?: ContextMenuContentComponent;\n}\n\nexport interface CancelContextMenuEvent {\n  eventType: 'cancel';\n  event?: MouseEvent | KeyboardEvent;\n}\nexport interface ExecuteContextMenuEvent {\n  eventType: 'execute';\n  event?: MouseEvent | KeyboardEvent;\n  item: any;\n  menuItem: ContextMenuItemDirective;\n}\nexport type CloseContextMenuEvent = ExecuteContextMenuEvent | CancelContextMenuEvent;\n\n@Injectable()\nexport class ContextMenuService {\n  public isDestroyingLeafMenu = false;\n\n  public show: Subject<IContextMenuClickEvent