@acorex/components 6.0.1 → 6.0.7

package/esm2020/common/src/hotkey.service.mjs

@@ -0,0 +1,38 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs/internal/Observable';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class AXHotkeysService {
+    constructor(eventManager, document) {
+        this.eventManager = eventManager;
+        this.document = document;
+        this.defaults = {
+            element: this.document,
+        };
+    }
+    addShortcut(options) {
+        const merged = { ...this.defaults, ...options };
+        const event = `keydown.${merged.keys}`;
+        return new Observable((observer) => {
+            const handler = (e) => {
+                e.preventDefault();
+                observer.next(e);
+            };
+            const dispose = this.eventManager.addEventListener(merged.element, event, handler);
+            return () => {
+                dispose();
+            };
+        });
+    }
+}
+AXHotkeysService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXHotkeysService, deps: [{ token: i1.EventManager }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+AXHotkeysService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXHotkeysService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXHotkeysService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.EventManager }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/src/infinite-scroll.directive.mjs

@@ -0,0 +1,63 @@
+import { Directive, Input } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { exhaustMap, filter, map, pairwise, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+;
+const AX_DEFAULT_SCROLL_POSITION = {
+    scrollHeight: 0,
+    scrollTop: 0,
+    clientHeight: 0
+};
+export class AXInfiniteScrollerDirective {
+    constructor(elm) {
+        this.elm = elm;
+        this.scrollPercent = 70;
+        this.isUserScrollingDown = (positions) => {
+            return positions[0].sT < positions[1].sT;
+        };
+        this.isScrollExpectedPercent = (position) => {
+            return ((position.sT + position.cH) / position.sH) > (this.scrollPercent / 100);
+        };
+    }
+    ngAfterViewInit() {
+        this.registerScrollEvent();
+        this.streamScrollEvents();
+        this.requestCallbackOnScroll();
+    }
+    registerScrollEvent() {
+        this.scrollEvent$ = fromEvent(this.elm.nativeElement, 'scroll');
+    }
+    streamScrollEvents() {
+        this.userScrolledDown$ = this.scrollEvent$
+            .pipe(map((e) => ({
+            scrollHeight: e.target.scrollHeight,
+            scrollTop: e.target.scrollTop,
+            clientHeight: e.target.clientHeight
+        })), pairwise(), filter(positions => this.isUserScrollingDown(positions) && this.isScrollExpectedPercent(positions[1])));
+    }
+    requestCallbackOnScroll() {
+        this.requestOnScroll$ = this.userScrolledDown$;
+        if (this.immediateCallback) {
+            this.requestOnScroll$ = this.requestOnScroll$.pipe(startWith([AX_DEFAULT_SCROLL_POSITION, AX_DEFAULT_SCROLL_POSITION]));
+        }
+        this.requestOnScroll$.pipe(exhaustMap(() => {
+            return this.scrollCallback();
+        }));
+        //.subscribe((data) => { console.log(data) }, (err) => console.log(err));
+    }
+}
+AXInfiniteScrollerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXInfiniteScrollerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AXInfiniteScrollerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.2", type: AXInfiniteScrollerDirective, selector: "[axInfiniteScroller]", inputs: { scrollCallback: "scrollCallback", immediateCallback: "immediateCallback", scrollPercent: "scrollPercent" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXInfiniteScrollerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[axInfiniteScroller]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { scrollCallback: [{
+                type: Input
+            }], immediateCallback: [{
+                type: Input
+            }], scrollPercent: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL2NvbW1vbi9zcmMvaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUE2QixLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDNUUsT0FBTyxFQUFFLFNBQVMsRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUM3QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQU83RSxDQUFDO0FBRUYsTUFBTSwwQkFBMEIsR0FBcUI7SUFDakQsWUFBWSxFQUFFLENBQUM7SUFDZixTQUFTLEVBQUUsQ0FBQztJQUNaLFlBQVksRUFBRSxDQUFDO0NBQ2xCLENBQUM7QUFLRixNQUFNLE9BQU8sMkJBQTJCO0lBa0JwQyxZQUFvQixHQUFlO1FBQWYsUUFBRyxHQUFILEdBQUcsQ0FBWTtRQUZuQyxrQkFBYSxHQUFHLEVBQUUsQ0FBQztRQWtEWCx3QkFBbUIsR0FBRyxDQUFDLFNBQVMsRUFBRSxFQUFFO1lBQ3hDLE9BQU8sU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzdDLENBQUMsQ0FBQTtRQUVPLDRCQUF1QixHQUFHLENBQUMsUUFBUSxFQUFFLEVBQUU7WUFDM0MsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsR0FBRyxRQUFRLENBQUMsRUFBRSxDQUFDLEdBQUcsUUFBUSxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxHQUFHLENBQUMsQ0FBQztRQUNwRixDQUFDLENBQUE7SUF0RHNDLENBQUM7SUFFeEMsZUFBZTtRQUVYLElBQUksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1FBRTNCLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBRTFCLElBQUksQ0FBQyx1QkFBdUIsRUFBRSxDQUFDO0lBRW5DLENBQUM7SUFFTyxtQkFBbUI7UUFFdkIsSUFBSSxDQUFDLFlBQVksR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFFcEUsQ0FBQztJQUVPLGtCQUFrQjtRQUN0QixJQUFJLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLFlBQVk7YUFDckMsSUFBSSxDQUNELEdBQUcsQ0FBQyxDQUFDLENBQU0sRUFBb0IsRUFBRSxDQUFDLENBQUM7WUFDL0IsWUFBWSxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsWUFBWTtZQUNuQyxTQUFTLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTO1lBQzdCLFlBQVksRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLFlBQVk7U0FDdEMsQ0FBQyxDQUFDLEVBQ0gsUUFBUSxFQUFFLEVBQ1YsTUFBTSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksQ0FBQyx1QkFBdUIsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUN6RyxDQUFDO0lBQ1YsQ0FBQztJQUVPLHVCQUF1QjtRQUMzQixJQUFJLENBQUMsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDO1FBRS9DLElBQUksSUFBSSxDQUFDLGlCQUFpQixFQUFFO1lBQ3hCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUM5QyxTQUFTLENBQUMsQ0FBQywwQkFBMEIsRUFBRSwwQkFBMEIsQ0FBQyxDQUFDLENBQ3RFLENBQUM7U0FDTDtRQUVELElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQ3RCLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDWixPQUFPLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUNqQyxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ0gseUVBQXlFO0lBRWpGLENBQUM7O3dIQWhFUSwyQkFBMkI7NEdBQTNCLDJCQUEyQjsyRkFBM0IsMkJBQTJCO2tCQUh2QyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxzQkFBc0I7aUJBQ25DO2lHQVdHLGNBQWM7c0JBRGIsS0FBSztnQkFJTixpQkFBaUI7c0JBRGhCLEtBQUs7Z0JBSU4sYUFBYTtzQkFEWixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBBZnRlclZpZXdJbml0LCBFbGVtZW50UmVmLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBmcm9tRXZlbnQsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgZXhoYXVzdE1hcCwgZmlsdGVyLCBtYXAsIHBhaXJ3aXNlLCBzdGFydFdpdGggfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcblxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBBWFNjcm9sbFBvc2l0aW9uIHtcclxuICAgIHNjcm9sbEhlaWdodDogbnVtYmVyO1xyXG4gICAgc2Nyb2xsVG9wOiBudW1iZXI7XHJcbiAgICBjbGllbnRIZWlnaHQ6IG51bWJlcjtcclxufTtcclxuXHJcbmNvbnN0IEFYX0RFRkFVTFRfU0NST0xMX1BPU0lUSU9OOiBBWFNjcm9sbFBvc2l0aW9uID0ge1xyXG4gICAgc2Nyb2xsSGVpZ2h0OiAwLFxyXG4gICAgc2Nyb2xsVG9wOiAwLFxyXG4gICAgY2xpZW50SGVpZ2h0OiAwXHJcbn07XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICAgIHNlbGVjdG9yOiAnW2F4SW5maW5pdGVTY3JvbGxlcl0nXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBWEluZmluaXRlU2Nyb2xsZXJEaXJlY3RpdmUgaW1wbGVtZW50cyBBZnRlclZpZXdJbml0IHtcclxuXHJcbiAgICBwcml2YXRlIHNjcm9sbEV2ZW50JDogT2JzZXJ2YWJsZTxhbnk+O1xyXG5cclxuICAgIHByaXZhdGUgdXNlclNjcm9sbGVkRG93biQ6IE9ic2VydmFibGU8YW55PjtcclxuXHJcblxyXG4gICAgcHJpdmF0ZSByZXF1ZXN0T25TY3JvbGwkOiBPYnNlcnZhYmxlPGFueT47XHJcblxyXG4gICAgQElucHV0KClcclxuICAgIHNjcm9sbENhbGxiYWNrOiBGdW5jdGlvbjtcclxuXHJcbiAgICBASW5wdXQoKVxyXG4gICAgaW1tZWRpYXRlQ2FsbGJhY2s7XHJcblxyXG4gICAgQElucHV0KClcclxuICAgIHNjcm9sbFBlcmNlbnQgPSA3MDtcclxuXHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGVsbTogRWxlbWVudFJlZikgeyB9XHJcblxyXG4gICAgbmdBZnRlclZpZXdJbml0KCkge1xyXG5cclxuICAgICAgICB0aGlzLnJlZ2lzdGVyU2Nyb2xsRXZlbnQoKTtcclxuXHJcbiAgICAgICAgdGhpcy5zdHJlYW1TY3JvbGxFdmVudHMoKTtcclxuXHJcbiAgICAgICAgdGhpcy5yZXF1ZXN0Q2FsbGJhY2tPblNjcm9sbCgpO1xyXG5cclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIHJlZ2lzdGVyU2Nyb2xsRXZlbnQoKSB7XHJcblxyXG4gICAgICAgIHRoaXMuc2Nyb2xsRXZlbnQkID0gZnJvbUV2ZW50KHRoaXMuZWxtLm5hdGl2ZUVsZW1lbnQsICdzY3JvbGwnKTtcclxuXHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBzdHJlYW1TY3JvbGxFdmVudHMoKSB7XHJcbiAgICAgICAgdGhpcy51c2VyU2Nyb2xsZWREb3duJCA9IHRoaXMuc2Nyb2xsRXZlbnQkXHJcbiAgICAgICAgICAgIC5waXBlKFxyXG4gICAgICAgICAgICAgICAgbWFwKChlOiBhbnkpOiBBWFNjcm9sbFBvc2l0aW9uID0+ICh7XHJcbiAgICAgICAgICAgICAgICAgICAgc2Nyb2xsSGVpZ2h0OiBlLnRhcmdldC5zY3JvbGxIZWlnaHQsXHJcbiAgICAgICAgICAgICAgICAgICAgc2Nyb2xsVG9wOiBlLnRhcmdldC5zY3JvbGxUb3AsXHJcbiAgICAgICAgICAgICAgICAgICAgY2xpZW50SGVpZ2h0OiBlLnRhcmdldC5jbGllbnRIZWlnaHRcclxuICAgICAgICAgICAgICAgIH0pKSxcclxuICAgICAgICAgICAgICAgIHBhaXJ3aXNlKCksXHJcbiAgICAgICAgICAgICAgICBmaWx0ZXIocG9zaXRpb25zID0+IHRoaXMuaXNVc2VyU2Nyb2xsaW5nRG93bihwb3NpdGlvbnMpICYmIHRoaXMuaXNTY3JvbGxFeHBlY3RlZFBlcmNlbnQocG9zaXRpb25zWzFdKSlcclxuICAgICAgICAgICAgKTtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIHJlcXVlc3RDYWxsYmFja09uU2Nyb2xsKCkge1xyXG4gICAgICAgIHRoaXMucmVxdWVzdE9uU2Nyb2xsJCA9IHRoaXMudXNlclNjcm9sbGVkRG93biQ7XHJcblxyXG4gICAgICAgIGlmICh0aGlzLmltbWVkaWF0ZUNhbGxiYWNrKSB7XHJcbiAgICAgICAgICAgIHRoaXMucmVxdWVzdE9uU2Nyb2xsJCA9IHRoaXMucmVxdWVzdE9uU2Nyb2xsJC5waXBlKFxyXG4gICAgICAgICAgICAgICAgc3RhcnRXaXRoKFtBWF9ERUZBVUxUX1NDUk9MTF9QT1NJVElPTiwgQVhfREVGQVVMVF9TQ1JPTExfUE9TSVRJT05dKVxyXG4gICAgICAgICAgICApO1xyXG4gICAgICAgIH1cclxuXHJcbiAgICAgICAgdGhpcy5yZXF1ZXN0T25TY3JvbGwkLnBpcGUoXHJcbiAgICAgICAgICAgIGV4aGF1c3RNYXAoKCkgPT4ge1xyXG4gICAgICAgICAgICAgICAgcmV0dXJuIHRoaXMuc2Nyb2xsQ2FsbGJhY2soKTtcclxuICAgICAgICAgICAgfSkpXHJcbiAgICAgICAgICAgIC8vLnN1YnNjcmliZSgoZGF0YSkgPT4geyBjb25zb2xlLmxvZyhkYXRhKSB9LCAoZXJyKSA9PiBjb25zb2xlLmxvZyhlcnIpKTtcclxuXHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBpc1VzZXJTY3JvbGxpbmdEb3duID0gKHBvc2l0aW9ucykgPT4ge1xyXG4gICAgICAgIHJldHVybiBwb3NpdGlvbnNbMF0uc1QgPCBwb3NpdGlvbnNbMV0uc1Q7XHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBpc1Njcm9sbEV4cGVjdGVkUGVyY2VudCA9IChwb3NpdGlvbikgPT4ge1xyXG4gICAgICAgIHJldHVybiAoKHBvc2l0aW9uLnNUICsgcG9zaXRpb24uY0gpIC8gcG9zaXRpb24uc0gpID4gKHRoaXMuc2Nyb2xsUGVyY2VudCAvIDEwMCk7XHJcbiAgICB9XHJcblxyXG59Il19

package/esm2020/common/src/overlay.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable, TemplateRef } from '@angular/core';
+import { TemplatePortal, ComponentPortal } from '@angular/cdk/portal';
+import { merge } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./custom-cdk-overlay.service";
+import * as i2 from "@angular/cdk/overlay";
+export class AXOverlayService {
+    constructor(overlayService, overlayService2, appRef) {
+        this.overlayService = overlayService;
+        this.overlayService2 = overlayService2;
+        this.appRef = appRef;
+    }
+    show(content, context, configs) {
+        configs = Object.assign({
+            hasBackdrop: true,
+            transparentBackdrop: true,
+            closeOnClickOutside: true
+        }, configs || {});
+        // get root viewref
+        const viewRef = this.appRef.components[0].instance.viewRef;
+        let portal;
+        // get component by route
+        if (typeof content === 'string') {
+            // TODO
+        }
+        // create portal from component
+        else if (content instanceof TemplateRef) {
+            portal = new TemplatePortal(content, viewRef, context);
+        }
+        else if (typeof content === 'function') {
+            portal = new ComponentPortal(content, viewRef);
+        }
+        let positionStrategy;
+        if (configs.position && configs.targetElement) {
+            positionStrategy = this.overlayService.position()
+                .flexibleConnectedTo(configs.targetElement)
+                .withPositions(Array.isArray(configs.position) ? configs.position : [configs.position])
+                .withPush(true);
+        }
+        else {
+            positionStrategy = this.overlayService.position().global().centerHorizontally().centerVertically();
+        }
+        let scrollStrategy = this.overlayService.scrollStrategies.reposition({ autoClose: true });
+        if (configs.scroll === 'block') {
+            scrollStrategy = this.overlayService.scrollStrategies.block();
+        }
+        if (configs.scroll === 'close') {
+            scrollStrategy = this.overlayService.scrollStrategies.close();
+        }
+        const config = {
+            positionStrategy,
+            scrollStrategy,
+            hasBackdrop: configs.hasBackdrop,
+            disposeOnNavigation: true,
+            backdropClass: configs.backdropClass ? configs.backdropClass : (configs.transparentBackdrop ? 'cdk-overlay-transparent-backdrop' : undefined),
+            panelClass: configs.panelClass ? configs.panelClass : ['ax-animate-animated', 'ax-animate-zoomIn', 'ax-animate-faster']
+        };
+        // joon nanat dorost sho
+        let overlayRef = configs.containerElement ? this.overlayService.createOn(configs.containerElement, config) : this.overlayService2.create(config);
+        const host = overlayRef.attach(portal);
+        if (host.instance) {
+            Object.assign(host.instance, context);
+            setTimeout(() => {
+                host.changeDetectorRef.detectChanges();
+            }, 0);
+        }
+        if (configs.closeOnClickOutside) {
+            merge(overlayRef.backdropClick(), overlayRef.detachments()).subscribe(() => {
+                overlayRef.dispose();
+                overlayRef = undefined;
+                if (configs.onBackdropClick) {
+                    configs.onBackdropClick();
+                }
+            });
+        }
+        return {
+            instance: host.instance,
+            dispose: overlayRef.dispose.bind(overlayRef),
+            isOpen: () => {
+                return overlayRef.hasAttached();
+            }
+        };
+    }
+}
+AXOverlayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXOverlayService, deps: [{ token: i1.DynamicOverlay }, { token: i2.Overlay }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable });
+AXOverlayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXOverlayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXOverlayService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicOverlay }, { type: i2.Overlay }, { type: i0.ApplicationRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.service.js","sourceRoot":"","sources":["../../../../../../projects/acorex/components/common/src/overlay.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ApplicationRef, ViewContainerRef, TemplateRef } from '@angular/core';\r\nimport { Overlay, PositionStrategy, ScrollStrategy } from '@angular/cdk/overlay';\r\nimport { TemplatePortal, Portal, ComponentPortal } from '@angular/cdk/portal';\r\nimport { AXConnectedPosition } from './drawing.class';\r\nimport { merge } from 'rxjs';\r\nimport { DynamicOverlay } from './custom-cdk-overlay.service';\r\n\r\nexport interface AXOverlayViewRef {\r\n    instance: any;\r\n    dispose: () => void;\r\n    isOpen: () => boolean;\r\n}\r\n\r\nexport interface AXOverlayConfigs {\r\n    position?: AXConnectedPosition | AXConnectedPosition[];\r\n    hasBackdrop?: boolean;\r\n    transparentBackdrop?: boolean;\r\n    closeOnClickOutside?: boolean;\r\n    targetElement?: HTMLElement;\r\n    containerElement?: HTMLElement;\r\n    onBackdropClick?: () => void;\r\n    panelClass?: string[] | string;\r\n    backdropClass?: string[] | string;\r\n    scroll?: 'auto' | 'block' | 'close';\r\n}\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class AXOverlayService {\r\n    constructor(\r\n        private overlayService: DynamicOverlay,\r\n        private overlayService2: Overlay,\r\n        private appRef: ApplicationRef) {\r\n\r\n    }\r\n\r\n    show(content: any, context?: any, configs?: AXOverlayConfigs): AXOverlayViewRef {\r\n        configs = Object.assign({\r\n            hasBackdrop: true,\r\n            transparentBackdrop: true,\r\n            closeOnClickOutside: true\r\n        }, configs || {});\r\n        // get root viewref\r\n        const viewRef: ViewContainerRef = this.appRef.components[0].instance.viewRef;\r\n\r\n        let portal: Portal<any>;\r\n        // get component by route\r\n        if (typeof content === 'string') {\r\n            // TODO\r\n        }\r\n        // create portal from component\r\n        else if (content instanceof TemplateRef) {\r\n            portal = new TemplatePortal(content, viewRef, context);\r\n        }\r\n        else if (typeof content === 'function') {\r\n            portal = new ComponentPortal(content, viewRef);\r\n        }\r\n        let positionStrategy: PositionStrategy;\r\n        if (configs.position && configs.targetElement) {\r\n            positionStrategy = this.overlayService.position()\r\n                .flexibleConnectedTo(configs.targetElement)\r\n                .withPositions(\r\n                    Array.isArray(configs.position) ? configs.position : [configs.position]\r\n                )\r\n                .withPush(true);\r\n        }\r\n        else {\r\n            positionStrategy = this.overlayService.position().global().centerHorizontally().centerVertically();\r\n        }\r\n        let scrollStrategy: ScrollStrategy = this.overlayService.scrollStrategies.reposition({ autoClose: true });\r\n        if (configs.scroll === 'block') {\r\n            scrollStrategy = this.overlayService.scrollStrategies.block();\r\n        }\r\n        if (configs.scroll === 'close') {\r\n            scrollStrategy = this.overlayService.scrollStrategies.close();\r\n        }\r\n\r\n        const config = {\r\n            positionStrategy,\r\n            scrollStrategy,\r\n            hasBackdrop: configs.hasBackdrop,\r\n            disposeOnNavigation: true,\r\n            backdropClass: configs.backdropClass ? configs.backdropClass : (configs.transparentBackdrop ? 'cdk-overlay-transparent-backdrop' : undefined),\r\n            panelClass: configs.panelClass ? configs.panelClass : ['ax-animate-animated', 'ax-animate-zoomIn','ax-animate-faster']\r\n        };\r\n        // joon nanat dorost sho\r\n        let overlayRef:any = configs.containerElement ? this.overlayService.createOn(configs.containerElement, config) : this.overlayService2.create(config);\r\n\r\n        const host = overlayRef.attach(portal!);\r\n        if (host.instance) {\r\n            Object.assign(host.instance, context);\r\n            setTimeout(() => {\r\n                host.changeDetectorRef.detectChanges();\r\n            }, 0);\r\n        }\r\n        if (configs.closeOnClickOutside) {\r\n            merge(\r\n                overlayRef.backdropClick(),\r\n                overlayRef.detachments(),\r\n            ).subscribe(() => {\r\n                overlayRef.dispose();\r\n                overlayRef = undefined;\r\n                if (configs!.onBackdropClick) {\r\n                    configs!.onBackdropClick();\r\n                }\r\n            });\r\n\r\n        }\r\n        return {\r\n            instance: host.instance,\r\n            dispose: overlayRef.dispose.bind(overlayRef),\r\n            isOpen: () => {\r\n                return overlayRef.hasAttached();\r\n            }\r\n        };\r\n    }\r\n\r\n}"]}

package/esm2020/common/src/responsive.directive.mjs

@@ -0,0 +1,34 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXResponsiveDirective {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        this._observer = new ResizeObserver(entries => {
+            for (let entry of entries) {
+                if (entry.target) {
+                    const e = entry.target;
+                    const elements = [e, ...Array.from(e.querySelectorAll(`[class*='sm:']`))];
+                    elements.map(c => ({
+                        element: c,
+                        classList: Array.from(c.classList).filter(c => c.includes('sm')).map(c => c.slice(3))
+                    })).forEach(c => {
+                        e.clientWidth < 320 ? c.element.classList.add(...c.classList) : c.element.classList.remove(...c.classList);
+                    });
+                }
+            }
+        });
+        this._observer.observe(_elementRef.nativeElement);
+    }
+    ;
+    ngOnDestroy() {
+        this._observer.disconnect();
+        this._observer.unobserve(this._elementRef.nativeElement);
+    }
+}
+AXResponsiveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXResponsiveDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AXResponsiveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.2", type: AXResponsiveDirective, selector: "[ax-responsive]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXResponsiveDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ax-responsive]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/common/src/styles.class.mjs

@@ -0,0 +1,22 @@
+export const AX_STYLE_COLOR_TYPES = [
+    'primary',
+    'secondary',
+    'info',
+    'danger',
+    'success',
+    'warning',
+    'light',
+    'dark'
+];
+export const AX_LOCATIONS = [
+    'bottom-start',
+    'bottom-center',
+    'bottom-end',
+    'top-start',
+    'top-center',
+    'top-end',
+    'center-end',
+    'center-start'
+];
+export const AX_DIRECTIONS = ['vertical', 'horizontal'];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/context-menu/acorex-components-context-menu.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNvcmV4LWNvbXBvbmVudHMtY29udGV4dC1tZW51LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNvcmV4L2NvbXBvbmVudHMvY29udGV4dC1tZW51L2Fjb3JleC1jb21wb25lbnRzLWNvbnRleHQtbWVudS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/context-menu/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './src/context-menu.component';
+export * from './src/context-menu.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Fjb3JleC9jb21wb25lbnRzL2NvbnRleHQtbWVudS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL2NvbnRleHQtbWVudS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NyYy9jb250ZXh0LW1lbnUubW9kdWxlJztcclxuIl19

package/esm2020/context-menu/src/context-menu.component.mjs

@@ -0,0 +1,257 @@
+import { Component, ChangeDetectionStrategy, ViewEncapsulation, ElementRef, ViewChild, Input, } from '@angular/core';
+import { AXBaseComponent, AXBaseMenuMixin } from '@acorex/components/mixin';
+import { TemplatePortal } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@acorex/core/platform";
+import * as i3 from "@angular/common";
+import * as i4 from "@acorex/components/menu";
+/**
+ * The Button is a component which detects user interaction and triggers a corresponding event
+ *
+ * @category Components
+ */
+export class AXContextMenuComponent extends AXBaseMenuMixin {
+    constructor(_elementRef, cdr, _overlay, _viewContainerRef, _platform) {
+        super(_elementRef, cdr);
+        this._elementRef = _elementRef;
+        this.cdr = cdr;
+        this._overlay = _overlay;
+        this._viewContainerRef = _viewContainerRef;
+        this._platform = _platform;
+    }
+    get contextTemplate() {
+        return this._contextTemplate;
+    }
+    get target() {
+        return this._target;
+    }
+    set target(v) {
+        if (v instanceof HTMLElement)
+            this._target = v;
+        else if (v instanceof ElementRef)
+            this._target = v.nativeElement;
+        else if (v instanceof AXBaseComponent)
+            this._target = v._getInnerElement();
+    }
+    onInit() {
+        super.onInit();
+    }
+    ngAfterViewInit() {
+        super.onViewInit();
+        this._templatePortal = new TemplatePortal(this._contextTemplate ? this._contextTemplate : this._menuTmp, this._viewContainerRef);
+        this._target.addEventListener('contextmenu', (e) => {
+            e.preventDefault();
+            const position = {
+                getBoundingClientRect: () => ({
+                    bottom: e.clientY,
+                    height: 0,
+                    left: e.clientX,
+                    right: e.clientX,
+                    top: e.clientY,
+                    width: 0,
+                }),
+            };
+            this._openAsOverlay(new ElementRef(position));
+        });
+    }
+    _openAsOverlay(position) {
+        this._overlayRef = this._overlay.create({
+            positionStrategy: this._overlay
+                .position()
+                .flexibleConnectedTo(position)
+                .withPositions([
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'end',
+                    originY: 'center',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'end',
+                    originY: 'bottom',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'center',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'center',
+                },
+                {
+                    originX: 'end',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'bottom',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'center',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'bottom',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'center',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'center',
+                },
+                {
+                    originX: 'start',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'bottom',
+                },
+                {
+                    originX: 'center',
+                    originY: 'top',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'center',
+                    originY: 'center',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'center',
+                    originY: 'bottom',
+                    overlayX: 'start',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'center',
+                    originY: 'top',
+                    overlayX: 'center',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'center',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'top',
+                },
+                {
+                    originX: 'center',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'center',
+                },
+                {
+                    originX: 'center',
+                    originY: 'top',
+                    overlayX: 'end',
+                    overlayY: 'bottom',
+                },
+            ])
+                .withPush(false),
+            disposeOnNavigation: true,
+            panelClass: ['ax-animate-fadeIn', 'ax-animate-faster', 'ax-overlay-menu'],
+            maxHeight: 'unset',
+            hasBackdrop: false,
+            backdropClass: ['cdk-overlay-transparent-backdrop'],
+        });
+        this._overlayRef.attach(this._templatePortal);
+        this._overlayRef.outsidePointerEvents().subscribe(() => {
+            if (this._overlayRef && this.openMode === 'click') {
+                this.close();
+            }
+        });
+        this._platform.scroll.subscribe(() => {
+            if (this._overlayRef) {
+                this.close();
+            }
+        });
+        this._platform.resize.subscribe(() => {
+            if (this._overlayRef) {
+                this.close();
+            }
+        });
+    }
+    close() {
+        this._overlayRef.detach();
+        this.displayItems.forEach((element) => {
+            element.isOpen = false;
+            element.isActive = false;
+        });
+        this.cdr.detectChanges();
+    }
+    /***********defultTmp***********/
+    onContextMenuClick(e) {
+        this.onMenuItemClick.emit(e);
+    }
+}
+AXContextMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXContextMenuComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.AXPlatform }], target: i0.ɵɵFactoryTarget.Component });
+AXContextMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.2", type: AXContextMenuComponent, selector: "ax-context-menu", inputs: { disabled: "disabled", textField: "textField", valueField: "valueField", items: "items", parentId: "parentId", iconField: "iconField", isOpen: "isOpen", isActive: "isActive", visibleField: "visibleField", disableField: "disableField", hasChildField: "hasChildField", dividerField: "dividerField", openMode: "openMode", orientation: "orientation", target: "target" }, outputs: { onBlur: "onBlur", onFocus: "onFocus", onMenuItemClick: "onMenuItemClick" }, viewQueries: [{ propertyName: "_contextTemplate", first: true, predicate: ["contextTemplate"], descendants: true }, { propertyName: "_menuTmp", first: true, predicate: ["menuTmp"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<ng-template #contextTemplateRef>\r\n    <ng-container *ngIf=\"contextTemplate  else menuTmp\">\r\n        <div class=\"ax-context-menu\">\r\n            <ng-container *ngTemplateOutlet=\"contextTemplate\">\r\n            </ng-container>\r\n        </div>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n\r\n<ng-template #menuTmp>\r\n    <ax-menu class=\"ax-context-menu\" orientation=\"vertical\" openMode=\"hover\" [items]='items'\r\n        [disableField]=\"disableField\" [hasChildField]=\"hasChildField\" [textField]=\"textField\" [iconField]=\"iconField\"\r\n        [valueField]=\"valueField\" [dividerField]=\"dividerField\" (onMenuItemClick)='onContextMenuClick($event)'>\r\n    </ax-menu>\r\n</ng-template>", dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i4.AXMenuComponent, selector: "ax-menu", inputs: ["disabled", "tabIndex", "textField", "valueField", "items", "parentId", "iconField", "tooltip", "isOpen", "isActive", "visibleField", "disableField", "hasChildField", "dividerField", "openMode", "orientation", "showModal"], outputs: ["onBlur", "onFocus", "onMenuItemClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.2", ngImport: i0, type: AXContextMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ax-context-menu', inputs: [
+                        'disabled',
+                        'textField',
+                        'valueField',
+                        'items',
+                        'parentId',
+                        'iconField',
+                        'isOpen',
+                        'isActive',
+                        'visibleField',
+                        'disableField',
+                        'hasChildField',
+                        'dividerField',
+                        'openMode',
+                        'orientation',
+                    ], outputs: ['onBlur', 'onFocus', 'onMenuItemClick'], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<ng-template #contextTemplateRef>\r\n    <ng-container *ngIf=\"contextTemplate  else menuTmp\">\r\n        <div class=\"ax-context-menu\">\r\n            <ng-container *ngTemplateOutlet=\"contextTemplate\">\r\n            </ng-container>\r\n        </div>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n\r\n<ng-template #menuTmp>\r\n    <ax-menu class=\"ax-context-menu\" orientation=\"vertical\" openMode=\"hover\" [items]='items'\r\n        [disableField]=\"disableField\" [hasChildField]=\"hasChildField\" [textField]=\"textField\" [iconField]=\"iconField\"\r\n        [valueField]=\"valueField\" [dividerField]=\"dividerField\" (onMenuItemClick)='onContextMenuClick($event)'>\r\n    </ax-menu>\r\n</ng-template>" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.AXPlatform }]; }, propDecorators: { _contextTemplate: [{
+                type: ViewChild,
+                args: ['contextTemplate']
+            }], _menuTmp: [{
+                type: ViewChild,
+                args: ['menuTmp', { static: true }]
+            }], target: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-menu.component.js","sourceRoot":"","sources":["../../../../../../projects/acorex/components/context-menu/src/context-menu.component.ts","../../../../../../projects/acorex/components/context-menu/src/context-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["import { OverlayRef, Overlay } from '@angular/cdk/overlay';\r\n\r\nimport {\r\n  Component,\r\n  ChangeDetectionStrategy,\r\n  ViewEncapsulation,\r\n  OnInit,\r\n  TemplateRef,\r\n  ElementRef,\r\n  ChangeDetectorRef,\r\n  ViewContainerRef,\r\n  ViewChild,\r\n  Input,\r\n} from '@angular/core';\r\nimport { AXBaseComponent, AXBaseMenuMixin } from '@acorex/components/mixin';\r\nimport { TemplatePortal } from '@angular/cdk/portal';\r\nimport { AXPlatform } from '@acorex/core/platform';\r\n\r\n/**\r\n * The Button is a component which detects user interaction and triggers a corresponding event\r\n *\r\n * @category Components\r\n */\r\n@Component({\r\n  selector: 'ax-context-menu',\r\n  templateUrl: './context-menu.component.html',\r\n  inputs: [\r\n    'disabled',\r\n    'textField',\r\n    'valueField',\r\n    'items',\r\n    'parentId',\r\n    'iconField',\r\n    'isOpen',\r\n    'isActive',\r\n    'visibleField',\r\n    'disableField',\r\n    'hasChildField',\r\n    'dividerField',\r\n    'openMode',\r\n    'orientation',\r\n  ],\r\n  outputs: ['onBlur', 'onFocus', 'onMenuItemClick'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class AXContextMenuComponent extends AXBaseMenuMixin implements OnInit {\r\n  @ViewChild('contextTemplate')\r\n  _contextTemplate: TemplateRef<any>;\r\n\r\n  get contextTemplate(): TemplateRef<any> {\r\n    return this._contextTemplate;\r\n  }\r\n\r\n  @ViewChild('menuTmp', { static: true })\r\n  _menuTmp: TemplateRef<any>;\r\n\r\n  private _overlayRef: OverlayRef;\r\n\r\n  private _templatePortal: TemplatePortal;\r\n\r\n  private _target: HTMLElement;\r\n\r\n  @Input()\r\n  public get target(): HTMLElement {\r\n    return this._target;\r\n  }\r\n\r\n  public set target(v: HTMLElement | ElementRef | AXBaseComponent) {\r\n    if (v instanceof HTMLElement) this._target = v;\r\n    else if (v instanceof ElementRef) this._target = v.nativeElement;\r\n    else if (v instanceof AXBaseComponent) this._target = v._getInnerElement();\r\n  }\r\n\r\n  constructor(\r\n    private _elementRef: ElementRef,\r\n    private cdr: ChangeDetectorRef,\r\n    private _overlay: Overlay,\r\n    private _viewContainerRef: ViewContainerRef,\r\n    private _platform: AXPlatform\r\n  ) {\r\n    super(_elementRef, cdr);\r\n  }\r\n\r\n  onInit(): void {\r\n    super.onInit();\r\n  }\r\n\r\n  ngAfterViewInit(): void {\r\n    super.onViewInit();\r\n\r\n    this._templatePortal = new TemplatePortal(\r\n      this._contextTemplate ? this._contextTemplate : this._menuTmp,\r\n      this._viewContainerRef\r\n    );\r\n\r\n    this._target.addEventListener('contextmenu', (e) => {\r\n      e.preventDefault();\r\n      const position = {\r\n        getBoundingClientRect: () => ({\r\n          bottom: e.clientY,\r\n          height: 0,\r\n          left: e.clientX,\r\n          right: e.clientX,\r\n          top: e.clientY,\r\n          width: 0,\r\n        }),\r\n      };\r\n      this._openAsOverlay(new ElementRef(position));\r\n    });\r\n  }\r\n\r\n  private _openAsOverlay(position): void {\r\n    this._overlayRef = this._overlay.create({\r\n      positionStrategy: this._overlay\r\n        .position()\r\n        .flexibleConnectedTo(position)\r\n        .withPositions([\r\n          {\r\n            originX: 'end',\r\n            originY: 'top',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'center',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'bottom',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'top',\r\n            overlayX: 'center',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'center',\r\n          },\r\n          {\r\n            originX: 'end',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'bottom',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'top',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'center',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'bottom',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'top',\r\n            overlayX: 'center',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'center',\r\n          },\r\n          {\r\n            originX: 'start',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'bottom',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'top',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'center',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'bottom',\r\n            overlayX: 'start',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'top',\r\n            overlayX: 'center',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'top',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'center',\r\n          },\r\n          {\r\n            originX: 'center',\r\n            originY: 'top',\r\n            overlayX: 'end',\r\n            overlayY: 'bottom',\r\n          },\r\n        ])\r\n        .withPush(false),\r\n      disposeOnNavigation: true,\r\n      panelClass: ['ax-animate-fadeIn', 'ax-animate-faster', 'ax-overlay-menu'],\r\n      maxHeight: 'unset',\r\n      hasBackdrop: false,\r\n      backdropClass: ['cdk-overlay-transparent-backdrop'],\r\n    });\r\n    this._overlayRef.attach(this._templatePortal);\r\n    this._overlayRef.outsidePointerEvents().subscribe(() => {\r\n      if (this._overlayRef && this.openMode === 'click') {\r\n        this.close();\r\n      }\r\n    });\r\n\r\n    this._platform.scroll.subscribe(() => {\r\n      if (this._overlayRef) {\r\n        this.close();\r\n      }\r\n    });\r\n\r\n    this._platform.resize.subscribe(() => {\r\n      if (this._overlayRef) {\r\n        this.close();\r\n      }\r\n    });\r\n  }\r\n\r\n  private close() {\r\n    this._overlayRef.detach();\r\n    this.displayItems.forEach((element) => {\r\n      element.isOpen = false;\r\n      element.isActive = false;\r\n    });\r\n    this.cdr.detectChanges();\r\n  }\r\n\r\n  /***********defultTmp***********/\r\n  onContextMenuClick(e) {\r\n    this.onMenuItemClick.emit(e);\r\n  }\r\n}\r\n","<ng-template #contextTemplateRef>\r\n    <ng-container *ngIf=\"contextTemplate  else menuTmp\">\r\n        <div class=\"ax-context-menu\">\r\n            <ng-container *ngTemplateOutlet=\"contextTemplate\">\r\n            </ng-container>\r\n        </div>\r\n    </ng-container>\r\n</ng-template>\r\n\r\n\r\n<ng-template #menuTmp>\r\n    <ax-menu class=\"ax-context-menu\" orientation=\"vertical\" openMode=\"hover\" [items]='items'\r\n        [disableField]=\"disableField\" [hasChildField]=\"hasChildField\" [textField]=\"textField\" [iconField]=\"iconField\"\r\n        [valueField]=\"valueField\" [dividerField]=\"dividerField\" (onMenuItemClick)='onContextMenuClick($event)'>\r\n    </ax-menu>\r\n</ng-template>"]}