@ptsecurity/mosaic 12.3.0 → 13.1.1

package/esm2020/core/option/option.mjs

@@ -0,0 +1,254 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Inject, InjectionToken, Input, Optional, Output, ViewEncapsulation } from '@angular/core';
+import { ENTER, SPACE } from '@ptsecurity/cdk/keycodes';
+import { Subject } from 'rxjs';
+import { McOptgroup } from './optgroup';
+import * as i0 from "@angular/core";
+import * as i1 from "./optgroup";
+import * as i2 from "../selection/pseudo-checkbox/pseudo-checkbox";
+import * as i3 from "@angular/common";
+/**
+ * Option IDs need to be unique across components, so this counter exists outside of
+ * the component definition.
+ */
+let uniqueIdCounter = 0;
+/** Event object emitted by McOption when selected or deselected. */
+export class McOptionSelectionChange {
+    constructor(source, isUserInput = false) {
+        this.source = source;
+        this.isUserInput = isUserInput;
+    }
+}
+/**
+ * Injection token used to provide the parent component to options.
+ */
+export const MC_OPTION_PARENT_COMPONENT = new InjectionToken('MC_OPTION_PARENT_COMPONENT');
+/**
+ * Single option inside of a `<mc-select>` element.
+ */
+export class McOption {
+    constructor(element, changeDetectorRef, parent, group) {
+        this.element = element;
+        this.changeDetectorRef = changeDetectorRef;
+        this.parent = parent;
+        this.group = group;
+        /** Event emitted when the option is selected or deselected. */
+        // tslint:disable-next-line:no-output-on-prefix
+        this.onSelectionChange = new EventEmitter();
+        /** Emits when the state of the option changes and any parents have to be notified. */
+        this.stateChanges = new Subject();
+        this._id = `mc-option-${uniqueIdCounter++}`;
+        this._selected = false;
+        this._disabled = false;
+        this._active = false;
+        this.mostRecentViewValue = '';
+    }
+    get showCheckbox() {
+        return this._showCheckbox === undefined ? this.multiple : this._showCheckbox;
+    }
+    set showCheckbox(value) {
+        this._showCheckbox = coerceBooleanProperty(value);
+    }
+    /**
+     * The displayed value of the option. It is necessary to show the selected option in the
+     * select's trigger.
+     */
+    get viewValue() {
+        // TODO: Add input property alternative for node envs.
+        return (this.getHostElement().textContent || '').trim();
+    }
+    /** Whether the wrapping component is in multiple selection mode. */
+    get multiple() {
+        return this.parent && this.parent.multiple;
+    }
+    get id() {
+        return this._id;
+    }
+    get selected() {
+        return this._selected;
+    }
+    get disabled() {
+        return (this.group && this.group.disabled) || this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    /**
+     * Whether or not the option is currently active and ready to be selected.
+     * An active option displays styles as if it is focused, but the
+     * focus is actually retained somewhere else. This comes in handy
+     * for components like autocomplete where focus must remain on the input.
+     */
+    get active() {
+        return this._active;
+    }
+    ngAfterViewChecked() {
+        // Since parent components could be using the option's label to display the selected values
+        // (e.g. `mc-select`) and they don't have a way of knowing if the option's label has changed
+        // we have to check for changes in the DOM ourselves and dispatch an event. These checks are
+        // relatively cheap, however we still limit them only to selected options in order to avoid
+        // hitting the DOM too often.
+        if (this._selected) {
+            const viewValue = this.viewValue;
+            if (viewValue !== this.mostRecentViewValue) {
+                this.mostRecentViewValue = viewValue;
+                this.stateChanges.next();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    getHeight() {
+        // tslint:disable-next-line:naming-convention
+        const DOMRect = this.element.nativeElement.getClientRects()[0];
+        return DOMRect ? DOMRect.height : 0;
+    }
+    select() {
+        if (!this._selected) {
+            this._selected = true;
+            this.changeDetectorRef.markForCheck();
+            this.emitSelectionChangeEvent();
+        }
+    }
+    deselect() {
+        if (this._selected) {
+            this._selected = false;
+            this.changeDetectorRef.markForCheck();
+            this.emitSelectionChangeEvent();
+        }
+    }
+    focus() {
+        const element = this.getHostElement();
+        if (typeof element.focus === 'function') {
+            element.focus();
+        }
+    }
+    /**
+     * This method sets display styles on the option to make it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setActiveStyles() {
+        if (!this._active) {
+            this._active = true;
+            this.changeDetectorRef.markForCheck();
+        }
+    }
+    /**
+     * This method removes display styles on the option that made it appear
+     * active. This is used by the ActiveDescendantKeyManager so key
+     * events will display the proper options as active on arrow key events.
+     */
+    setInactiveStyles() {
+        if (this._active) {
+            this._active = false;
+            this.changeDetectorRef.markForCheck();
+        }
+    }
+    /** Gets the label to be used when determining whether the option should be focused. */
+    getLabel() {
+        return this.viewValue;
+    }
+    /** Ensures the option is selected when activated from the keyboard. */
+    handleKeydown(event) {
+        // tslint:disable-next-line
+        if (event.keyCode === ENTER || event.keyCode === SPACE) {
+            this.selectViaInteraction();
+            // Prevent the page from scrolling down and form submits.
+            event.preventDefault();
+        }
+    }
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     */
+    selectViaInteraction() {
+        if (!this.disabled) {
+            this._selected = this.multiple ? !this._selected : true;
+            this.changeDetectorRef.markForCheck();
+            this.emitSelectionChangeEvent(true);
+        }
+    }
+    getTabIndex() {
+        return this.disabled ? '-1' : '0';
+    }
+    getHostElement() {
+        return this.element.nativeElement;
+    }
+    /** Emits the selection change event. */
+    emitSelectionChangeEvent(isUserInput = false) {
+        this.onSelectionChange.emit(new McOptionSelectionChange(this, isUserInput));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ McOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: McOption, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: MC_OPTION_PARENT_COMPONENT, optional: true }, { token: i1.McOptgroup, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ McOption.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: McOption, selector: "mc-option", inputs: { value: "value", showCheckbox: "showCheckbox", disabled: "disabled" }, outputs: { onSelectionChange: "onSelectionChange" }, host: { listeners: { "click": "selectViaInteraction()", "keydown": "handleKeydown($event)" }, properties: { "attr.tabindex": "getTabIndex()", "class.mc-selected": "selected", "class.mc-option-multiple": "multiple", "class.mc-active": "active", "class.mc-disabled": "disabled", "id": "id" }, classAttribute: "mc-option" }, exportAs: ["mcOption"], ngImport: i0, template: "<mc-pseudo-checkbox\n    *ngIf=\"showCheckbox\"\n    [state]=\"selected ? 'checked' : 'unchecked'\"\n    [disabled]=\"disabled\">\n</mc-pseudo-checkbox>\n\n<span class=\"mc-option-text\"><ng-content></ng-content></span>\n\n<div class=\"mc-option-overlay\"></div>\n", styles: [".mc-option{display:flex;flex-direction:row;align-items:center;box-sizing:border-box;position:relative;max-width:100%;height:var(--mc-option-size-height, 32px);border:var(--mc-option-size-border-width, 2px) solid transparent;cursor:pointer;outline:none;padding-left:var(--mc-option-size-horizontal-padding, 16px);padding-right:var(--mc-option-size-horizontal-padding, 16px);-webkit-tap-highlight-color:transparent}.mc-option.mc-disabled{cursor:default}.mc-option .mc-pseudo-checkbox{margin-right:8px}.mc-option .mc-option-overlay{position:absolute;top:calc(-1 * var(--mc-option-size-border-width, 2px));left:calc(-1 * var(--mc-option-size-border-width, 2px));right:calc(-1 * var(--mc-option-size-border-width, 2px));bottom:calc(-1 * var(--mc-option-size-border-width, 2px));pointer-events:none;border-radius:inherit}.mc-option-text{display:inline-block;flex-grow:1;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}\n"], components: [{ type: i2.McPseudoCheckbox, selector: "mc-pseudo-checkbox", inputs: ["state", "disabled"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: McOption, decorators: [{
+            type: Component,
+            args: [{ selector: 'mc-option', exportAs: 'mcOption', host: {
+                        '[attr.tabindex]': 'getTabIndex()',
+                        class: 'mc-option',
+                        '[class.mc-selected]': 'selected',
+                        '[class.mc-option-multiple]': 'multiple',
+                        '[class.mc-active]': 'active',
+                        '[class.mc-disabled]': 'disabled',
+                        '[id]': 'id',
+                        '(click)': 'selectViaInteraction()',
+                        '(keydown)': 'handleKeydown($event)'
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<mc-pseudo-checkbox\n    *ngIf=\"showCheckbox\"\n    [state]=\"selected ? 'checked' : 'unchecked'\"\n    [disabled]=\"disabled\">\n</mc-pseudo-checkbox>\n\n<span class=\"mc-option-text\"><ng-content></ng-content></span>\n\n<div class=\"mc-option-overlay\"></div>\n", styles: [".mc-option{display:flex;flex-direction:row;align-items:center;box-sizing:border-box;position:relative;max-width:100%;height:var(--mc-option-size-height, 32px);border:var(--mc-option-size-border-width, 2px) solid transparent;cursor:pointer;outline:none;padding-left:var(--mc-option-size-horizontal-padding, 16px);padding-right:var(--mc-option-size-horizontal-padding, 16px);-webkit-tap-highlight-color:transparent}.mc-option.mc-disabled{cursor:default}.mc-option .mc-pseudo-checkbox{margin-right:8px}.mc-option .mc-option-overlay{position:absolute;top:calc(-1 * var(--mc-option-size-border-width, 2px));left:calc(-1 * var(--mc-option-size-border-width, 2px));right:calc(-1 * var(--mc-option-size-border-width, 2px));bottom:calc(-1 * var(--mc-option-size-border-width, 2px));pointer-events:none;border-radius:inherit}.mc-option-text{display:inline-block;flex-grow:1;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MC_OPTION_PARENT_COMPONENT]
+                }] }, { type: i1.McOptgroup, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { value: [{
+                type: Input
+            }], showCheckbox: [{
+                type: Input
+            }], onSelectionChange: [{
+                type: Output
+            }], disabled: [{
+                type: Input
+            }] } });
+/**
+ * Counts the amount of option group labels that precede the specified option.
+ * @param optionIndex Index of the option at which to start counting.
+ * @param options Flat list of all of the options.
+ * @param optionGroups Flat list of all of the option groups.
+ * @docs-private
+ */
+export function countGroupLabelsBeforeOption(optionIndex, options, optionGroups) {
+    if (optionGroups.length) {
+        const optionsArray = options.toArray();
+        const groups = optionGroups.toArray();
+        let groupCounter = 0;
+        for (let i = 0; i < optionIndex + 1; i++) {
+            if (optionsArray[i].group && optionsArray[i].group === groups[groupCounter]) {
+                groupCounter++;
+            }
+        }
+        return groupCounter;
+    }
+    return 0;
+}
+/**
+ * Determines the position to which to scroll a panel in order for an option to be into view.
+ * @param optionIndex Index of the option to be scrolled into the view.
+ * @param optionHeight Height of the options.
+ * @param currentScrollPosition Current scroll position of the panel.
+ * @param panelHeight Height of the panel.
+ * @docs-private
+ */
+export function getOptionScrollPosition(optionIndex, optionHeight, currentScrollPosition, panelHeight) {
+    const optionOffset = optionIndex * optionHeight;
+    if (optionOffset < currentScrollPosition) {
+        return optionOffset;
+    }
+    if (optionOffset + optionHeight > currentScrollPosition + panelHeight) {
+        return Math.max(0, optionOffset - panelHeight + optionHeight);
+    }
+    return currentScrollPosition;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option.js","sourceRoot":"","sources":["../../../../../packages/mosaic/core/option/option.ts","../../../../../packages/mosaic/core/option/option.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n    AfterViewChecked,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    EventEmitter,\n    Inject,\n    InjectionToken,\n    Input,\n    OnDestroy,\n    Optional,\n    Output,\n    QueryList,\n    ViewEncapsulation\n} from '@angular/core';\nimport { ENTER, SPACE } from '@ptsecurity/cdk/keycodes';\nimport { Subject } from 'rxjs';\n\nimport { McOptgroup } from './optgroup';\n\n\n/**\n * Option IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n */\nlet uniqueIdCounter = 0;\n\n/** Event object emitted by McOption when selected or deselected. */\nexport class McOptionSelectionChange {\n    constructor(public source: McOption, public isUserInput = false) {}\n}\n\n/**\n * Describes a parent component that manages a list of options.\n * Contains properties that the options can inherit.\n * @docs-private\n */\n// tslint:disable-next-line: naming-convention\nexport interface McOptionParentComponent {\n    multiple?: boolean;\n}\n\n/**\n * Injection token used to provide the parent component to options.\n */\nexport const MC_OPTION_PARENT_COMPONENT =\n    new InjectionToken<McOptionParentComponent>('MC_OPTION_PARENT_COMPONENT');\n\n/**\n * Single option inside of a `<mc-select>` element.\n */\n@Component({\n    selector: 'mc-option',\n    exportAs: 'mcOption',\n    host: {\n        '[attr.tabindex]': 'getTabIndex()',\n        class: 'mc-option',\n        '[class.mc-selected]': 'selected',\n        '[class.mc-option-multiple]': 'multiple',\n        '[class.mc-active]': 'active',\n        '[class.mc-disabled]': 'disabled',\n        '[id]': 'id',\n\n        '(click)': 'selectViaInteraction()',\n        '(keydown)': 'handleKeydown($event)'\n    },\n    styleUrls: ['option.scss'],\n    templateUrl: 'option.html',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class McOption implements AfterViewChecked, OnDestroy {\n    /** The form value of the option. */\n    @Input() value: any;\n\n    @Input()\n    get showCheckbox() {\n        return this._showCheckbox === undefined ? this.multiple : this._showCheckbox;\n    }\n\n    set showCheckbox(value) {\n        this._showCheckbox = coerceBooleanProperty(value);\n    }\n\n    private _showCheckbox: boolean;\n\n    /** Event emitted when the option is selected or deselected. */\n    // tslint:disable-next-line:no-output-on-prefix\n    @Output() readonly onSelectionChange = new EventEmitter<McOptionSelectionChange>();\n\n    /** Emits when the state of the option changes and any parents have to be notified. */\n    readonly stateChanges = new Subject<void>();\n\n    /**\n     * The displayed value of the option. It is necessary to show the selected option in the\n     * select's trigger.\n     */\n    get viewValue(): string {\n        // TODO: Add input property alternative for node envs.\n        return (this.getHostElement().textContent || '').trim();\n    }\n\n    /** Whether the wrapping component is in multiple selection mode. */\n    get multiple() {\n        return this.parent && this.parent.multiple;\n    }\n\n    get id(): string {\n        return this._id;\n    }\n\n    private _id = `mc-option-${uniqueIdCounter++}`;\n\n    get selected(): boolean {\n        return this._selected;\n    }\n\n    private _selected = false;\n\n    @Input()\n    get disabled() {\n        return (this.group && this.group.disabled) || this._disabled;\n    }\n\n    set disabled(value: any) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n\n    private _disabled = false;\n\n    /**\n     * Whether or not the option is currently active and ready to be selected.\n     * An active option displays styles as if it is focused, but the\n     * focus is actually retained somewhere else. This comes in handy\n     * for components like autocomplete where focus must remain on the input.\n     */\n    get active(): boolean {\n        return this._active;\n    }\n\n    private _active = false;\n\n    private mostRecentViewValue = '';\n\n    constructor(\n        private readonly element: ElementRef,\n        private readonly changeDetectorRef: ChangeDetectorRef,\n        @Optional() @Inject(MC_OPTION_PARENT_COMPONENT) private readonly parent: McOptionParentComponent,\n        @Optional() readonly group: McOptgroup\n    ) {}\n\n    ngAfterViewChecked() {\n        // Since parent components could be using the option's label to display the selected values\n        // (e.g. `mc-select`) and they don't have a way of knowing if the option's label has changed\n        // we have to check for changes in the DOM ourselves and dispatch an event. These checks are\n        // relatively cheap, however we still limit them only to selected options in order to avoid\n        // hitting the DOM too often.\n        if (this._selected) {\n            const viewValue = this.viewValue;\n\n            if (viewValue !== this.mostRecentViewValue) {\n                this.mostRecentViewValue = viewValue;\n                this.stateChanges.next();\n            }\n        }\n    }\n\n    ngOnDestroy() {\n        this.stateChanges.complete();\n    }\n\n    getHeight(): number {\n        // tslint:disable-next-line:naming-convention\n        const DOMRect: DOMRect = this.element.nativeElement.getClientRects()[0];\n\n        return DOMRect ? DOMRect.height : 0;\n    }\n\n    select(): void {\n        if (!this._selected) {\n            this._selected = true;\n\n            this.changeDetectorRef.markForCheck();\n            this.emitSelectionChangeEvent();\n        }\n    }\n\n    deselect(): void {\n        if (this._selected) {\n            this._selected = false;\n\n            this.changeDetectorRef.markForCheck();\n            this.emitSelectionChangeEvent();\n        }\n    }\n\n    focus(): void {\n        const element = this.getHostElement();\n\n        if (typeof element.focus === 'function') {\n            element.focus();\n        }\n    }\n\n    /**\n     * This method sets display styles on the option to make it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     */\n    setActiveStyles(): void {\n        if (!this._active) {\n            this._active = true;\n            this.changeDetectorRef.markForCheck();\n        }\n    }\n\n    /**\n     * This method removes display styles on the option that made it appear\n     * active. This is used by the ActiveDescendantKeyManager so key\n     * events will display the proper options as active on arrow key events.\n     */\n    setInactiveStyles(): void {\n        if (this._active) {\n            this._active = false;\n            this.changeDetectorRef.markForCheck();\n        }\n    }\n\n    /** Gets the label to be used when determining whether the option should be focused. */\n    getLabel(): string {\n        return this.viewValue;\n    }\n\n    /** Ensures the option is selected when activated from the keyboard. */\n    handleKeydown(event: KeyboardEvent): void {\n        // tslint:disable-next-line\n        if (event.keyCode === ENTER || event.keyCode === SPACE) {\n            this.selectViaInteraction();\n\n            // Prevent the page from scrolling down and form submits.\n            event.preventDefault();\n        }\n    }\n\n    /**\n     * `Selects the option while indicating the selection came from the user. Used to\n     * determine if the select's view -> model callback should be invoked.`\n     */\n    selectViaInteraction(): void {\n        if (!this.disabled) {\n            this._selected = this.multiple ? !this._selected : true;\n\n            this.changeDetectorRef.markForCheck();\n            this.emitSelectionChangeEvent(true);\n        }\n    }\n\n    getTabIndex(): string {\n        return this.disabled ? '-1' : '0';\n    }\n\n    getHostElement(): HTMLElement {\n        return this.element.nativeElement;\n    }\n\n    /** Emits the selection change event. */\n    private emitSelectionChangeEvent(isUserInput = false): void {\n        this.onSelectionChange.emit(new McOptionSelectionChange(this, isUserInput));\n    }\n}\n\n/**\n * Counts the amount of option group labels that precede the specified option.\n * @param optionIndex Index of the option at which to start counting.\n * @param options Flat list of all of the options.\n * @param optionGroups Flat list of all of the option groups.\n * @docs-private\n */\nexport function countGroupLabelsBeforeOption(\n    optionIndex: number,\n    options: QueryList<McOption>,\n    optionGroups: QueryList<McOptgroup>\n): number {\n\n    if (optionGroups.length) {\n        const optionsArray = options.toArray();\n        const groups = optionGroups.toArray();\n\n        let groupCounter = 0;\n\n        for (let i = 0; i < optionIndex + 1; i++) {\n            if (optionsArray[i].group && optionsArray[i].group === groups[groupCounter]) {\n                groupCounter++;\n            }\n        }\n\n        return groupCounter;\n    }\n\n    return 0;\n}\n\n/**\n * Determines the position to which to scroll a panel in order for an option to be into view.\n * @param optionIndex Index of the option to be scrolled into the view.\n * @param optionHeight Height of the options.\n * @param currentScrollPosition Current scroll position of the panel.\n * @param panelHeight Height of the panel.\n * @docs-private\n */\nexport function getOptionScrollPosition(\n    optionIndex: number,\n    optionHeight: number,\n    currentScrollPosition: number,\n    panelHeight: number\n): number {\n    const optionOffset = optionIndex * optionHeight;\n\n    if (optionOffset < currentScrollPosition) { return optionOffset; }\n\n    if (optionOffset + optionHeight > currentScrollPosition + panelHeight) {\n        return Math.max(0, optionOffset - panelHeight + optionHeight);\n    }\n\n    return currentScrollPosition;\n}\n\n","<mc-pseudo-checkbox\n    *ngIf=\"showCheckbox\"\n    [state]=\"selected ? 'checked' : 'unchecked'\"\n    [disabled]=\"disabled\">\n</mc-pseudo-checkbox>\n\n<span class=\"mc-option-text\"><ng-content></ng-content></span>\n\n<div class=\"mc-option-overlay\"></div>\n"]}

package/esm2020/core/pop-up/pop-up-trigger.mjs

@@ -0,0 +1,239 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Overlay, ScrollDispatcher } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, NgZone, ViewContainerRef } from '@angular/core';
+import { ESCAPE } from '@ptsecurity/cdk/keycodes';
+import { Subject } from 'rxjs';
+import { delay as rxDelay, distinctUntilChanged, takeUntil } from 'rxjs/operators';
+import { EXTENDED_OVERLAY_POSITIONS, POSITION_MAP, POSITION_PRIORITY_STRATEGY, POSITION_TO_CSS_MAP } from '../overlay/overlay-position-map';
+import { PopUpPlacements, PopUpTriggers } from './constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/bidi";
+// tslint:disable-next-line:naming-convention
+export class McPopUpTrigger {
+    constructor(overlay, elementRef, ngZone, scrollDispatcher, hostView, scrollStrategy, direction) {
+        this.overlay = overlay;
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.scrollDispatcher = scrollDispatcher;
+        this.hostView = hostView;
+        this.scrollStrategy = scrollStrategy;
+        this.direction = direction;
+        this.isOpen = false;
+        this.enterDelay = 0;
+        this.leaveDelay = 0;
+        this.placement = PopUpPlacements.Top;
+        this.placementPriority = null;
+        this.visible = false;
+        this.listeners = new Map();
+        this.destroyed = new Subject();
+        this.detach = () => {
+            if (this.overlayRef && this.overlayRef.hasAttached()) {
+                this.overlayRef.detach();
+            }
+            this.instance = null;
+        };
+        this.onPositionChange = ($event) => {
+            if (!this.instance) {
+                return;
+            }
+            let newPlacement = this.placement;
+            const { originX, originY, overlayX, overlayY } = $event.connectionPair;
+            Object.keys(this.availablePositions).some((key) => {
+                if (originX === this.availablePositions[key].originX && originY === this.availablePositions[key].originY &&
+                    overlayX === this.availablePositions[key].overlayX && overlayY === this.availablePositions[key].overlayY) {
+                    newPlacement = key;
+                    return true;
+                }
+                return false;
+            });
+            this.placementChange.emit(newPlacement);
+            this.updateClassMap(newPlacement);
+            this.instance.detectChanges();
+        };
+        this.addEventListener = (listener, event) => {
+            this.elementRef.nativeElement.addEventListener(event, listener);
+        };
+        this.removeEventListener = (listener, event) => {
+            this.elementRef.nativeElement.removeEventListener(event, listener);
+        };
+        this.availablePositions = POSITION_MAP;
+    }
+    ngOnInit() {
+        this.initListeners();
+    }
+    ngOnDestroy() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+        }
+        this.listeners.forEach(this.removeEventListener);
+        this.listeners.clear();
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    updatePlacement(value) {
+        if (POSITION_TO_CSS_MAP[value]) {
+            this.placement = value;
+            this.updateClassMap();
+        }
+        else {
+            this.placement = PopUpPlacements.Top;
+            console.warn(`Unknown position: ${value}. Will used default position: ${this.placement}`);
+        }
+        if (this.visible) {
+            this.updatePosition();
+        }
+    }
+    updatePlacementPriority(value) {
+        if (value && value.length > 0) {
+            this.placementPriority = value;
+        }
+        else {
+            this.placementPriority = null;
+        }
+    }
+    updateVisible(externalValue) {
+        const value = coerceBooleanProperty(externalValue);
+        if (this.visible !== value) {
+            this.visible = value;
+            if (value) {
+                this.show();
+            }
+            else {
+                this.hide();
+            }
+        }
+    }
+    handleKeydown(event) {
+        if (this.isOpen && event.keyCode === ESCAPE) { // tslint:disable-line
+            this.hide();
+        }
+    }
+    handleTouchend() {
+        this.hide();
+    }
+    show(delay = this.enterDelay) {
+        if (this.disabled || this.instance) {
+            return;
+        }
+        this.overlayRef = this.createOverlay();
+        this.detach();
+        this.portal = this.portal || new ComponentPortal(this.getOverlayHandleComponentType(), this.hostView);
+        this.instance = this.overlayRef.attach(this.portal).instance;
+        this.instance.afterHidden()
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(this.detach);
+        this.updateClassMap();
+        this.updateData();
+        this.instance.visibleChange
+            .pipe(takeUntil(this.destroyed), distinctUntilChanged())
+            .subscribe((value) => {
+            this.visible = value;
+            this.visibleChange.emit(value);
+            this.isOpen = value;
+        });
+        this.updatePosition();
+        this.instance.show(delay);
+    }
+    hide(delay = this.leaveDelay) {
+        if (this.instance) {
+            this.instance.hide(delay);
+        }
+    }
+    /** Create the overlay config and position strategy */
+    createOverlay() {
+        if (this.overlayRef) {
+            return this.overlayRef;
+        }
+        // Create connected position strategy that listens for scroll events to reposition.
+        const strategy = this.overlay
+            .position()
+            .flexibleConnectedTo(this.elementRef)
+            .withTransformOriginOn(this.originSelector)
+            .withFlexibleDimensions(false)
+            .withPositions([...EXTENDED_OVERLAY_POSITIONS])
+            .withScrollableContainers(this.scrollDispatcher.getAncestorScrollContainers(this.elementRef));
+        strategy.positionChanges
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(this.onPositionChange);
+        this.overlayRef = this.overlay.create({
+            ...this.overlayConfig,
+            direction: this.direction,
+            positionStrategy: strategy,
+            scrollStrategy: this.scrollStrategy()
+        });
+        this.closingActions()
+            .pipe(takeUntil(this.destroyed))
+            .pipe(rxDelay(0))
+            .subscribe(() => this.hide());
+        this.overlayRef.outsidePointerEvents()
+            .subscribe(() => this.instance.handleBodyInteraction());
+        this.overlayRef.detachments()
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(this.detach);
+        return this.overlayRef;
+    }
+    initListeners() {
+        this.clearListeners();
+        if (this.trigger.includes(PopUpTriggers.Click)) {
+            this.listeners
+                .set('click', () => this.show())
+                .forEach(this.addEventListener);
+        }
+        if (this.trigger.includes(PopUpTriggers.Hover)) {
+            this.listeners
+                .set('mouseenter', () => this.show())
+                .set('mouseleave', () => this.hide())
+                .forEach(this.addEventListener);
+        }
+        if (this.trigger.includes(PopUpTriggers.Focus)) {
+            this.listeners
+                .set('focus', () => this.show())
+                .set('blur', () => this.hide())
+                .forEach(this.addEventListener);
+        }
+    }
+    /** Updates the position of the current popover. */
+    updatePosition(reapplyPosition = false) {
+        this.overlayRef = this.createOverlay();
+        const position = this.overlayRef.getConfig().positionStrategy
+            .withPositions(this.getPrioritizedPositions())
+            .withPush(true);
+        if (reapplyPosition) {
+            setTimeout(() => position.reapplyLastPosition());
+        }
+    }
+    getPriorityPlacementStrategy(value) {
+        const result = [];
+        const possiblePositions = Object.keys(this.availablePositions);
+        if (Array.isArray(value)) {
+            value.forEach((position) => {
+                if (possiblePositions.includes(position)) {
+                    result.push(this.availablePositions[position]);
+                }
+            });
+        }
+        else if (possiblePositions.includes(value)) {
+            result.push(this.availablePositions[value]);
+        }
+        return result;
+    }
+    getPrioritizedPositions() {
+        if (this.placementPriority) {
+            return this.getPriorityPlacementStrategy(this.placementPriority);
+        }
+        return POSITION_PRIORITY_STRATEGY[this.placement];
+    }
+    clearListeners() {
+        this.listeners.forEach(this.removeEventListener);
+        this.listeners.clear();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ McPopUpTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: McPopUpTrigger, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ McPopUpTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.0", type: McPopUpTrigger, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: McPopUpTrigger, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.ScrollDispatcher }, { type: i0.ViewContainerRef }, { type: undefined }, { type: i2.Directionality }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pop-up-trigger.js","sourceRoot":"","sources":["../../../../../packages/mosaic/core/pop-up/pop-up-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n    ConnectedOverlayPositionChange,\n    ConnectionPositionPair,\n    FlexibleConnectedPositionStrategy,\n    Overlay,\n    OverlayRef,\n    ScrollDispatcher\n} from '@angular/cdk/overlay';\nimport { OverlayConfig } from '@angular/cdk/overlay/overlay-config';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport {\n    Directive,\n    ElementRef,\n    EventEmitter,\n    NgZone,\n    TemplateRef,\n    Type,\n    ViewContainerRef\n} from '@angular/core';\nimport { ESCAPE } from '@ptsecurity/cdk/keycodes';\nimport { Observable, Subject } from 'rxjs';\nimport { delay as rxDelay, distinctUntilChanged, takeUntil } from 'rxjs/operators';\n\nimport {\n    EXTENDED_OVERLAY_POSITIONS,\n    POSITION_MAP,\n    POSITION_PRIORITY_STRATEGY,\n    POSITION_TO_CSS_MAP\n} from '../overlay/overlay-position-map';\n\nimport { PopUpPlacements, PopUpTriggers } from './constants';\n\n\n@Directive()\n// tslint:disable-next-line:naming-convention\nexport abstract class McPopUpTrigger<T> {\n    isOpen: boolean = false;\n\n    enterDelay: number = 0;\n    leaveDelay: number = 0;\n\n    abstract disabled: boolean;\n    abstract trigger: string;\n    abstract customClass: string;\n    abstract content: string | TemplateRef<any>;\n\n    abstract placementChange: EventEmitter<string>;\n    abstract visibleChange: EventEmitter<boolean>;\n\n    protected abstract originSelector: string;\n    protected abstract overlayConfig: OverlayConfig;\n\n    protected placement = PopUpPlacements.Top;\n    protected placementPriority: string | string[] | null = null;\n\n    protected visible = false;\n\n    // tslint:disable-next-line:naming-convention orthodox-getter-and-setter\n    protected _content: string | TemplateRef<any>;\n    // tslint:disable-next-line:naming-convention orthodox-getter-and-setter\n    protected _disabled: boolean;\n    // tslint:disable-next-line:naming-convention orthodox-getter-and-setter\n    protected _customClass: string;\n\n    protected overlayRef: OverlayRef | null;\n    protected portal: ComponentPortal<T>;\n    protected instance: any | null;\n\n    protected listeners = new Map<string, EventListenerOrEventListenerObject>();\n\n    protected readonly availablePositions: { [key: string]: ConnectionPositionPair };\n    protected readonly destroyed = new Subject<void>();\n\n    protected constructor(\n        protected overlay: Overlay,\n        protected elementRef: ElementRef,\n        protected ngZone: NgZone,\n        protected scrollDispatcher: ScrollDispatcher,\n        protected hostView: ViewContainerRef,\n        protected scrollStrategy,\n        protected direction?: Directionality\n    ) {\n        this.availablePositions = POSITION_MAP;\n    }\n\n    abstract updateClassMap(newPlacement?: string): void;\n\n    abstract updateData(): void;\n\n    abstract closingActions(): Observable<any>;\n\n    abstract getOverlayHandleComponentType(): Type<T>;\n\n    ngOnInit(): void {\n        this.initListeners();\n    }\n\n    ngOnDestroy(): void {\n        if (this.overlayRef) {\n            this.overlayRef.dispose();\n        }\n\n        this.listeners.forEach(this.removeEventListener);\n\n        this.listeners.clear();\n\n        this.destroyed.next();\n        this.destroyed.complete();\n    }\n\n    updatePlacement(value: PopUpPlacements) {\n        if (POSITION_TO_CSS_MAP[value]) {\n            this.placement = value;\n\n            this.updateClassMap();\n        } else {\n            this.placement = PopUpPlacements.Top;\n\n            console.warn(`Unknown position: ${value}. Will used default position: ${this.placement}`);\n        }\n\n        if (this.visible) {\n            this.updatePosition();\n        }\n    }\n\n    updatePlacementPriority(value) {\n        if (value && value.length > 0) {\n            this.placementPriority = value;\n        } else {\n            this.placementPriority = null;\n        }\n    }\n\n    updateVisible(externalValue: boolean) {\n        const value = coerceBooleanProperty(externalValue);\n\n        if (this.visible !== value) {\n            this.visible = value;\n\n            if (value) {\n                this.show();\n            } else {\n                this.hide();\n            }\n        }\n    }\n\n    handleKeydown(event: KeyboardEvent) {\n        if (this.isOpen && event.keyCode === ESCAPE) { // tslint:disable-line\n            this.hide();\n        }\n    }\n\n    handleTouchend() {\n        this.hide();\n    }\n\n    show(delay: number = this.enterDelay): void {\n        if (this.disabled || this.instance) { return; }\n\n        this.overlayRef = this.createOverlay();\n        this.detach();\n\n        this.portal = this.portal || new ComponentPortal(this.getOverlayHandleComponentType(), this.hostView);\n\n        this.instance = this.overlayRef.attach(this.portal).instance;\n\n        this.instance.afterHidden()\n            .pipe(takeUntil(this.destroyed))\n            .subscribe(this.detach);\n\n        this.updateClassMap();\n\n        this.updateData();\n\n        this.instance.visibleChange\n            .pipe(takeUntil(this.destroyed), distinctUntilChanged())\n            .subscribe((value) => {\n                this.visible = value;\n                this.visibleChange.emit(value);\n                this.isOpen = value;\n            });\n\n        this.updatePosition();\n\n        this.instance.show(delay);\n    }\n\n    hide(delay: number = this.leaveDelay): void {\n        if (this.instance) {\n            this.instance.hide(delay);\n        }\n    }\n\n    detach = (): void => {\n        if (this.overlayRef && this.overlayRef.hasAttached()) {\n            this.overlayRef.detach();\n        }\n\n        this.instance = null;\n    }\n\n    /** Create the overlay config and position strategy */\n    createOverlay(): OverlayRef {\n        if (this.overlayRef) { return this.overlayRef; }\n\n        // Create connected position strategy that listens for scroll events to reposition.\n        const strategy = this.overlay\n            .position()\n            .flexibleConnectedTo(this.elementRef)\n            .withTransformOriginOn(this.originSelector)\n            .withFlexibleDimensions(false)\n            .withPositions([...EXTENDED_OVERLAY_POSITIONS])\n            .withScrollableContainers(this.scrollDispatcher.getAncestorScrollContainers(this.elementRef));\n\n        strategy.positionChanges\n            .pipe(takeUntil(this.destroyed))\n            .subscribe(this.onPositionChange);\n\n        this.overlayRef = this.overlay.create({\n            ...this.overlayConfig,\n            direction: this.direction,\n            positionStrategy: strategy,\n            scrollStrategy: this.scrollStrategy()\n        });\n\n        this.closingActions()\n            .pipe(takeUntil(this.destroyed))\n            .pipe(rxDelay(0))\n            .subscribe(() => this.hide());\n\n        this.overlayRef.outsidePointerEvents()\n            .subscribe(() => this.instance!.handleBodyInteraction());\n\n        this.overlayRef.detachments()\n            .pipe(takeUntil(this.destroyed))\n            .subscribe(this.detach);\n\n        return this.overlayRef;\n    }\n\n    onPositionChange = ($event: ConnectedOverlayPositionChange): void => {\n        if (!this.instance) { return; }\n\n        let newPlacement = this.placement;\n\n        const { originX, originY, overlayX, overlayY } = $event.connectionPair;\n\n        Object.keys(this.availablePositions).some((key) => {\n            if (\n                originX === this.availablePositions[key].originX && originY === this.availablePositions[key].originY &&\n                overlayX === this.availablePositions[key].overlayX && overlayY === this.availablePositions[key].overlayY\n            ) {\n                newPlacement = key as PopUpPlacements;\n\n                return true;\n            }\n\n            return false;\n        });\n\n        this.placementChange.emit(newPlacement);\n\n        this.updateClassMap(newPlacement);\n\n        this.instance.detectChanges();\n    }\n\n    initListeners() {\n        this.clearListeners();\n\n        if (this.trigger.includes(PopUpTriggers.Click)) {\n            this.listeners\n                .set('click', () => this.show())\n                .forEach(this.addEventListener);\n        }\n\n        if (this.trigger.includes(PopUpTriggers.Hover)) {\n            this.listeners\n                .set('mouseenter', () => this.show())\n                .set('mouseleave', () => this.hide())\n                .forEach(this.addEventListener);\n        }\n\n        if (this.trigger.includes(PopUpTriggers.Focus)) {\n            this.listeners\n                .set('focus', () => this.show())\n                .set('blur', () => this.hide())\n                .forEach(this.addEventListener);\n        }\n    }\n\n    /** Updates the position of the current popover. */\n    updatePosition(reapplyPosition: boolean = false) {\n        this.overlayRef = this.createOverlay();\n\n        const position = (this.overlayRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy)\n            .withPositions(this.getPrioritizedPositions())\n            .withPush(true);\n\n        if (reapplyPosition) {\n            setTimeout(() => position.reapplyLastPosition());\n        }\n    }\n\n    protected getPriorityPlacementStrategy(value: string | string[]): ConnectionPositionPair[] {\n        const result: ConnectionPositionPair[] = [];\n        const possiblePositions = Object.keys(this.availablePositions);\n\n        if (Array.isArray(value)) {\n            value.forEach((position: string) => {\n                if (possiblePositions.includes(position)) {\n                    result.push(this.availablePositions[position]);\n                }\n            });\n        } else if (possiblePositions.includes(value)) {\n            result.push(this.availablePositions[value]);\n        }\n\n        return result;\n    }\n\n    protected getPrioritizedPositions() {\n        if (this.placementPriority) {\n            return this.getPriorityPlacementStrategy(this.placementPriority);\n        }\n\n        return POSITION_PRIORITY_STRATEGY[this.placement];\n    }\n\n    protected clearListeners() {\n        this.listeners.forEach(this.removeEventListener);\n\n        this.listeners.clear();\n    }\n\n    private addEventListener = (listener: EventListener | EventListenerObject, event: string) => {\n        this.elementRef.nativeElement.addEventListener(event, listener);\n    }\n\n    private removeEventListener = (listener: EventListener | EventListenerObject, event: string) => {\n        this.elementRef.nativeElement.removeEventListener(event, listener);\n    }\n}\n"]}