@kreash/ngx-contextmenu/index.d.ts

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

import * as i0 from '@angular/core';
import { TemplateRef, ElementRef, EventEmitter, OnInit, OnDestroy, AfterViewInit, QueryList, ModuleWithProviders } from '@angular/core';
import * as i6 from '@angular/cdk/overlay';
import { OverlayRef, Overlay, ScrollStrategyOptions } from '@angular/cdk/overlay';
import { Highlightable } from '@angular/cdk/a11y';
import { Subject } from 'rxjs';
import * as i5 from '@angular/common';

interface IContextMenuOptions {
    useBootstrap4?: boolean;
    autoFocus?: boolean;
}

declare class ContextMenuItemDirective<TItem = any> implements Highlightable {
    template: TemplateRef<{
        item: TItem;
    }>;
    elementRef: ElementRef;
    subMenu: any;
    divider: boolean;
    enabled: boolean | ((item: TItem) => boolean);
    passive: boolean;
    visible: boolean | ((item: TItem) => boolean);
    execute: EventEmitter<{
        event: MouseEvent | KeyboardEvent;
        item: TItem;
    }>;
    currentItem: TItem;
    isActive: boolean;
    get disabled(): boolean;
    constructor(template: TemplateRef<{
        item: TItem;
    }>, elementRef: ElementRef);
    setActiveStyles(): void;
    setInactiveStyles(): void;
    triggerExecute(item: TItem, $event?: MouseEvent | KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuItemDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuItemDirective<any>, "[contextMenuItem]", never, { "subMenu": { "alias": "subMenu"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "enabled": { "alias": "enabled"; "required": false; }; "passive": { "alias": "passive"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "execute": "execute"; }, never, never, false, never>;
}

interface ILinkConfig$1 {
    click: (item: any, $event?: MouseEvent) => void;
    enabled?: (item: any) => boolean;
    html: (item: any) => string;
}
declare class ContextMenuContentComponent implements OnInit, OnDestroy, AfterViewInit {
    menuItems: ContextMenuItemDirective[];
    item: any;
    event: MouseEvent | KeyboardEvent;
    parentContextMenu: ContextMenuContentComponent;
    menuClass: string;
    overlay: OverlayRef;
    isLeaf: boolean;
    execute: EventEmitter<{
        event: MouseEvent | KeyboardEvent;
        item: any;
        menuItem: ContextMenuItemDirective;
    }>;
    openSubMenu: EventEmitter<IContextMenuClickEvent>;
    closeLeafMenu: EventEmitter<CloseLeafMenuEvent>;
    closeAllMenus: EventEmitter<{
        event: MouseEvent;
    }>;
    menuElement: ElementRef;
    menuItemElements: QueryList<ElementRef>;
    autoFocus: boolean;
    useBootstrap4: boolean;
    private _keyManager;
    private subscription;
    constructor(options: IContextMenuOptions);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    focus(): void;
    stopEvent($event: MouseEvent): void;
    isMenuItemEnabled(menuItem: ContextMenuItemDirective): boolean;
    isMenuItemVisible(menuItem: ContextMenuItemDirective): boolean;
    isDisabled(link: ILinkConfig$1): boolean;
    onKeyEvent(event: KeyboardEvent): void;
    keyboardOpenSubMenu(event?: KeyboardEvent): void;
    keyboardMenuItemSelect(event?: KeyboardEvent): void;
    onCloseLeafMenu(event: KeyboardEvent): void;
    closeMenu(event: MouseEvent): void;
    onOpenSubMenu(menuItem: ContextMenuItemDirective, event?: MouseEvent | KeyboardEvent): void;
    onMenuItemSelect(menuItem: ContextMenuItemDirective, event: MouseEvent | KeyboardEvent): void;
    private cancelEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuContentComponent, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuContentComponent, "context-menu-content", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "item": { "alias": "item"; "required": false; }; "event": { "alias": "event"; "required": false; }; "parentContextMenu": { "alias": "parentContextMenu"; "required": false; }; "menuClass": { "alias": "menuClass"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; "isLeaf": { "alias": "isLeaf"; "required": false; }; }, { "execute": "execute"; "openSubMenu": "openSubMenu"; "closeLeafMenu": "closeLeafMenu"; "closeAllMenus": "closeAllMenus"; }, never, never, false, never>;
}

interface IContextMenuClickEvent {
    anchorElement?: Element | EventTarget;
    contextMenu?: ContextMenuComponent;
    event?: MouseEvent | KeyboardEvent;
    parentContextMenu?: ContextMenuContentComponent;
    item: any;
    activeMenuItemIndex?: number;
}
interface IContextMenuContext extends IContextMenuClickEvent {
    menuItems: ContextMenuItemDirective[];
    menuClass: string;
}
interface CloseLeafMenuEvent {
    exceptRootMenu?: boolean;
    event?: MouseEvent | KeyboardEvent;
}
interface OverlayRefWithContextMenu extends OverlayRef {
    contextMenu?: ContextMenuContentComponent;
}
interface CancelContextMenuEvent {
    eventType: 'cancel';
    event?: MouseEvent | KeyboardEvent;
}
interface ExecuteContextMenuEvent {
    eventType: 'execute';
    event?: MouseEvent | KeyboardEvent;
    item: any;
    menuItem: ContextMenuItemDirective;
}
type CloseContextMenuEvent = ExecuteContextMenuEvent | CancelContextMenuEvent;

declare class ContextMenuService {
    private overlay;
    private scrollStrategy;
    isDestroyingLeafMenu: boolean;
    show: Subject<IContextMenuClickEvent>;
    close: Subject<CloseContextMenuEvent>;
    private overlays;
    private fakeElement;
    private readonly rootMenuPositionsFor;
    private readonly subMenuPositions;
    constructor(overlay: Overlay, scrollStrategy: ScrollStrategyOptions);
    openContextMenu(context: IContextMenuContext): void;
    attachContextMenu(overlay: OverlayRef, context: IContextMenuContext): void;
    closeAllContextMenus(closeEvent: CloseContextMenuEvent): void;
    getLastAttachedOverlay(): OverlayRefWithContextMenu;
    destroyLeafMenu({ exceptRootMenu, event }?: CloseLeafMenuEvent): void;
    destroySubMenus(contextMenu: ContextMenuContentComponent): void;
    isLeafMenu(contextMenuContent: ContextMenuContentComponent): boolean;
    private destroyOverlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuService>;
}

interface ILinkConfig {
    click: (item: any, $event?: MouseEvent) => void;
    enabled?: (item: any) => boolean;
    html: (item: any) => string;
}
interface MouseLocation {
    left?: string;
    top?: string;
    marginLeft?: string;
    marginTop?: string;
}
declare class ContextMenuComponent implements OnDestroy {
    private contextMenuService;
    menuClass: string;
    autoFocus: boolean;
    useBootstrap4: boolean;
    disabled: boolean;
    close: EventEmitter<CloseContextMenuEvent>;
    open: EventEmitter<IContextMenuClickEvent>;
    menuItems: QueryList<ContextMenuItemDirective>;
    visibleMenuItems: ContextMenuItemDirective[];
    menuElement: ElementRef;
    links: ILinkConfig[];
    item: any;
    event: MouseEvent | KeyboardEvent;
    private subscription;
    constructor(contextMenuService: ContextMenuService, options: IContextMenuOptions);
    ngOnDestroy(): void;
    onMenuEvent(menuEvent: IContextMenuClickEvent): void;
    isMenuItemVisible(menuItem: ContextMenuItemDirective): boolean;
    setVisibleMenuItems(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "context-menu", never, { "menuClass": { "alias": "menuClass"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "useBootstrap4": { "alias": "useBootstrap4"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "close": "close"; "open": "open"; }, ["menuItems"], never, false, never>;
}

declare class ContextMenuAttachDirective {
    private contextMenuService;
    contextMenuSubject: any;
    contextMenu: ContextMenuComponent;
    constructor(contextMenuService: ContextMenuService);
    onContextMenu(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuAttachDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContextMenuAttachDirective, "[contextMenu]", never, { "contextMenuSubject": { "alias": "contextMenuSubject"; "required": false; }; "contextMenu": { "alias": "contextMenu"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ContextMenuModule {
    static forRoot(options?: IContextMenuOptions): ModuleWithProviders<ContextMenuModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ContextMenuModule, [typeof ContextMenuComponent, typeof ContextMenuContentComponent, typeof ContextMenuAttachDirective, typeof ContextMenuItemDirective], [typeof i5.CommonModule, typeof i6.OverlayModule], [typeof ContextMenuComponent, typeof ContextMenuAttachDirective, typeof ContextMenuItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ContextMenuModule>;
}

export { ContextMenuAttachDirective, ContextMenuComponent, ContextMenuItemDirective, ContextMenuModule, ContextMenuService };
export type { CancelContextMenuEvent, CloseContextMenuEvent, CloseLeafMenuEvent, ExecuteContextMenuEvent, IContextMenuClickEvent, IContextMenuContext, IContextMenuOptions, ILinkConfig, MouseLocation, OverlayRefWithContextMenu };
//# sourceMappingURL=index.d.ts.map