@clr/angular 12.0.8 → 13.0.0-next.0

package/esm2020/utils/popover/popover-anchor.mjs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/popover-events.service";
+export class ClrPopoverAnchor {
+    constructor(smartEventService, element) {
+        smartEventService.anchorButtonRef = element;
+    }
+}
+ClrPopoverAnchor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverAnchor, deps: [{ token: i1.ClrPopoverEventsService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClrPopoverAnchor.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrPopoverAnchor, selector: "[clrPopoverAnchor]", host: { properties: { "class.clr-anchor": "true" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverAnchor, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrPopoverAnchor]',
+                    host: {
+                        '[class.clr-anchor]': 'true',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ClrPopoverEventsService }, { type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1hbmNob3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyL3NyYy91dGlscy9wb3BvdmVyL3BvcG92ZXItYW5jaG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBYyxNQUFNLGVBQWUsQ0FBQzs7O0FBU3RELE1BQU0sT0FBTyxnQkFBZ0I7SUFDM0IsWUFBWSxpQkFBMEMsRUFBRSxPQUFtQjtRQUN6RSxpQkFBaUIsQ0FBQyxlQUFlLEdBQUcsT0FBTyxDQUFDO0lBQzlDLENBQUM7OzZHQUhVLGdCQUFnQjtpR0FBaEIsZ0JBQWdCOzJGQUFoQixnQkFBZ0I7a0JBTjVCLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtvQkFDOUIsSUFBSSxFQUFFO3dCQUNKLG9CQUFvQixFQUFFLE1BQU07cUJBQzdCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxNi0yMDIxIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICogVGhpcyBzb2Z0d2FyZSBpcyByZWxlYXNlZCB1bmRlciBNSVQgbGljZW5zZS5cbiAqIFRoZSBmdWxsIGxpY2Vuc2UgaW5mb3JtYXRpb24gY2FuIGJlIGZvdW5kIGluIExJQ0VOU0UgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgcHJvamVjdC5cbiAqXG4gKi9cblxuaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDbHJQb3BvdmVyRXZlbnRzU2VydmljZSB9IGZyb20gJy4vcHJvdmlkZXJzL3BvcG92ZXItZXZlbnRzLnNlcnZpY2UnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbY2xyUG9wb3ZlckFuY2hvcl0nLFxuICBob3N0OiB7XG4gICAgJ1tjbGFzcy5jbHItYW5jaG9yXSc6ICd0cnVlJyxcbiAgfSxcbn0pXG5leHBvcnQgY2xhc3MgQ2xyUG9wb3ZlckFuY2hvciB7XG4gIGNvbnN0cnVjdG9yKHNtYXJ0RXZlbnRTZXJ2aWNlOiBDbHJQb3BvdmVyRXZlbnRzU2VydmljZSwgZWxlbWVudDogRWxlbWVudFJlZikge1xuICAgIHNtYXJ0RXZlbnRTZXJ2aWNlLmFuY2hvckJ1dHRvblJlZiA9IGVsZW1lbnQ7XG4gIH1cbn1cbiJdfQ==

package/esm2020/utils/popover/popover-close-button.mjs

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { Directive, EventEmitter, Output, HostListener } from '@angular/core';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/popover-events.service";
+import * as i2 from "./providers/popover-toggle.service";
+export class ClrPopoverCloseButton {
+    constructor(elementRef, smartEventsService, smartOpenService) {
+        this.elementRef = elementRef;
+        this.smartEventsService = smartEventsService;
+        this.smartOpenService = smartOpenService;
+        this.subscriptions = [];
+        this.closeChange = new EventEmitter();
+        this.subscriptions.push(smartOpenService.openChange.pipe(filter(value => !value)).subscribe(() => {
+            this.closeChange.next();
+        }));
+    }
+    handleClick(event) {
+        this.smartOpenService.toggleWithEvent(event);
+        this.smartEventsService.setAnchorFocus();
+    }
+    ngAfterViewInit() {
+        this.smartEventsService.closeButtonRef = this.elementRef;
+        this.smartEventsService.setCloseFocus();
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrPopoverCloseButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverCloseButton, deps: [{ token: i0.ElementRef }, { token: i1.ClrPopoverEventsService }, { token: i2.ClrPopoverToggleService }], target: i0.ɵɵFactoryTarget.Directive });
+ClrPopoverCloseButton.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrPopoverCloseButton, selector: "[clrPopoverCloseButton]", outputs: { closeChange: "clrPopoverOnCloseChange" }, host: { listeners: { "click": "handleClick($event)" }, properties: { "class.clr-smart-close-button": "true" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverCloseButton, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrPopoverCloseButton]',
+                    host: {
+                        '[class.clr-smart-close-button]': 'true',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ClrPopoverEventsService }, { type: i2.ClrPopoverToggleService }]; }, propDecorators: { closeChange: [{
+                type: Output,
+                args: ['clrPopoverOnCloseChange']
+            }], handleClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/popover/popover-content.mjs

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { Directive, Inject, Input, EventEmitter, } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/popover-position.service";
+import * as i2 from "./providers/popover-events.service";
+import * as i3 from "./providers/popover-toggle.service";
+// https://github.com/angular/angular/issues/20351#issuecomment-344009887
+/** @dynamic */
+export class ClrPopoverContent {
+    constructor(document, container, template, renderer, smartPositionService, smartEventsService, smartOpenService) {
+        this.document = document;
+        this.container = container;
+        this.template = template;
+        this.renderer = renderer;
+        this.smartPositionService = smartPositionService;
+        this.smartEventsService = smartEventsService;
+        this.smartOpenService = smartOpenService;
+        this.subscriptions = [];
+        this.shouldRealign = false;
+        // Check-collector pattern:
+        // In order to get accurate content height/width values, we cannot calculate alignment offsets until
+        // after the projected content has stabilized.
+        // As multiple check events may happen in the same rendering cycle, we need to collect all events
+        // and only act after the content is really stable. Or we may get wrong intermediate positioning values.
+        // We will channel subsequent content check events through this observable.
+        this.checkCollector = new EventEmitter();
+    }
+    set open(value) {
+        this.smartOpenService.open = !!value;
+    }
+    set contentAt(position) {
+        this.smartPositionService.position = position;
+    }
+    set outsideClickClose(clickToClose) {
+        this.smartEventsService.outsideClickClose = !!clickToClose;
+    }
+    set scrollToClose(scrollToClose) {
+        this.smartEventsService.scrollToClose = !!scrollToClose;
+    }
+    ngAfterViewInit() {
+        this.subscriptions.push(this.smartOpenService.openChange.subscribe(change => {
+            if (change) {
+                this.addContent();
+            }
+            else {
+                this.removeContent();
+            }
+        }), this.smartPositionService.shouldRealign.subscribe(() => {
+            this.shouldRealign = true;
+            // Avoid flickering on initialization, caused by the asynchronous nature of the
+            // check-collector pattern.
+            if (this.view) {
+                this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '0');
+            }
+        }), 
+        // Here we collect subsequent synchronously received content-check events and only take action
+        // at the end of the cycle. See below for details on the check-collector pattern.
+        this.checkCollector.pipe(debounceTime(0)).subscribe(() => {
+            this.alignContent();
+            this.shouldRealign = false;
+            if (this.view) {
+                this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '1');
+            }
+        }));
+    }
+    ngOnDestroy() {
+        this.removeContent();
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+    removeContent() {
+        if (!this.view) {
+            return;
+        }
+        this.view.rootNodes.forEach(node => this.renderer.removeChild(this.document.body, node));
+        this.container.clear();
+        delete this.view;
+    }
+    /**
+     * TODO(matt): investigate why DebugElement retains a reference to the nodes and causes a memory leak.
+     * A note about the use of appendChild/removeChild
+     * The DebugElement is keeping a reference to the detached node and its unclear why.
+     * This does warrant further investigation. But, since it doesn't happen in production mode
+     * it is a low priority issue for now.
+     */
+    addContent() {
+        // Create the view container
+        this.view = this.container.createEmbeddedView(this.template);
+        this.smartEventsService.contentRef = this.view.rootNodes[0]; // So we know where/what to set close focus on
+        this.renderer.addClass(this.view.rootNodes[0], 'clr-popover-content');
+        // Reset to the begining of the document to be available for sizing/positioning calculations.
+        // If we add new content to the bottom it triggers changes in the layout that may lead to false anchor
+        // coordinates values.
+        this.renderer.setStyle(this.view.rootNodes[0], 'top', '0px');
+        this.renderer.setStyle(this.view.rootNodes[0], 'left', '0px');
+        // We need to hide it during the calculation phase, while it's not yet finally positioned.
+        this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '0');
+        this.renderer.listen(this.view.rootNodes[0], 'click', event => {
+            this.smartOpenService.openEvent = event;
+        });
+        this.view.rootNodes.forEach(node => {
+            this.renderer.appendChild(this.document.body, node);
+        });
+        // Mark for realingment on the next content-check cycle.
+        this.shouldRealign = true;
+    }
+    ngAfterContentChecked() {
+        if (this.smartOpenService.open && this.view && this.shouldRealign) {
+            // Channel content-check event through the check-collector
+            this.checkCollector.emit();
+        }
+    }
+    alignContent() {
+        if (!this.view) {
+            return;
+        }
+        const positionCoords = this.smartPositionService.alignContent(this.view.rootNodes[0]);
+        this.renderer.setStyle(this.view.rootNodes[0], 'top', `${positionCoords.yOffset}px`);
+        this.renderer.setStyle(this.view.rootNodes[0], 'left', `${positionCoords.xOffset}px`);
+        this.smartOpenService.popoverAlignedEmit(this.view.rootNodes[0]);
+    }
+}
+ClrPopoverContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverContent, deps: [{ token: DOCUMENT }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: i0.Renderer2 }, { token: i1.ClrPopoverPositionService }, { token: i2.ClrPopoverEventsService }, { token: i3.ClrPopoverToggleService }], target: i0.ɵɵFactoryTarget.Directive });
+ClrPopoverContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrPopoverContent, selector: "[clrPopoverContent]", inputs: { open: ["clrPopoverContent", "open"], contentAt: ["clrPopoverContentAt", "contentAt"], outsideClickClose: ["clrPopoverContentOutsideClickToClose", "outsideClickClose"], scrollToClose: ["clrPopoverContentScrollToClose", "scrollToClose"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverContent, decorators: [{
+            type: Directive,
+            args: [{ selector: '[clrPopoverContent]' }]
+        }], ctorParameters: function () { return [{ type: HTMLDocument, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: i0.Renderer2 }, { type: i1.ClrPopoverPositionService }, { type: i2.ClrPopoverEventsService }, { type: i3.ClrPopoverToggleService }]; }, propDecorators: { open: [{
+                type: Input,
+                args: ['clrPopoverContent']
+            }], contentAt: [{
+                type: Input,
+                args: ['clrPopoverContentAt']
+            }], outsideClickClose: [{
+                type: Input,
+                args: ['clrPopoverContentOutsideClickToClose']
+            }], scrollToClose: [{
+                type: Input,
+                args: ['clrPopoverContentScrollToClose']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-content.js","sourceRoot":"","sources":["../../../../../projects/angular/src/utils/popover/popover-content.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n *\n */\nimport {\n  Directive,\n  EmbeddedViewRef,\n  Inject,\n  Input,\n  OnDestroy,\n  Renderer2,\n  TemplateRef,\n  ViewContainerRef,\n  AfterContentChecked,\n  EventEmitter,\n} from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { Subscription } from 'rxjs';\n\nimport { ClrPopoverToggleService } from './providers/popover-toggle.service';\nimport { ClrPopoverEventsService } from './providers/popover-events.service';\nimport { ClrPopoverPositionService } from './providers/popover-position.service';\nimport { ClrPopoverPosition } from './interfaces/popover-position.interface';\nimport { debounceTime } from 'rxjs/operators';\n\n// https://github.com/angular/angular/issues/20351#issuecomment-344009887\n/** @dynamic */\n@Directive({ selector: '[clrPopoverContent]' })\nexport class ClrPopoverContent implements AfterContentChecked, OnDestroy {\n  private view: EmbeddedViewRef<void>;\n  private subscriptions: Subscription[] = [];\n\n  @Input('clrPopoverContent')\n  public set open(value: boolean) {\n    this.smartOpenService.open = !!value;\n  }\n\n  @Input('clrPopoverContentAt')\n  set contentAt(position: ClrPopoverPosition) {\n    this.smartPositionService.position = position;\n  }\n\n  @Input('clrPopoverContentOutsideClickToClose')\n  set outsideClickClose(clickToClose: boolean) {\n    this.smartEventsService.outsideClickClose = !!clickToClose;\n  }\n\n  @Input('clrPopoverContentScrollToClose')\n  set scrollToClose(scrollToClose: boolean) {\n    this.smartEventsService.scrollToClose = !!scrollToClose;\n  }\n\n  constructor(\n    @Inject(DOCUMENT) private document: HTMLDocument,\n    private container: ViewContainerRef,\n    private template: TemplateRef<any>,\n    private renderer: Renderer2,\n    private smartPositionService: ClrPopoverPositionService,\n    private smartEventsService: ClrPopoverEventsService,\n    private smartOpenService: ClrPopoverToggleService\n  ) {}\n\n  ngAfterViewInit() {\n    this.subscriptions.push(\n      this.smartOpenService.openChange.subscribe(change => {\n        if (change) {\n          this.addContent();\n        } else {\n          this.removeContent();\n        }\n      }),\n      this.smartPositionService.shouldRealign.subscribe(() => {\n        this.shouldRealign = true;\n        // Avoid flickering on initialization, caused by the asynchronous nature of the\n        // check-collector pattern.\n        if (this.view) {\n          this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '0');\n        }\n      }),\n      // Here we collect subsequent synchronously received content-check events and only take action\n      // at the end of the cycle. See below for details on the check-collector pattern.\n      this.checkCollector.pipe(debounceTime(0)).subscribe(() => {\n        this.alignContent();\n        this.shouldRealign = false;\n        if (this.view) {\n          this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '1');\n        }\n      })\n    );\n  }\n\n  ngOnDestroy() {\n    this.removeContent();\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n  private removeContent(): void {\n    if (!this.view) {\n      return;\n    }\n    this.view.rootNodes.forEach(node => this.renderer.removeChild(this.document.body, node));\n    this.container.clear();\n    delete this.view;\n  }\n\n  /**\n   * TODO(matt): investigate why DebugElement retains a reference to the nodes and causes a memory leak.\n   * A note about the use of appendChild/removeChild\n   * The DebugElement is keeping a reference to the detached node and its unclear why.\n   * This does warrant further investigation. But, since it doesn't happen in production mode\n   * it is a low priority issue for now.\n   */\n  private addContent() {\n    // Create the view container\n    this.view = this.container.createEmbeddedView(this.template);\n    this.smartEventsService.contentRef = this.view.rootNodes[0]; // So we know where/what to set close focus on\n    this.renderer.addClass(this.view.rootNodes[0], 'clr-popover-content');\n    // Reset to the begining of the document to be available for sizing/positioning calculations.\n    // If we add new content to the bottom it triggers changes in the layout that may lead to false anchor\n    // coordinates values.\n    this.renderer.setStyle(this.view.rootNodes[0], 'top', '0px');\n    this.renderer.setStyle(this.view.rootNodes[0], 'left', '0px');\n    // We need to hide it during the calculation phase, while it's not yet finally positioned.\n    this.renderer.setStyle(this.view.rootNodes[0], 'opacity', '0');\n    this.renderer.listen(this.view.rootNodes[0], 'click', event => {\n      this.smartOpenService.openEvent = event;\n    });\n    this.view.rootNodes.forEach(node => {\n      this.renderer.appendChild(this.document.body, node);\n    });\n    // Mark for realingment on the next content-check cycle.\n    this.shouldRealign = true;\n  }\n\n  private shouldRealign = false;\n\n  // Check-collector pattern:\n  // In order to get accurate content height/width values, we cannot calculate alignment offsets until\n  // after the projected content has stabilized.\n  // As multiple check events may happen in the same rendering cycle, we need to collect all events\n  // and only act after the content is really stable. Or we may get wrong intermediate positioning values.\n  // We will channel subsequent content check events through this observable.\n  private checkCollector: EventEmitter<void> = new EventEmitter();\n\n  ngAfterContentChecked(): void {\n    if (this.smartOpenService.open && this.view && this.shouldRealign) {\n      // Channel content-check event through the check-collector\n      this.checkCollector.emit();\n    }\n  }\n\n  private alignContent() {\n    if (!this.view) {\n      return;\n    }\n    const positionCoords = this.smartPositionService.alignContent(this.view.rootNodes[0]);\n    this.renderer.setStyle(this.view.rootNodes[0], 'top', `${positionCoords.yOffset}px`);\n    this.renderer.setStyle(this.view.rootNodes[0], 'left', `${positionCoords.xOffset}px`);\n    this.smartOpenService.popoverAlignedEmit(this.view.rootNodes[0]);\n  }\n}\n"]}

package/esm2020/utils/popover/popover-open-close-button.mjs

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/popover-toggle.service";
+export class ClrPopoverOpenCloseButton {
+    constructor(smartOpenService) {
+        this.smartOpenService = smartOpenService;
+        this.subscriptions = [];
+        this.openCloseChange = new EventEmitter();
+        this.subscriptions.push(this.smartOpenService.openChange.subscribe(change => {
+            this.openCloseChange.next(change);
+        }));
+    }
+    handleClick(event) {
+        this.smartOpenService.toggleWithEvent(event);
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+}
+ClrPopoverOpenCloseButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverOpenCloseButton, deps: [{ token: i1.ClrPopoverToggleService }], target: i0.ɵɵFactoryTarget.Directive });
+ClrPopoverOpenCloseButton.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrPopoverOpenCloseButton, selector: "[clrPopoverOpenCloseButton]", outputs: { openCloseChange: "clrPopoverOpenCloseChange" }, host: { listeners: { "click": "handleClick($event)" }, properties: { "class.clr-smart-open-close": "true" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverOpenCloseButton, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrPopoverOpenCloseButton]',
+                    host: {
+                        '[class.clr-smart-open-close]': 'true',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ClrPopoverToggleService }]; }, propDecorators: { openCloseChange: [{
+                type: Output,
+                args: ['clrPopoverOpenCloseChange']
+            }], handleClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/popover/popover.module.mjs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { NgModule } from '@angular/core';
+import { ClrPopoverContent } from './popover-content';
+import { ClrPopoverOpenCloseButton } from './popover-open-close-button';
+import { ClrPopoverCloseButton } from './popover-close-button';
+import { ClrPopoverAnchor } from './popover-anchor';
+import * as i0 from "@angular/core";
+export class ClrPopoverModuleNext {
+}
+ClrPopoverModuleNext.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverModuleNext, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrPopoverModuleNext.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverModuleNext, declarations: [ClrPopoverAnchor, ClrPopoverCloseButton, ClrPopoverOpenCloseButton, ClrPopoverContent], exports: [ClrPopoverAnchor, ClrPopoverCloseButton, ClrPopoverOpenCloseButton, ClrPopoverContent] });
+ClrPopoverModuleNext.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverModuleNext, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrPopoverModuleNext, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [ClrPopoverAnchor, ClrPopoverCloseButton, ClrPopoverOpenCloseButton, ClrPopoverContent],
+                    exports: [ClrPopoverAnchor, ClrPopoverCloseButton, ClrPopoverOpenCloseButton, ClrPopoverContent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/popover/position-operators.mjs

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ *
+ */
+import { ClrViewportViolation } from './enums/viewport-violation.enum';
+import { ClrAlignment } from './enums/alignment.enum';
+export const flipSides = position => {
+    return {
+        ...position,
+        side: -1 * position.side,
+    };
+};
+// This could be used in more advanced positioning algorithms.
+// flipAxisFlipSideAndNudgeContent(flipAxis, flipSide, nudge, nudgeForward?): ClrTransform {...}
+// I would like to keep it for now.
+export const flipAxis = position => {
+    return {
+        ...position,
+        axis: position.axis === 0 ? 1 : 0,
+    };
+};
+export const nudgeContent = (position, forward) => {
+    const nextAlignment = position.content + (forward ? 0.5 : -0.5);
+    if (nextAlignment < 0 || nextAlignment > 1) {
+        return position;
+    }
+    else {
+        return {
+            ...position,
+            content: nextAlignment,
+        };
+    }
+};
+export function flipSidesAndNudgeContent(flip, nudge, nudgeBack) {
+    return (position) => nudge(flip(position), nudgeBack);
+}
+export function align(position, anchor, content) {
+    let xDiff = anchor.left;
+    let yDiff = anchor.top;
+    // When ClrAxis is VERTICAL BEFORE = left, AFTER = right
+    // When ClrAxis is HORIZONTAL BEFORE is top, AFTER is bottom
+    switch (position.axis + position.side) {
+        case -1: {
+            // ClrAxis.VERTICAL + ClrSide.BEFORE
+            xDiff += alignHorizontal(position, anchor, content);
+            yDiff -= content.height; // pull content up to the top of the anchor
+            break;
+        }
+        case 1: {
+            // ClrAxis.VERTICAL + ClrSide.AFTER
+            xDiff += alignHorizontal(position, anchor, content);
+            yDiff += anchor.height; // push the content down to below the anchor
+            break;
+        }
+        case 0: {
+            // ClrAxis.HORIZONTAL + ClrSide.BEFORE
+            xDiff -= content.width; // pull the content left of the anchor
+            yDiff += alignVertical(position, anchor, content);
+            break;
+        }
+        case 2: {
+            // ClrAxis.HORIZONTAL + ClrSide.AFTER
+            xDiff += anchor.width; // push the content right of of the anchor
+            yDiff += alignVertical(position, anchor, content);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return { xOffset: xDiff, yOffset: yDiff };
+}
+function alignHorizontal(position, anchor, content) {
+    let horizontalOffset = 0;
+    // horizontal offset for the anchor position
+    switch (position.anchor /*calculate for the anchor alignment*/) {
+        case ClrAlignment.START: {
+            // nothing to calculate here
+            break;
+        }
+        case ClrAlignment.CENTER: {
+            horizontalOffset += anchor.width / 2; // push content over 1/2 anchor width
+            break;
+        }
+        case ClrAlignment.END: {
+            horizontalOffset += anchor.width; //  push content over width of the anchor
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    // horizontal offsets for anchor alignment
+    switch (position.content // calculate for the content alignment
+    ) {
+        case ClrAlignment.START: {
+            // Nothing to calculate here
+            break;
+        }
+        case ClrAlignment.CENTER: {
+            horizontalOffset -= content.width / 2; // pull content left by a value of 1/2 content width
+            break;
+        }
+        case ClrAlignment.END: {
+            // subtract the width of currentContent from horizontalOffset to pull it back
+            horizontalOffset -= content.width;
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return horizontalOffset;
+}
+function alignVertical(position, anchor, content) {
+    // y axis offsets for anchor alignment
+    let verticalOffset = 0;
+    // Calculate y offset for anchor position
+    switch (position.anchor) {
+        case ClrAlignment.START: {
+            // nothing to calculate here
+            break;
+        }
+        case ClrAlignment.CENTER: {
+            verticalOffset += anchor.height / 2; // push content down to the middle of the anchor rect
+            break;
+        }
+        case ClrAlignment.END: {
+            verticalOffset += anchor.height; // push content down to the bottom of the anchor
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    // Calculate y offsets for content alignment
+    switch (position.content) {
+        case ClrAlignment.START: {
+            // aligned to the top of the content rect
+            break;
+        }
+        case ClrAlignment.CENTER: {
+            verticalOffset -= content.height / 2; // pull content back up to the middle of the content rect
+            break;
+        }
+        case ClrAlignment.END: {
+            verticalOffset -= content.height; // pull content back up to the bottom of the content rect
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    return verticalOffset;
+}
+export function testVisibility(offset, content) {
+    const violations = [];
+    const mockCoords = {
+        bottom: offset.yOffset + content.height,
+        left: offset.xOffset,
+        right: offset.xOffset + content.width,
+        top: offset.yOffset,
+    };
+    if (!(mockCoords.top >= 0)) {
+        violations.push(ClrViewportViolation.TOP);
+    }
+    if (!(mockCoords.left >= 0)) {
+        violations.push(ClrViewportViolation.LEFT);
+    }
+    if (!(mockCoords.bottom <= (window.innerHeight || document.documentElement.clientHeight))) {
+        violations.push(ClrViewportViolation.BOTTOM);
+    }
+    if (!(mockCoords.right <= (window.innerWidth || document.documentElement.clientWidth))) {
+        violations.push(ClrViewportViolation.RIGHT);
+    }
+    return violations;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"position-operators.js","sourceRoot":"","sources":["../../../../../projects/angular/src/utils/popover/position-operators.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n *\n */\n\nimport { ClrPopoverPosition } from './interfaces/popover-position.interface';\nimport { ClrPopoverContentOffset } from './interfaces/popover-content-offset.interface';\nimport { ClrViewportViolation } from './enums/viewport-violation.enum';\nimport { ClrVisibilityCoords } from './interfaces/visibility-coords.interface';\nimport { ClrAlignment } from './enums/alignment.enum';\n\n// Put the forward arg here but it is only needed when nudging content or anchors.\nexport type ClrTransform = (position: ClrPopoverPosition, back?: boolean) => ClrPopoverPosition;\n\nexport const flipSides: ClrTransform = position => {\n  return {\n    ...position,\n    side: -1 * position.side,\n  };\n};\n\n// This could be used in more advanced positioning algorithms.\n// flipAxisFlipSideAndNudgeContent(flipAxis, flipSide, nudge, nudgeForward?): ClrTransform {...}\n// I would like to keep it for now.\nexport const flipAxis: ClrTransform = position => {\n  return {\n    ...position,\n    axis: position.axis === 0 ? 1 : 0,\n  };\n};\n\nexport const nudgeContent: ClrTransform = (position, forward) => {\n  const nextAlignment = position.content + (forward ? 0.5 : -0.5);\n  if (nextAlignment < 0 || nextAlignment > 1) {\n    return position;\n  } else {\n    return {\n      ...position,\n      content: nextAlignment,\n    };\n  }\n};\n\nexport function flipSidesAndNudgeContent(flip: ClrTransform, nudge: ClrTransform, nudgeBack?: boolean): ClrTransform {\n  return (position: ClrPopoverPosition): ClrPopoverPosition => nudge(flip(position), nudgeBack);\n}\n\nexport function align(position: ClrPopoverPosition, anchor: ClientRect, content: ClientRect): ClrPopoverContentOffset {\n  let xDiff = anchor.left;\n  let yDiff = anchor.top;\n\n  // When ClrAxis is VERTICAL BEFORE = left, AFTER = right\n  // When ClrAxis is HORIZONTAL BEFORE is top, AFTER is bottom\n  switch (position.axis + position.side) {\n    case -1: {\n      // ClrAxis.VERTICAL + ClrSide.BEFORE\n      xDiff += alignHorizontal(position, anchor, content);\n      yDiff -= content.height; // pull content up to the top of the anchor\n      break;\n    }\n    case 1: {\n      // ClrAxis.VERTICAL + ClrSide.AFTER\n      xDiff += alignHorizontal(position, anchor, content);\n      yDiff += anchor.height; // push the content down to below the anchor\n      break;\n    }\n    case 0: {\n      // ClrAxis.HORIZONTAL + ClrSide.BEFORE\n      xDiff -= content.width; // pull the content left of the anchor\n      yDiff += alignVertical(position, anchor, content);\n      break;\n    }\n    case 2: {\n      // ClrAxis.HORIZONTAL + ClrSide.AFTER\n      xDiff += anchor.width; // push the content right of of the anchor\n      yDiff += alignVertical(position, anchor, content);\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n  return { xOffset: xDiff, yOffset: yDiff };\n}\n\nfunction alignHorizontal(position: ClrPopoverPosition, anchor: ClientRect, content: ClientRect): number {\n  let horizontalOffset = 0;\n  // horizontal offset for the anchor position\n  switch (position.anchor /*calculate for the anchor alignment*/) {\n    case ClrAlignment.START: {\n      // nothing to calculate here\n      break;\n    }\n    case ClrAlignment.CENTER: {\n      horizontalOffset += anchor.width / 2; // push content over 1/2 anchor width\n      break;\n    }\n    case ClrAlignment.END: {\n      horizontalOffset += anchor.width; //  push content over width of the anchor\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n\n  // horizontal offsets for anchor alignment\n  switch (\n    position.content // calculate for the content alignment\n  ) {\n    case ClrAlignment.START: {\n      // Nothing to calculate here\n      break;\n    }\n    case ClrAlignment.CENTER: {\n      horizontalOffset -= content.width / 2; // pull content left by a value of 1/2 content width\n      break;\n    }\n    case ClrAlignment.END: {\n      // subtract the width of currentContent from horizontalOffset to pull it back\n      horizontalOffset -= content.width;\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n\n  return horizontalOffset;\n}\n\nfunction alignVertical(position: ClrPopoverPosition, anchor: ClientRect, content: ClientRect): number {\n  // y axis offsets for anchor alignment\n  let verticalOffset = 0;\n\n  // Calculate y offset for anchor position\n  switch (position.anchor) {\n    case ClrAlignment.START: {\n      // nothing to calculate here\n      break;\n    }\n    case ClrAlignment.CENTER: {\n      verticalOffset += anchor.height / 2; // push content down to the middle of the anchor rect\n      break;\n    }\n    case ClrAlignment.END: {\n      verticalOffset += anchor.height; // push content down to the bottom of the anchor\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n\n  // Calculate y offsets for content alignment\n  switch (position.content) {\n    case ClrAlignment.START: {\n      // aligned to the top of the content rect\n      break;\n    }\n    case ClrAlignment.CENTER: {\n      verticalOffset -= content.height / 2; // pull content back up to the middle of the content rect\n      break;\n    }\n    case ClrAlignment.END: {\n      verticalOffset -= content.height; // pull content back up to the bottom of the content rect\n      break;\n    }\n    default: {\n      break;\n    }\n  }\n  return verticalOffset;\n}\n\nexport function testVisibility(offset: ClrPopoverContentOffset, content: ClientRect): ClrViewportViolation[] {\n  const violations: ClrViewportViolation[] = [];\n  const mockCoords: ClrVisibilityCoords = {\n    bottom: offset.yOffset + content.height,\n    left: offset.xOffset,\n    right: offset.xOffset + content.width,\n    top: offset.yOffset,\n  };\n\n  if (!(mockCoords.top >= 0)) {\n    violations.push(ClrViewportViolation.TOP);\n  }\n  if (!(mockCoords.left >= 0)) {\n    violations.push(ClrViewportViolation.LEFT);\n  }\n  if (!(mockCoords.bottom <= (window.innerHeight || document.documentElement.clientHeight))) {\n    violations.push(ClrViewportViolation.BOTTOM);\n  }\n  if (!(mockCoords.right <= (window.innerWidth || document.documentElement.clientWidth))) {\n    violations.push(ClrViewportViolation.RIGHT);\n  }\n\n  return violations;\n}\n"]}