carbon-components-angular 5.22.0 → 5.23.0

package/esm2020/popover/popover.directive.mjs

@@ -1,17 +1,14 @@
 import { Directive, EventEmitter, HostBinding, Input, Output } from "@angular/core";
+import { arrow, autoUpdate, computePosition, flip, offset } from "@floating-ui/dom";
 import * as i0 from "@angular/core";
-/**
- * Applies popover container styling to the element it is applied to. Get started with importing the module:
- *
- * ```typescript
- * import { PopoverModule } from 'carbon-components-angular';
- * ```
- *
- * [See demo](../../?path=/story/components-popover--basic)
- */
 export class PopoverContainer {
-    constructor(changeDetectorRef) {
+    constructor(elementRef, ngZone, renderer, changeDetectorRef) {
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.renderer = renderer;
         this.changeDetectorRef = changeDetectorRef;
+        this._align = "bottom";
+        this.alignmentClassPrefix = "cds--popover--";
         /**
          * Emits an event when the dialog is closed
          */
@@ -24,110 +21,229 @@ export class PopoverContainer {
          * Emits an event when the state of `isOpen` changes. Allows `isOpen` to be double bound
          */
         this.isOpenChange = new EventEmitter();
+        /**
+         * Show caret at the alignment position
+         */
         this.caret = true;
+        /**
+         * Enable drop shadow around the popover container
+         */
         this.dropShadow = true;
-        this.highContrast = false;
-        this.isOpen = false;
+        /**
+         * Enable high contrast for popover container
+         */
+        this.highContrast = true;
+        /**
+         * **Experimental**: Use floating-ui to position the tooltip
+         * This is not toggleable - should be sent once
+         */
+        this.autoAlign = false;
         this.containerClass = true;
-        this.align = "bottom";
-    }
-    // Top
-    get alignmentTopClass() {
-        return this.align === "top";
-    }
-    get alignmentTopLeftClass() {
-        return this.align === "top-left";
-    }
-    get alignmentTopRightClass() {
-        return this.align === "top-right";
-    }
-    // Bottom
-    get alignmentBottomClass() {
-        return this.align === "bottom";
-    }
-    get alignmentBottomLeftClass() {
-        return this.align === "bottom-left";
-    }
-    get alignmentBottomRightClass() {
-        return this.align === "bottom-right";
-    }
-    // Left
-    get alignmentLeftClass() {
-        return this.align === "left";
-    }
-    get alignmentLeftTopClass() {
-        return this.align === "left-top";
-    }
-    get alignmentLeftBottomClass() {
-        return this.align === "left-bottom";
-    }
-    // Right
-    get alignmentRightClass() {
-        return this.align === "right";
-    }
-    get alignmentRightTopClass() {
-        return this.align === "right-top";
+        this.isOpen = false;
     }
-    get alignmentRightBottomClass() {
-        return this.align === "right-bottom";
+    /**
+     * Set alignment of popover
+     * As of v5, `oldPlacements` are now deprecated in favor of Placements
+     *
+     * When `autoAlign` is set to `true`, alignment may change for best placement
+     */
+    set align(alignment) {
+        // If alignment is not passed, the default value will be `undefined`.
+        if (!alignment) {
+            return;
+        }
+        const previousAlignment = this._align;
+        switch (alignment) {
+            case "top-left":
+                this._align = "top-start";
+                break;
+            case "top-right":
+                this._align = "top-end";
+                break;
+            case "bottom-left":
+                this._align = "bottom-start";
+                break;
+            case "bottom-right":
+                this._align = "bottom-end";
+                break;
+            case "left-top":
+                this._align = "left-start";
+                break;
+            case "left-bottom":
+                this._align = "left-end";
+                break;
+            case "right-top":
+                this._align = "right-start";
+                break;
+            case "right-bottom":
+                this._align = "right-end";
+                break;
+            default:
+                this._align = alignment;
+                break;
+        }
+        this.updateAlignmentClass(this._align, previousAlignment);
     }
+    /**
+     * Handles emitting open/close event
+     * @param open - Is the popover container open
+     * @param event - Event
+     */
     handleChange(open, event) {
-        if (this.isOpen !== open) {
+        // We only emit the event when parameter has an event to keep existing behavior
+        if ((this.isOpen !== open) && event) {
             this.isOpenChange.emit(open);
         }
         if (open) {
-            this.onOpen.emit(event);
+            if (event) {
+                this.onOpen.emit(event);
+            }
+            // when auto alignment is enabled, use auto update to set the placement for the element
+            if (this.autoAlign) {
+                if (this.caretRef) {
+                    // Get caret offset/height property
+                    // Getting computed styles once every open, otherwise expensive.
+                    const computedStyle = getComputedStyle(this.caretRef);
+                    const offset = computedStyle.getPropertyValue("--cds-popover-offset");
+                    const height = computedStyle.getPropertyValue("--cds-popover-caret-height");
+                    this.caretOffset = (offset?.includes("px") ? Number(offset.split("px", 1)[0]) : Number(offset.split("rem", 1)[0]) * 16) || 10;
+                    this.caretHeight = (height?.includes("px") ? Number(height.split("px", 1)[0]) : Number(height.split("rem", 1)[0]) * 16) || 6;
+                }
+                if (this.elementRef.nativeElement && this.popoverContentRef) {
+                    this.unmountFloatingElement = autoUpdate(this.elementRef.nativeElement, this.popoverContentRef, this.recomputePosition.bind(this));
+                }
+            }
         }
         else {
-            this.onClose.emit(event);
+            this.cleanUp();
+            if (event) {
+                this.onClose.emit(event);
+            }
         }
         this.isOpen = open;
         this.changeDetectorRef.markForCheck();
     }
+    roundByDPR(value) {
+        const dpr = window.devicePixelRatio || 1;
+        return Math.round(value * dpr) / dpr;
+    }
+    /**
+     * Compute position of tooltip when autoAlign is enabled
+     */
+    recomputePosition() {
+        // Run outside of angular zone to avoid unnecessary change detection and rely on floating-ui
+        this.ngZone.runOutsideAngular(async () => {
+            const { x, y, placement, middlewareData } = await computePosition(this.elementRef.nativeElement, this.popoverContentRef, {
+                placement: this._align,
+                strategy: "fixed",
+                middleware: [
+                    offset(this.caretOffset),
+                    flip({ fallbackAxisSideDirection: "start" }),
+                    arrow({ element: this.caretRef })
+                ]
+            });
+            const previousAlignment = this._align;
+            this._align = placement;
+            this.updateAlignmentClass(this._align, previousAlignment);
+            // Using CSSOM to manipulate CSS to avoid content security policy inline-src
+            // https://github.com/w3c/webappsec-csp/issues/212
+            Object.assign(this.popoverContentRef.style, {
+                position: "fixed",
+                top: "0",
+                left: "0",
+                // Using transform instead of top/left position to improve performance
+                transform: `translate(${this.roundByDPR(x)}px,${this.roundByDPR(y)}px)`
+            });
+            if (middlewareData.arrow) {
+                const { x: arrowX, y: arrowY } = middlewareData.arrow;
+                const staticSide = {
+                    top: "bottom",
+                    right: "left",
+                    bottom: "top",
+                    left: "right"
+                }[placement.split("-")[0]];
+                this.caretRef.style.left = arrowX != null ? `${arrowX}px` : "";
+                this.caretRef.style.top = arrowY != null ? `${arrowY}px` : "";
+                this.caretRef.style.right = "";
+                this.caretRef.style.bottom = "";
+                if (staticSide) {
+                    this.caretRef.style[staticSide] = `${-this.caretHeight}px`;
+                }
+            }
+        });
+    }
+    /**
+     * Close the popover and reopen it with updated values without emitting an event
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        // Close and reopen the popover, handle alignment/programmatic open/close
+        const originalState = this.isOpen;
+        this.handleChange(false);
+        // Ignore first change since content is not initialized
+        if (changes.autoAlign && !changes.autoAlign.firstChange) {
+            // Reset the inline styles
+            this.popoverContentRef = this.elementRef.nativeElement.querySelector(".cds--popover-content");
+            this.popoverContentRef.setAttribute("style", "");
+            this.caretRef = this.elementRef.nativeElement.querySelector("span.cds--popover-caret");
+        }
+        this.handleChange(originalState);
+    }
+    /**
+     * Handle initialization of element
+     */
+    ngAfterViewInit() {
+        this.initializeReferences();
+    }
+    initializeReferences() {
+        this.updateAlignmentClass(this._align);
+        // Initialize html references since they will not change and are required for popover components
+        this.popoverContentRef = this.elementRef.nativeElement.querySelector(".cds--popover-content");
+        this.caretRef = this.elementRef.nativeElement.querySelector("span.cds--popover-caret");
+        // Handle initial isOpen
+        this.handleChange(this.isOpen);
+    }
+    /**
+     * Clean up
+     */
+    ngOnDestroy() {
+        this.cleanUp();
+    }
+    /**
+     * Clean up `autoUpdate` if auto alignment is enabled
+     */
+    cleanUp() {
+        if (this.unmountFloatingElement) {
+            this.unmountFloatingElement();
+        }
+        this.unmountFloatingElement = undefined;
+    }
+    /**
+     * Replace existing previous alignment class with new
+     * @param previousAlignment
+     */
+    updateAlignmentClass(newAlignment, previousAlignment) {
+        if (this.elementRef.nativeElement && previousAlignment !== newAlignment) {
+            const regexp = new RegExp("right|top|left|bottom");
+            // Since we are constantly switching, it's safer to delete all matching class names
+            this.elementRef.nativeElement.classList.forEach(className => {
+                if (regexp.test(className)) {
+                    this.renderer.removeClass(this.elementRef.nativeElement, `${className}`);
+                }
+            });
+            this.renderer.addClass(this.elementRef.nativeElement, `${this.alignmentClassPrefix}${newAlignment}`);
+        }
+    }
 }
-PopoverContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PopoverContainer, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
-PopoverContainer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: PopoverContainer, selector: "[cdsPopover], [ibmPopover]", inputs: { caret: "caret", dropShadow: "dropShadow", highContrast: "highContrast", isOpen: "isOpen", align: "align" }, outputs: { onClose: "onClose", onOpen: "onOpen", isOpenChange: "isOpenChange" }, host: { properties: { "class.cds--popover--top": "this.alignmentTopClass", "class.cds--popover--top-left": "this.alignmentTopLeftClass", "class.cds--popover--top-right": "this.alignmentTopRightClass", "class.cds--popover--bottom": "this.alignmentBottomClass", "class.cds--popover--bottom-left": "this.alignmentBottomLeftClass", "class.cds--popover--bottom-right": "this.alignmentBottomRightClass", "class.cds--popover--left": "this.alignmentLeftClass", "class.cds--popover--left-top": "this.alignmentLeftTopClass", "class.cds--popover--left-bottom": "this.alignmentLeftBottomClass", "class.cds--popover--right": "this.alignmentRightClass", "class.cds--popover--right-top": "this.alignmentRightTopClass", "class.cds--popover--right-bottom": "this.alignmentRightBottomClass", "class.cds--popover--caret": "this.caret", "class.cds--popover--drop-shadow": "this.dropShadow", "class.cds--popover--high-contrast": "this.highContrast", "class.cds--popover--open": "this.isOpen", "class.cds--popover-container": "this.containerClass" } }, ngImport: i0 });
+PopoverContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PopoverContainer, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+PopoverContainer.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: PopoverContainer, selector: "[cdsPopover], [ibmPopover]", inputs: { align: "align", caret: "caret", dropShadow: "dropShadow", highContrast: "highContrast", autoAlign: "autoAlign", isOpen: "isOpen" }, outputs: { onClose: "onClose", onOpen: "onOpen", isOpenChange: "isOpenChange" }, host: { properties: { "class.cds--popover--caret": "this.caret", "class.cds--popover--drop-shadow": "this.dropShadow", "class.cds--popover--high-contrast": "this.highContrast", "class.cds--popover--auto-align": "this.autoAlign", "class.cds--popover-container": "this.containerClass", "class.cds--popover--open": "this.isOpen" } }, usesOnChanges: true, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PopoverContainer, decorators: [{
             type: Directive,
             args: [{
                     selector: "[cdsPopover], [ibmPopover]"
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { alignmentTopClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--top"]
-            }], alignmentTopLeftClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--top-left"]
-            }], alignmentTopRightClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--top-right"]
-            }], alignmentBottomClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--bottom"]
-            }], alignmentBottomLeftClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--bottom-left"]
-            }], alignmentBottomRightClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--bottom-right"]
-            }], alignmentLeftClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--left"]
-            }], alignmentLeftTopClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--left-top"]
-            }], alignmentLeftBottomClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--left-bottom"]
-            }], alignmentRightClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--right"]
-            }], alignmentRightTopClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--right-top"]
-            }], alignmentRightBottomClass: [{
-                type: HostBinding,
-                args: ["class.cds--popover--right-bottom"]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { align: [{
+                type: Input
             }], onClose: [{
                 type: Output
             }], onOpen: [{
@@ -149,15 +265,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                 args: ["class.cds--popover--high-contrast"]
             }, {
                 type: Input
-            }], isOpen: [{
+            }], autoAlign: [{
                 type: HostBinding,
-                args: ["class.cds--popover--open"]
+                args: ["class.cds--popover--auto-align"]
             }, {
                 type: Input
             }], containerClass: [{
                 type: HostBinding,
                 args: ["class.cds--popover-container"]
-            }], align: [{
+            }], isOpen: [{
                 type: Input
+            }, {
+                type: HostBinding,
+                args: ["class.cds--popover--open"]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.directive.js","sourceRoot":"","sources":["../../../src/popover/popover.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectorRef,\n\tDirective,\n\tEventEmitter,\n\tHostBinding,\n\tInput,\n\tOutput\n} from \"@angular/core\";\n\n/**\n * Applies popover container styling to the element it is applied to. Get started with importing the module:\n *\n * ```typescript\n * import { PopoverModule } from 'carbon-components-angular';\n * ```\n *\n * [See demo](../../?path=/story/components-popover--basic)\n */\n@Directive({\n\tselector: \"[cdsPopover], [ibmPopover]\"\n})\nexport class PopoverContainer {\n\t// Top\n\t@HostBinding(\"class.cds--popover--top\") get alignmentTopClass() {\n\t\treturn this.align === \"top\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--top-left\") get alignmentTopLeftClass() {\n\t\treturn this.align === \"top-left\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--top-right\") get alignmentTopRightClass() {\n\t\treturn this.align === \"top-right\";\n\t}\n\n\t// Bottom\n\t@HostBinding(\"class.cds--popover--bottom\") get alignmentBottomClass() {\n\t\treturn this.align === \"bottom\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--bottom-left\") get alignmentBottomLeftClass() {\n\t\treturn this.align === \"bottom-left\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--bottom-right\") get alignmentBottomRightClass() {\n\t\treturn this.align === \"bottom-right\";\n\t}\n\n\t// Left\n\t@HostBinding(\"class.cds--popover--left\") get alignmentLeftClass() {\n\t\treturn this.align === \"left\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--left-top\") get alignmentLeftTopClass() {\n\t\treturn this.align === \"left-top\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--left-bottom\") get alignmentLeftBottomClass() {\n\t\treturn this.align === \"left-bottom\";\n\t}\n\n\t// Right\n\t@HostBinding(\"class.cds--popover--right\") get alignmentRightClass() {\n\t\treturn this.align === \"right\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--right-top\") get alignmentRightTopClass() {\n\t\treturn this.align === \"right-top\";\n\t}\n\n\t@HostBinding(\"class.cds--popover--right-bottom\") get alignmentRightBottomClass() {\n\t\treturn this.align === \"right-bottom\";\n\t}\n\n\t/**\n\t * Emits an event when the dialog is closed\n\t */\n\t@Output() onClose: EventEmitter<Event> = new EventEmitter();\n\t/**\n\t * Emits an event when the dialog is opened\n\t */\n\t@Output() onOpen: EventEmitter<Event> = new EventEmitter();\n\t/**\n\t * Emits an event when the state of `isOpen` changes. Allows `isOpen` to be double bound\n\t */\n\t@Output() isOpenChange = new EventEmitter<boolean>();\n\n\t@HostBinding(\"class.cds--popover--caret\") @Input() caret = true;\n\t@HostBinding(\"class.cds--popover--drop-shadow\") @Input() dropShadow = true;\n\t@HostBinding(\"class.cds--popover--high-contrast\") @Input() highContrast = false;\n\t@HostBinding(\"class.cds--popover--open\") @Input() isOpen = false;\n\n\t@HostBinding(\"class.cds--popover-container\") containerClass = true;\n\t@Input() align: \"top\" | \"top-left\" | \"top-right\" |\n\t\t\"bottom\" | \"bottom-left\" | \"bottom-right\" |\n\t\t\"left\" | \"left-bottom\" | \"left-top\" |\n\t\t\"right\" | \"right-bottom\" | \"right-top\" = \"bottom\";\n\n\tconstructor(private changeDetectorRef: ChangeDetectorRef) {}\n\n\thandleChange(open: boolean, event: Event) {\n\t\tif (this.isOpen !== open) {\n\t\t\tthis.isOpenChange.emit(open);\n\t\t}\n\n\t\tif (open) {\n\t\t\tthis.onOpen.emit(event);\n\t\t} else {\n\t\t\tthis.onClose.emit(event);\n\t\t}\n\t\tthis.isOpen = open;\n\t\tthis.changeDetectorRef.markForCheck();\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.directive.js","sourceRoot":"","sources":["../../../src/popover/popover.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tAfterViewInit,\n\tChangeDetectorRef,\n\tDirective,\n\tElementRef,\n\tEventEmitter,\n\tHostBinding,\n\tInput,\n\tNgZone,\n\tOnChanges,\n\tOnDestroy,\n\tOutput,\n\tRenderer2,\n\tSimpleChanges\n} from \"@angular/core\";\nimport {\n\tarrow,\n\tautoUpdate,\n\tcomputePosition,\n\tflip,\n\toffset,\n\tPlacement\n} from \"@floating-ui/dom\";\n\n// Deprecated popover alignments\ntype oldPlacement = \"top-left\"\n\t| \"top-right\"\n\t| \"bottom-left\"\n\t| \"bottom-right\"\n\t| \"left-bottom\"\n\t| \"left-top\"\n\t| \"right-bottom\"\n\t| \"right-top\";\n\n@Directive({\n\tselector: \"[cdsPopover], [ibmPopover]\"\n})\nexport class PopoverContainer implements AfterViewInit, OnChanges, OnDestroy {\n\t/**\n\t * Set alignment of popover\n\t * As of v5, `oldPlacements` are now deprecated in favor of Placements\n\t *\n\t * When `autoAlign` is set to `true`, alignment may change for best placement\n\t */\n\t@Input() set align(alignment: oldPlacement | Placement) {\n\t\t// If alignment is not passed, the default value will be `undefined`.\n\t\tif (!alignment) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst previousAlignment = this._align;\n\t\tswitch (alignment) {\n\t\t\tcase \"top-left\":\n\t\t\t\tthis._align = \"top-start\";\n\t\t\t\tbreak;\n\t\t\tcase \"top-right\":\n\t\t\t\tthis._align = \"top-end\";\n\t\t\t\tbreak;\n\t\t\tcase \"bottom-left\":\n\t\t\t\tthis._align = \"bottom-start\";\n\t\t\t\tbreak;\n\t\t\tcase \"bottom-right\":\n\t\t\t\tthis._align = \"bottom-end\";\n\t\t\t\tbreak;\n\t\t\tcase \"left-top\":\n\t\t\t\tthis._align = \"left-start\";\n\t\t\t\tbreak;\n\t\t\tcase \"left-bottom\":\n\t\t\t\tthis._align = \"left-end\";\n\t\t\t\tbreak;\n\t\t\tcase \"right-top\":\n\t\t\t\tthis._align = \"right-start\";\n\t\t\t\tbreak;\n\t\t\tcase \"right-bottom\":\n\t\t\t\tthis._align = \"right-end\";\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthis._align = alignment as Placement;\n\t\t\t\tbreak;\n\t\t}\n\t\tthis.updateAlignmentClass(this._align, previousAlignment);\n\t}\n\n\t_align: Placement = \"bottom\";\n\treadonly alignmentClassPrefix = \"cds--popover--\";\n\n\t/**\n\t * Emits an event when the dialog is closed\n\t */\n\t@Output() onClose: EventEmitter<Event> = new EventEmitter();\n\t/**\n\t * Emits an event when the dialog is opened\n\t */\n\t@Output() onOpen: EventEmitter<Event> = new EventEmitter();\n\t/**\n\t * Emits an event when the state of `isOpen` changes. Allows `isOpen` to be double bound\n\t */\n\t@Output() isOpenChange = new EventEmitter<boolean>();\n\t/**\n\t * Show caret at the alignment position\n\t */\n\t@HostBinding(\"class.cds--popover--caret\") @Input() caret = true;\n\t/**\n\t * Enable drop shadow around the popover container\n\t */\n\t@HostBinding(\"class.cds--popover--drop-shadow\") @Input() dropShadow = true;\n\t/**\n\t * Enable high contrast for popover container\n\t */\n\t@HostBinding(\"class.cds--popover--high-contrast\") @Input() highContrast = true;\n\t/**\n\t * **Experimental**: Use floating-ui to position the tooltip\n\t * This is not toggleable - should be sent once\n\t */\n\t@HostBinding(\"class.cds--popover--auto-align\") @Input() autoAlign = false;\n\t@HostBinding(\"class.cds--popover-container\") containerClass = true;\n\t@Input() @HostBinding(\"class.cds--popover--open\") isOpen = false;\n\n\tprotected popoverContentRef: HTMLElement;\n\tprotected caretRef: HTMLElement;\n\tprotected caretOffset: number;\n\tprotected caretHeight: number;\n\tprotected unmountFloatingElement: Function;\n\n\tconstructor(\n\t\tprotected elementRef: ElementRef,\n\t\tprotected ngZone: NgZone,\n\t\tprotected renderer: Renderer2,\n\t\tprotected changeDetectorRef: ChangeDetectorRef\n\t) {}\n\n\t/**\n\t * Handles emitting open/close event\n\t * @param open - Is the popover container open\n\t * @param event - Event\n\t */\n\thandleChange(open: boolean, event?: Event) {\n\t\t// We only emit the event when parameter has an event to keep existing behavior\n\t\tif ((this.isOpen !== open) && event) {\n\t\t\tthis.isOpenChange.emit(open);\n\t\t}\n\n\t\tif (open) {\n\t\t\tif (event) {\n\t\t\t\tthis.onOpen.emit(event);\n\t\t\t}\n\n\t\t\t// when auto alignment is enabled, use auto update to set the placement for the element\n\t\t\tif (this.autoAlign) {\n\t\t\t\tif (this.caretRef) {\n\t\t\t\t\t// Get caret offset/height property\n\t\t\t\t\t// Getting computed styles once every open, otherwise expensive.\n\t\t\t\t\tconst computedStyle = getComputedStyle(this.caretRef);\n\t\t\t\t\tconst offset = computedStyle.getPropertyValue(\"--cds-popover-offset\");\n\t\t\t\t\tconst height = computedStyle.getPropertyValue(\"--cds-popover-caret-height\");\n\t\t\t\t\tthis.caretOffset = (offset?.includes(\"px\") ? Number(offset.split(\"px\", 1)[0]) : Number(offset.split(\"rem\", 1)[0]) * 16) || 10;\n\t\t\t\t\tthis.caretHeight = (height?.includes(\"px\") ? Number(height.split(\"px\", 1)[0]) : Number(height.split(\"rem\", 1)[0]) * 16) || 6;\n\t\t\t\t}\n\t\t\t\tif (this.elementRef.nativeElement && this.popoverContentRef) {\n\t\t\t\t\tthis.unmountFloatingElement = autoUpdate(\n\t\t\t\t\t\tthis.elementRef.nativeElement,\n\t\t\t\t\t\tthis.popoverContentRef,\n\t\t\t\t\t\tthis.recomputePosition.bind(this)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthis.cleanUp();\n\t\t\tif (event) {\n\t\t\t\tthis.onClose.emit(event);\n\t\t\t}\n\t\t}\n\t\tthis.isOpen = open;\n\t\tthis.changeDetectorRef.markForCheck();\n\t}\n\n\troundByDPR(value) {\n\t\tconst dpr = window.devicePixelRatio || 1;\n\t\treturn Math.round(value * dpr) / dpr;\n\t}\n\n\t/**\n\t * Compute position of tooltip when autoAlign is enabled\n\t */\n\trecomputePosition() {\n\t\t// Run outside of angular zone to avoid unnecessary change detection and rely on floating-ui\n\t\tthis.ngZone.runOutsideAngular(async () => {\n\t\t\tconst { x, y, placement, middlewareData } = await computePosition(\n\t\t\t\tthis.elementRef.nativeElement,\n\t\t\t\tthis.popoverContentRef,\n\t\t\t\t{\n\t\t\t\t\tplacement: this._align,\n\t\t\t\t\tstrategy: \"fixed\",\n\t\t\t\t\tmiddleware: [\n\t\t\t\t\t\toffset(this.caretOffset),\n\t\t\t\t\t\tflip({ fallbackAxisSideDirection: \"start\" }),\n\t\t\t\t\t\tarrow({ element: this.caretRef })\n\t\t\t\t\t]\n\t\t\t\t});\n\n\t\t\tconst previousAlignment = this._align;\n\t\t\tthis._align = placement;\n\t\t\tthis.updateAlignmentClass(this._align, previousAlignment);\n\n\t\t\t// Using CSSOM to manipulate CSS to avoid content security policy inline-src\n\t\t\t// https://github.com/w3c/webappsec-csp/issues/212\n\t\t\tObject.assign(this.popoverContentRef.style, {\n\t\t\t\tposition: \"fixed\",\n\t\t\t\ttop: \"0\",\n\t\t\t\tleft: \"0\",\n\t\t\t\t// Using transform instead of top/left position to improve performance\n\t\t\t\ttransform: `translate(${this.roundByDPR(x)}px,${this.roundByDPR(y)}px)`\n\t\t\t});\n\n\t\t\tif (middlewareData.arrow) {\n\t\t\t\tconst { x: arrowX, y: arrowY } = middlewareData.arrow;\n\n\t\t\t\tconst staticSide = {\n\t\t\t\t\ttop: \"bottom\",\n\t\t\t\t\tright: \"left\",\n\t\t\t\t\tbottom: \"top\",\n\t\t\t\t\tleft: \"right\"\n\t\t\t\t}[placement.split(\"-\")[0]];\n\n\t\t\t\tthis.caretRef.style.left = arrowX != null ? `${arrowX}px` : \"\";\n\t\t\t\tthis.caretRef.style.top = arrowY != null ? `${arrowY}px` : \"\";\n\t\t\t\tthis.caretRef.style.right = \"\";\n\t\t\t\tthis.caretRef.style.bottom = \"\";\n\n\t\t\t\tif (staticSide) {\n\t\t\t\t\tthis.caretRef.style[staticSide] = `${-this.caretHeight}px`;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Close the popover and reopen it with updated values without emitting an event\n\t * @param changes\n\t */\n\tngOnChanges(changes: SimpleChanges): void {\n\t\t// Close and reopen the popover, handle alignment/programmatic open/close\n\t\tconst originalState = this.isOpen;\n\t\tthis.handleChange(false);\n\n\t\t// Ignore first change since content is not initialized\n\t\tif (changes.autoAlign && !changes.autoAlign.firstChange) {\n\t\t\t// Reset the inline styles\n\t\t\tthis.popoverContentRef = this.elementRef.nativeElement.querySelector(\".cds--popover-content\");\n\t\t\tthis.popoverContentRef.setAttribute(\"style\", \"\");\n\t\t\tthis.caretRef = this.elementRef.nativeElement.querySelector(\"span.cds--popover-caret\");\n\t\t}\n\n\t\tthis.handleChange(originalState);\n\t}\n\n\t/**\n\t * Handle initialization of element\n\t */\n\tngAfterViewInit(): void {\n\t\tthis.initializeReferences();\n\t}\n\n\tinitializeReferences(): void {\n\t\tthis.updateAlignmentClass(this._align);\n\n\t\t// Initialize html references since they will not change and are required for popover components\n\t\tthis.popoverContentRef = this.elementRef.nativeElement.querySelector(\".cds--popover-content\");\n\t\tthis.caretRef = this.elementRef.nativeElement.querySelector(\"span.cds--popover-caret\");\n\n\t\t// Handle initial isOpen\n\t\tthis.handleChange(this.isOpen);\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tngOnDestroy(): void {\n\t\tthis.cleanUp();\n\t}\n\n\t/**\n\t * Clean up `autoUpdate` if auto alignment is enabled\n\t */\n\tcleanUp() {\n\t\tif (this.unmountFloatingElement) {\n\t\t\tthis.unmountFloatingElement();\n\t\t}\n\t\tthis.unmountFloatingElement = undefined;\n\t}\n\n\t/**\n\t * Replace existing previous alignment class with new\n\t * @param previousAlignment\n\t */\n\tupdateAlignmentClass(newAlignment: string, previousAlignment?: string) {\n\t\tif (this.elementRef.nativeElement && previousAlignment !== newAlignment) {\n\t\t\tconst regexp = new RegExp(\"right|top|left|bottom\");\n\t\t\t// Since we are constantly switching, it's safer to delete all matching class names\n\t\t\tthis.elementRef.nativeElement.classList.forEach(className => {\n\t\t\t\tif (regexp.test(className)) {\n\t\t\t\t\tthis.renderer.removeClass(this.elementRef.nativeElement, `${className}`);\n\t\t\t\t}\n\t\t\t});\n\t\t\tthis.renderer.addClass(this.elementRef.nativeElement, `${this.alignmentClassPrefix}${newAlignment}`);\n\t\t}\n\t}\n}\n"]}

package/esm2020/toggletip/toggletip.component.mjs

@@ -14,11 +14,12 @@ import * as i1 from "carbon-components-angular/popover";
  * [See demo](../../?path=/story/components-toggletip--basic)
  */
 export class Toggletip extends PopoverContainer {
-    constructor(hostElement, renderer, ref) {
-        super(ref);
+    constructor(hostElement, ngZone, renderer, changeDetectorRef) {
+        super(hostElement, ngZone, renderer, changeDetectorRef);
         this.hostElement = hostElement;
+        this.ngZone = ngZone;
         this.renderer = renderer;
-        this.ref = ref;
+        this.changeDetectorRef = changeDetectorRef;
         this.id = `tooltip-${Toggletip.toggletipCounter++}`;
         this.toggletipClass = true;
         this.isOpen = false;
@@ -27,6 +28,7 @@ export class Toggletip extends PopoverContainer {
         this.dropShadow = false;
     }
     ngAfterViewInit() {
+        this.initializeReferences();
         // Listen for click events on trigger
         fromEvent(this.btn.nativeElement, "click")
             .subscribe((event) => {
@@ -67,7 +69,7 @@ export class Toggletip extends PopoverContainer {
     }
 }
 Toggletip.toggletipCounter = 0;
-Toggletip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Toggletip, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+Toggletip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Toggletip, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
 Toggletip.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: Toggletip, selector: "cds-toggletip, ibm-toggletip", inputs: { id: "id", isOpen: "isOpen" }, host: { listeners: { "keyup": "hostkeys($event)" }, properties: { "class.cds--toggletip": "this.toggletipClass", "class.cds--toggletip--open": "this.isOpen" } }, queries: [{ propertyName: "btn", first: true, predicate: ToggletipButton, descendants: true, read: ElementRef }], usesInheritance: true, ngImport: i0, template: `
 		<ng-content select="[cdsToggletipButton]"></ng-content>
 		<cds-popover-content>
@@ -86,7 +88,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
 		</cds-popover-content>
 	`
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { id: [{
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { id: [{
                 type: Input
             }], toggletipClass: [{
                 type: HostBinding,
@@ -103,4 +105,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                 type: HostListener,
                 args: ["keyup", ["$event"]]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tooltip/definition-tooptip.component.mjs

@@ -12,14 +12,13 @@ import * as i1 from "@angular/common";
  * [See demo](../../?path=/story/components-tooltip-definition--basic)
  */
 export class TooltipDefinition extends PopoverContainer {
-    constructor(ref) {
-        super(ref);
-        this.ref = ref;
+    constructor(elementRef, ngZone, renderer, changeDetectorRef) {
+        super(elementRef, ngZone, renderer, changeDetectorRef);
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        this.changeDetectorRef = changeDetectorRef;
         this.id = `tooltip-definition-${TooltipDefinition.tooltipCount++}`;
-        /**
-         * Override alignment options
-         */
-        this.align = "bottom";
         this.highContrast = true;
         this.dropShadow = false;
     }
@@ -43,8 +42,8 @@ export class TooltipDefinition extends PopoverContainer {
     }
 }
 TooltipDefinition.tooltipCount = 0;
-TooltipDefinition.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TooltipDefinition, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-TooltipDefinition.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TooltipDefinition, selector: "cds-tooltip-definition, ibm-tooltip-definition", inputs: { id: "id", align: "align", description: "description" }, host: { listeners: { "keyup": "hostkeys($event)", "mouseleave": "mouseleave($event)" } }, usesInheritance: true, ngImport: i0, template: `
+TooltipDefinition.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TooltipDefinition, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TooltipDefinition.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: TooltipDefinition, selector: "cds-tooltip-definition, ibm-tooltip-definition", inputs: { id: "id", description: "description" }, host: { listeners: { "keyup": "hostkeys($event)", "mouseleave": "mouseleave($event)" } }, usesInheritance: true, ngImport: i0, template: `
 		<button
 			class="cds--definition-term"
 			[attr.aria-controls]="id"
@@ -63,8 +62,9 @@ TooltipDefinition.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", vers
 			<span class="cds--popover-content cds--definition-tooltip">
 				<ng-container *ngIf="!isTemplate(description)">{{description}}</ng-container>
 				<ng-template *ngIf="isTemplate(description)" [ngTemplateOutlet]="description"></ng-template>
+				<span *ngIf="autoAlign" class="cds--popover-caret cds--popover--auto-align"></span>
 			</span>
-			<span class="cds--popover-caret"></span>
+			<span *ngIf="!autoAlign" class="cds--popover-caret"></span>
 		</span>
 	`, isInline: true, dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TooltipDefinition, decorators: [{
@@ -91,14 +91,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
 			<span class="cds--popover-content cds--definition-tooltip">
 				<ng-container *ngIf="!isTemplate(description)">{{description}}</ng-container>
 				<ng-template *ngIf="isTemplate(description)" [ngTemplateOutlet]="description"></ng-template>
+				<span *ngIf="autoAlign" class="cds--popover-caret cds--popover--auto-align"></span>
 			</span>
-			<span class="cds--popover-caret"></span>
+			<span *ngIf="!autoAlign" class="cds--popover-caret"></span>
 		</span>
 	`
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { id: [{
-                type: Input
-            }], align: [{
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { id: [{
                 type: Input
             }], description: [{
                 type: Input
@@ -109,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                 type: HostListener,
                 args: ["mouseleave", ["$event"]]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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