@clr/angular 12.0.9 → 13.0.0

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

@@ -0,0 +1,177 @@
+/*
+ * 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 { Component, Inject, Input, Optional, PLATFORM_ID } from '@angular/core';
+import { AbstractPopover } from '../common/abstract-popover';
+import { POPOVER_HOST_ANCHOR } from '../common/popover-host-anchor.token';
+import { SIGNPOST_POSITIONS } from './signpost-positions';
+import { UNIQUE_ID, UNIQUE_ID_PROVIDER } from '../../utils/id-generator/id-generator.service';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../utils/i18n/common-strings.service";
+import * as i2 from "./providers/signpost-id.service";
+import * as i3 from "./providers/signpost-focus-manager.service";
+import * as i4 from "../../icon/icon";
+// aka where the arrow / pointer is at in relation to the anchor
+const POSITIONS = [
+    'top-left',
+    'top-middle',
+    'top-right',
+    'right-top',
+    'right-middle',
+    'right-bottom',
+    'bottom-right',
+    'bottom-middle',
+    'bottom-left',
+    'left-bottom',
+    'left-middle',
+    'left-top',
+];
+export class ClrSignpostContent extends AbstractPopover {
+    constructor(injector, parentHost, commonStrings, signpostContentId, signpostIdService, signpostFocusManager, platformId, document) {
+        super(injector, parentHost);
+        this.commonStrings = commonStrings;
+        this.signpostContentId = signpostContentId;
+        this.signpostIdService = signpostIdService;
+        this.signpostFocusManager = signpostFocusManager;
+        this.platformId = platformId;
+        if (!parentHost) {
+            throw new Error('clr-signpost-content should only be used inside of a clr-signpost');
+        }
+        // Defaults
+        this.position = 'right-middle';
+        this.closeOnOutsideClick = true;
+        this.signpostIdService.setId(signpostContentId);
+        this.document = document;
+    }
+    /**********
+     *
+     * @description
+     * Close function that uses the signpost instance to toggle the state of the content popover.
+     *
+     */
+    close() {
+        this.toggleService.open = false;
+    }
+    get position() {
+        return this._position;
+    }
+    /*********
+     *
+     * @description
+     * A setter for the position of the ClrSignpostContent popover. This is a combination of the following:
+     * - anchorPoint - where on the trigger to anchor the ClrSignpostContent
+     * - popoverPoint - where on the ClrSignpostContent container to align with the anchorPoint
+     * - offsetY - where on the Y axis to align the ClrSignpostContent so it meets specs
+     * - offsetX - where on the X axis to align the ClrSignpostContent so it meets specs
+     * There are 12 possible positions to place a ClrSignpostContent container:
+     * - top-left
+     * - top-middle
+     * - top-right
+     * - right-top
+     * - right-middle
+     * - right-bottom
+     * - bottom-right
+     * - bottom-middle
+     * - bottom-left
+     * - left-bottom
+     * - left-middle
+     * - left-top
+     *
+     * I think of it as follows for 'top-left' -> CONTAINER_SIDE-SIDE_POSITION. In this case CONTAINER_SIDE is 'top'
+     * meaning the top of the trigger icon (above the icon that hides/shows) the ClrSignpostContent. And, SIDE_POSITION
+     * is 'left' meaning two things: 1) the ClrSignpostContent container extends to the left and 2) the 'arrow/pointer'
+     * linking the SingpostContent to the trigger points down at the horizontal center of the trigger icon.
+     *
+     * @param newPosition
+     */
+    set position(position) {
+        // Ugh
+        this.renderer.removeClass(this.el.nativeElement, this.position);
+        if (position && POSITIONS.indexOf(position) > -1) {
+            this._position = position;
+        }
+        else {
+            this._position = 'right-middle';
+        }
+        // Ugh
+        this.renderer.addClass(this.el.nativeElement, this.position);
+        const setPosition = SIGNPOST_POSITIONS[this.position];
+        this.anchorPoint = setPosition.anchorPoint;
+        this.popoverPoint = setPosition.popoverPoint;
+        this.popoverOptions.offsetY = setPosition.offsetY;
+        this.popoverOptions.offsetX = setPosition.offsetX;
+    }
+    ngOnDestroy() {
+        if (isPlatformBrowser(this.platformId) && this.el.nativeElement.contains(this.document.activeElement)) {
+            this.signpostFocusManager.focusTrigger();
+        }
+    }
+}
+ClrSignpostContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostContent, deps: [{ token: i0.Injector }, { token: POPOVER_HOST_ANCHOR, optional: true }, { token: i1.ClrCommonStringsService }, { token: UNIQUE_ID }, { token: i2.SignpostIdService }, { token: i3.SignpostFocusManager }, { token: PLATFORM_ID }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+ClrSignpostContent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrSignpostContent, selector: "clr-signpost-content", inputs: { position: ["clrPosition", "position"] }, host: { properties: { "class.signpost-content": "true", "id": "signpostContentId" } }, providers: [UNIQUE_ID_PROVIDER], usesInheritance: true, ngImport: i0, template: `
+    <div class="signpost-wrap">
+      <div class="popover-pointer"></div>
+      <div class="signpost-content-header">
+        <button
+          type="button"
+          [attr.aria-label]="commonStrings.keys.signpostClose"
+          class="signpost-action close"
+          (click)="close()"
+          [attr.aria-controls]="signpostContentId"
+        >
+          <cds-icon shape="window-close" [attr.title]="commonStrings.keys.close"></cds-icon>
+        </button>
+      </div>
+      <div class="signpost-content-body">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `, isInline: true, directives: [{ type: i4.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostContent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-signpost-content',
+                    template: `
+    <div class="signpost-wrap">
+      <div class="popover-pointer"></div>
+      <div class="signpost-content-header">
+        <button
+          type="button"
+          [attr.aria-label]="commonStrings.keys.signpostClose"
+          class="signpost-action close"
+          (click)="close()"
+          [attr.aria-controls]="signpostContentId"
+        >
+          <cds-icon shape="window-close" [attr.title]="commonStrings.keys.close"></cds-icon>
+        </button>
+      </div>
+      <div class="signpost-content-body">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `,
+                    host: { '[class.signpost-content]': 'true', '[id]': 'signpostContentId' },
+                    providers: [UNIQUE_ID_PROVIDER],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.ElementRef, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [POPOVER_HOST_ANCHOR]
+                }] }, { type: i1.ClrCommonStringsService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [UNIQUE_ID]
+                }] }, { type: i2.SignpostIdService }, { type: i3.SignpostFocusManager }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { position: [{
+                type: Input,
+                args: ['clrPosition']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signpost-content.js","sourceRoot":"","sources":["../../../../../projects/angular/src/popover/signpost/signpost-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 */\nimport { Component, ElementRef, Inject, Injector, Input, Optional, OnDestroy, PLATFORM_ID } from '@angular/core';\n\nimport { AbstractPopover } from '../common/abstract-popover';\nimport { POPOVER_HOST_ANCHOR } from '../common/popover-host-anchor.token';\n\nimport { SIGNPOST_POSITIONS } from './signpost-positions';\nimport { ClrCommonStringsService } from '../../utils/i18n/common-strings.service';\nimport { UNIQUE_ID, UNIQUE_ID_PROVIDER } from '../../utils/id-generator/id-generator.service';\nimport { SignpostIdService } from './providers/signpost-id.service';\nimport { SignpostFocusManager } from './providers/signpost-focus-manager.service';\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\n\n// aka where the arrow / pointer is at in relation to the anchor\nconst POSITIONS: string[] = [\n  'top-left',\n  'top-middle',\n  'top-right',\n  'right-top',\n  'right-middle', // default\n  'right-bottom',\n  'bottom-right',\n  'bottom-middle',\n  'bottom-left',\n  'left-bottom',\n  'left-middle',\n  'left-top',\n];\n\n@Component({\n  selector: 'clr-signpost-content',\n  template: `\n    <div class=\"signpost-wrap\">\n      <div class=\"popover-pointer\"></div>\n      <div class=\"signpost-content-header\">\n        <button\n          type=\"button\"\n          [attr.aria-label]=\"commonStrings.keys.signpostClose\"\n          class=\"signpost-action close\"\n          (click)=\"close()\"\n          [attr.aria-controls]=\"signpostContentId\"\n        >\n          <cds-icon shape=\"window-close\" [attr.title]=\"commonStrings.keys.close\"></cds-icon>\n        </button>\n      </div>\n      <div class=\"signpost-content-body\">\n        <ng-content></ng-content>\n      </div>\n    </div>\n  `,\n  host: { '[class.signpost-content]': 'true', '[id]': 'signpostContentId' },\n  providers: [UNIQUE_ID_PROVIDER],\n})\nexport class ClrSignpostContent extends AbstractPopover implements OnDestroy {\n  private document: Document;\n\n  constructor(\n    injector: Injector,\n    @Optional()\n    @Inject(POPOVER_HOST_ANCHOR)\n    parentHost: ElementRef,\n    public commonStrings: ClrCommonStringsService,\n    @Inject(UNIQUE_ID) public signpostContentId: string,\n    private signpostIdService: SignpostIdService,\n    private signpostFocusManager: SignpostFocusManager,\n    @Inject(PLATFORM_ID) private platformId: any,\n    @Inject(DOCUMENT) document: any\n  ) {\n    super(injector, parentHost);\n    if (!parentHost) {\n      throw new Error('clr-signpost-content should only be used inside of a clr-signpost');\n    }\n    // Defaults\n    this.position = 'right-middle';\n    this.closeOnOutsideClick = true;\n    this.signpostIdService.setId(signpostContentId);\n\n    this.document = document;\n  }\n\n  /**********\n   *\n   * @description\n   * Close function that uses the signpost instance to toggle the state of the content popover.\n   *\n   */\n  close() {\n    this.toggleService.open = false;\n  }\n\n  private _position: string;\n\n  get position() {\n    return this._position;\n  }\n\n  /*********\n   *\n   * @description\n   * A setter for the position of the ClrSignpostContent popover. This is a combination of the following:\n   * - anchorPoint - where on the trigger to anchor the ClrSignpostContent\n   * - popoverPoint - where on the ClrSignpostContent container to align with the anchorPoint\n   * - offsetY - where on the Y axis to align the ClrSignpostContent so it meets specs\n   * - offsetX - where on the X axis to align the ClrSignpostContent so it meets specs\n   * There are 12 possible positions to place a ClrSignpostContent container:\n   * - top-left\n   * - top-middle\n   * - top-right\n   * - right-top\n   * - right-middle\n   * - right-bottom\n   * - bottom-right\n   * - bottom-middle\n   * - bottom-left\n   * - left-bottom\n   * - left-middle\n   * - left-top\n   *\n   * I think of it as follows for 'top-left' -> CONTAINER_SIDE-SIDE_POSITION. In this case CONTAINER_SIDE is 'top'\n   * meaning the top of the trigger icon (above the icon that hides/shows) the ClrSignpostContent. And, SIDE_POSITION\n   * is 'left' meaning two things: 1) the ClrSignpostContent container extends to the left and 2) the 'arrow/pointer'\n   * linking the SingpostContent to the trigger points down at the horizontal center of the trigger icon.\n   *\n   * @param newPosition\n   */\n  @Input('clrPosition')\n  set position(position: string) {\n    // Ugh\n    this.renderer.removeClass(this.el.nativeElement, this.position);\n    if (position && POSITIONS.indexOf(position) > -1) {\n      this._position = position;\n    } else {\n      this._position = 'right-middle';\n    }\n    // Ugh\n    this.renderer.addClass(this.el.nativeElement, this.position);\n\n    const setPosition = SIGNPOST_POSITIONS[this.position];\n    this.anchorPoint = setPosition.anchorPoint;\n    this.popoverPoint = setPosition.popoverPoint;\n    this.popoverOptions.offsetY = setPosition.offsetY;\n    this.popoverOptions.offsetX = setPosition.offsetX;\n  }\n\n  ngOnDestroy() {\n    if (isPlatformBrowser(this.platformId) && this.el.nativeElement.contains(this.document.activeElement)) {\n      this.signpostFocusManager.focusTrigger();\n    }\n  }\n}\n"]}

package/esm2020/popover/signpost/signpost-trigger.mjs

@@ -0,0 +1,96 @@
+/*
+ * 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 { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { Directive, HostListener, Inject, PLATFORM_ID } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../utils/popover/providers/popover-toggle.service";
+import * as i2 from "../../utils/i18n/common-strings.service";
+import * as i3 from "./providers/signpost-id.service";
+import * as i4 from "./providers/signpost-focus-manager.service";
+/*********
+ *
+ * @description
+ * A Directive added to the ClrSignpost Trigger button that will call the ClrSignpost.toggle() function to hide/show the
+ * ClrSignpostContent.
+ *
+ */
+export class ClrSignpostTrigger {
+    constructor(toggleService, el, commonStrings, signpostIdService, signpostFocusManager, document, platformId) {
+        this.toggleService = toggleService;
+        this.el = el;
+        this.commonStrings = commonStrings;
+        this.signpostIdService = signpostIdService;
+        this.signpostFocusManager = signpostFocusManager;
+        this.platformId = platformId;
+        this.subscriptions = [];
+        this.document = document;
+    }
+    ngOnInit() {
+        this.signpostFocusManager.triggerEl = this.el.nativeElement;
+        this.subscriptions.push(this.toggleService.openChange.subscribe((isOpen) => {
+            this.ariaExpanded = isOpen;
+            const prevIsOpen = this.isOpen;
+            this.isOpen = isOpen;
+            // openChange fires false on initialization because signpost starts as closed by default
+            // but we shouldn't focus on that initial false value
+            // we should focus back only if it's closed after being opened
+            if (!this.isOpen && prevIsOpen) {
+                this.focusOnClose();
+            }
+        }), this.signpostIdService.id.subscribe(idChange => (this.ariaControl = idChange)));
+        this.addDefaultAriaLabel(this.el.nativeElement);
+    }
+    addDefaultAriaLabel(el) {
+        if (!el.hasAttribute('aria-label')) {
+            el.setAttribute('aria-label', this.commonStrings.keys.signpostToggle);
+        }
+    }
+    focusOnClose() {
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        // we have to set the focus back on the trigger only if the focus is reset back to the body element
+        // if the focus is on another element, we are not allowed to move that focus back to this trigger again.
+        if (!this.isOpen && this.document.activeElement === this.document.body) {
+            this.signpostFocusManager.focusTrigger();
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+    /**********
+     *
+     * @description
+     * click handler for the ClrSignpost trigger button used to hide/show ClrSignpostContent.
+     */
+    onSignpostTriggerClick(event) {
+        this.toggleService.toggleWithEvent(event);
+    }
+}
+ClrSignpostTrigger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostTrigger, deps: [{ token: i1.ClrPopoverToggleService }, { token: i0.ElementRef }, { token: i2.ClrCommonStringsService }, { token: i3.SignpostIdService }, { token: i4.SignpostFocusManager }, { token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+ClrSignpostTrigger.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrSignpostTrigger, selector: "[clrSignpostTrigger]", host: { listeners: { "click": "onSignpostTriggerClick($event)" }, properties: { "attr.aria-expanded": "ariaExpanded", "attr.aria-controls": "ariaControl", "class.active": "isOpen" }, classAttribute: "signpost-trigger" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostTrigger, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrSignpostTrigger]',
+                    host: {
+                        class: 'signpost-trigger',
+                        '[attr.aria-expanded]': 'ariaExpanded',
+                        '[attr.aria-controls]': 'ariaControl',
+                        '[class.active]': 'isOpen',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ClrPopoverToggleService }, { type: i0.ElementRef }, { type: i2.ClrCommonStringsService }, { type: i3.SignpostIdService }, { type: i4.SignpostFocusManager }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; }, propDecorators: { onSignpostTriggerClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbnBvc3QtdHJpZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL3BvcG92ZXIvc2lnbnBvc3Qvc2lnbnBvc3QtdHJpZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLFFBQVEsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzlELE9BQU8sRUFBRSxTQUFTLEVBQWMsWUFBWSxFQUFFLE1BQU0sRUFBYSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7Ozs7OztBQWlCcEc7Ozs7OztHQU1HO0FBQ0gsTUFBTSxPQUFPLGtCQUFrQjtJQVM3QixZQUNVLGFBQXNDLEVBQ3RDLEVBQWMsRUFDZixhQUFzQyxFQUNyQyxpQkFBb0MsRUFDcEMsb0JBQTBDLEVBQ2hDLFFBQWEsRUFDRixVQUFlO1FBTnBDLGtCQUFhLEdBQWIsYUFBYSxDQUF5QjtRQUN0QyxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBQ2Ysa0JBQWEsR0FBYixhQUFhLENBQXlCO1FBQ3JDLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBbUI7UUFDcEMseUJBQW9CLEdBQXBCLG9CQUFvQixDQUFzQjtRQUVyQixlQUFVLEdBQVYsVUFBVSxDQUFLO1FBZnRDLGtCQUFhLEdBQW1CLEVBQUUsQ0FBQztRQWlCekMsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLENBQUMsb0JBQW9CLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDO1FBQzVELElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUNyQixJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsQ0FBQyxNQUFlLEVBQUUsRUFBRTtZQUMxRCxJQUFJLENBQUMsWUFBWSxHQUFHLE1BQU0sQ0FBQztZQUUzQixNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO1lBQy9CLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1lBRXJCLHdGQUF3RjtZQUN4RixxREFBcUQ7WUFDckQsOERBQThEO1lBQzlELElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxJQUFJLFVBQVUsRUFBRTtnQkFDOUIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO2FBQ3JCO1FBQ0gsQ0FBQyxDQUFDLEVBQ0YsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxXQUFXLEdBQUcsUUFBUSxDQUFDLENBQUMsQ0FDL0UsQ0FBQztRQUNGLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFTyxtQkFBbUIsQ0FBQyxFQUFlO1FBQ3pDLElBQUksQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQyxFQUFFO1lBQ2xDLEVBQUUsQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1NBQ3ZFO0lBQ0gsQ0FBQztJQUVPLFlBQVk7UUFDbEIsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsRUFBRTtZQUN2QyxPQUFPO1NBQ1I7UUFDRCxtR0FBbUc7UUFDbkcsd0dBQXdHO1FBQ3hHLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsYUFBYSxLQUFLLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFO1lBQ3RFLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxZQUFZLEVBQUUsQ0FBQztTQUMxQztJQUNILENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFpQixFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUVILHNCQUFzQixDQUFDLEtBQVk7UUFDakMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDNUMsQ0FBQzs7K0dBdkVVLGtCQUFrQiwrTEFlbkIsUUFBUSxhQUNSLFdBQVc7bUdBaEJWLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQWpCOUIsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0JBQXNCO29CQUNoQyxJQUFJLEVBQUU7d0JBQ0osS0FBSyxFQUFFLGtCQUFrQjt3QkFDekIsc0JBQXNCLEVBQUUsY0FBYzt3QkFDdEMsc0JBQXNCLEVBQUUsYUFBYTt3QkFDckMsZ0JBQWdCLEVBQUUsUUFBUTtxQkFDM0I7aUJBQ0Y7OzBCQXdCSSxNQUFNOzJCQUFDLFFBQVE7OzBCQUNmLE1BQU07MkJBQUMsV0FBVzs0Q0FxRHJCLHNCQUFzQjtzQkFEckIsWUFBWTt1QkFBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE2LTIwMjEgVk13YXJlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKiBUaGlzIHNvZnR3YXJlIGlzIHJlbGVhc2VkIHVuZGVyIE1JVCBsaWNlbnNlLlxuICogVGhlIGZ1bGwgbGljZW5zZSBpbmZvcm1hdGlvbiBjYW4gYmUgZm91bmQgaW4gTElDRU5TRSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBwcm9qZWN0LlxuICovXG5pbXBvcnQgeyBET0NVTUVOVCwgaXNQbGF0Zm9ybUJyb3dzZXIgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBIb3N0TGlzdGVuZXIsIEluamVjdCwgT25EZXN0cm95LCBQTEFURk9STV9JRCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDbHJQb3BvdmVyVG9nZ2xlU2VydmljZSB9IGZyb20gJy4uLy4uL3V0aWxzL3BvcG92ZXIvcHJvdmlkZXJzL3BvcG92ZXItdG9nZ2xlLnNlcnZpY2UnO1xuaW1wb3J0IHsgQ2xyQ29tbW9uU3RyaW5nc1NlcnZpY2UgfSBmcm9tICcuLi8uLi91dGlscy9pMThuL2NvbW1vbi1zdHJpbmdzLnNlcnZpY2UnO1xuaW1wb3J0IHsgU2lnbnBvc3RGb2N1c01hbmFnZXIgfSBmcm9tICcuL3Byb3ZpZGVycy9zaWducG9zdC1mb2N1cy1tYW5hZ2VyLnNlcnZpY2UnO1xuaW1wb3J0IHsgU2lnbnBvc3RJZFNlcnZpY2UgfSBmcm9tICcuL3Byb3ZpZGVycy9zaWducG9zdC1pZC5zZXJ2aWNlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2NsclNpZ25wb3N0VHJpZ2dlcl0nLFxuICBob3N0OiB7XG4gICAgY2xhc3M6ICdzaWducG9zdC10cmlnZ2VyJyxcbiAgICAnW2F0dHIuYXJpYS1leHBhbmRlZF0nOiAnYXJpYUV4cGFuZGVkJyxcbiAgICAnW2F0dHIuYXJpYS1jb250cm9sc10nOiAnYXJpYUNvbnRyb2wnLFxuICAgICdbY2xhc3MuYWN0aXZlXSc6ICdpc09wZW4nLFxuICB9LFxufSlcblxuLyoqKioqKioqKlxuICpcbiAqIEBkZXNjcmlwdGlvblxuICogQSBEaXJlY3RpdmUgYWRkZWQgdG8gdGhlIENsclNpZ25wb3N0IFRyaWdnZXIgYnV0dG9uIHRoYXQgd2lsbCBjYWxsIHRoZSBDbHJTaWducG9zdC50b2dnbGUoKSBmdW5jdGlvbiB0byBoaWRlL3Nob3cgdGhlXG4gKiBDbHJTaWducG9zdENvbnRlbnQuXG4gKlxuICovXG5leHBvcnQgY2xhc3MgQ2xyU2lnbnBvc3RUcmlnZ2VyIGltcGxlbWVudHMgT25EZXN0cm95IHtcbiAgcHJpdmF0ZSBzdWJzY3JpcHRpb25zOiBTdWJzY3JpcHRpb25bXSA9IFtdO1xuXG4gIHB1YmxpYyBhcmlhRXhwYW5kZWQ6IGJvb2xlYW47XG4gIHB1YmxpYyBhcmlhQ29udHJvbDogc3RyaW5nO1xuICBwdWJsaWMgaXNPcGVuOiBib29sZWFuO1xuXG4gIHByaXZhdGUgZG9jdW1lbnQ6IERvY3VtZW50O1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgdG9nZ2xlU2VydmljZTogQ2xyUG9wb3ZlclRvZ2dsZVNlcnZpY2UsXG4gICAgcHJpdmF0ZSBlbDogRWxlbWVudFJlZixcbiAgICBwdWJsaWMgY29tbW9uU3RyaW5nczogQ2xyQ29tbW9uU3RyaW5nc1NlcnZpY2UsXG4gICAgcHJpdmF0ZSBzaWducG9zdElkU2VydmljZTogU2lnbnBvc3RJZFNlcnZpY2UsXG4gICAgcHJpdmF0ZSBzaWducG9zdEZvY3VzTWFuYWdlcjogU2lnbnBvc3RGb2N1c01hbmFnZXIsXG4gICAgQEluamVjdChET0NVTUVOVCkgZG9jdW1lbnQ6IGFueSxcbiAgICBASW5qZWN0KFBMQVRGT1JNX0lEKSBwcml2YXRlIHBsYXRmb3JtSWQ6IGFueVxuICApIHtcbiAgICB0aGlzLmRvY3VtZW50ID0gZG9jdW1lbnQ7XG4gIH1cblxuICBuZ09uSW5pdCgpIHtcbiAgICB0aGlzLnNpZ25wb3N0Rm9jdXNNYW5hZ2VyLnRyaWdnZXJFbCA9IHRoaXMuZWwubmF0aXZlRWxlbWVudDtcbiAgICB0aGlzLnN1YnNjcmlwdGlvbnMucHVzaChcbiAgICAgIHRoaXMudG9nZ2xlU2VydmljZS5vcGVuQ2hhbmdlLnN1YnNjcmliZSgoaXNPcGVuOiBib29sZWFuKSA9PiB7XG4gICAgICAgIHRoaXMuYXJpYUV4cGFuZGVkID0gaXNPcGVuO1xuXG4gICAgICAgIGNvbnN0IHByZXZJc09wZW4gPSB0aGlzLmlzT3BlbjtcbiAgICAgICAgdGhpcy5pc09wZW4gPSBpc09wZW47XG5cbiAgICAgICAgLy8gb3BlbkNoYW5nZSBmaXJlcyBmYWxzZSBvbiBpbml0aWFsaXphdGlvbiBiZWNhdXNlIHNpZ25wb3N0IHN0YXJ0cyBhcyBjbG9zZWQgYnkgZGVmYXVsdFxuICAgICAgICAvLyBidXQgd2Ugc2hvdWxkbid0IGZvY3VzIG9uIHRoYXQgaW5pdGlhbCBmYWxzZSB2YWx1ZVxuICAgICAgICAvLyB3ZSBzaG91bGQgZm9jdXMgYmFjayBvbmx5IGlmIGl0J3MgY2xvc2VkIGFmdGVyIGJlaW5nIG9wZW5lZFxuICAgICAgICBpZiAoIXRoaXMuaXNPcGVuICYmIHByZXZJc09wZW4pIHtcbiAgICAgICAgICB0aGlzLmZvY3VzT25DbG9zZSgpO1xuICAgICAgICB9XG4gICAgICB9KSxcbiAgICAgIHRoaXMuc2lnbnBvc3RJZFNlcnZpY2UuaWQuc3Vic2NyaWJlKGlkQ2hhbmdlID0+ICh0aGlzLmFyaWFDb250cm9sID0gaWRDaGFuZ2UpKVxuICAgICk7XG4gICAgdGhpcy5hZGREZWZhdWx0QXJpYUxhYmVsKHRoaXMuZWwubmF0aXZlRWxlbWVudCk7XG4gIH1cblxuICBwcml2YXRlIGFkZERlZmF1bHRBcmlhTGFiZWwoZWw6IEhUTUxFbGVtZW50KSB7XG4gICAgaWYgKCFlbC5oYXNBdHRyaWJ1dGUoJ2FyaWEtbGFiZWwnKSkge1xuICAgICAgZWwuc2V0QXR0cmlidXRlKCdhcmlhLWxhYmVsJywgdGhpcy5jb21tb25TdHJpbmdzLmtleXMuc2lnbnBvc3RUb2dnbGUpO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgZm9jdXNPbkNsb3NlKCkge1xuICAgIGlmICghaXNQbGF0Zm9ybUJyb3dzZXIodGhpcy5wbGF0Zm9ybUlkKSkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cbiAgICAvLyB3ZSBoYXZlIHRvIHNldCB0aGUgZm9jdXMgYmFjayBvbiB0aGUgdHJpZ2dlciBvbmx5IGlmIHRoZSBmb2N1cyBpcyByZXNldCBiYWNrIHRvIHRoZSBib2R5IGVsZW1lbnRcbiAgICAvLyBpZiB0aGUgZm9jdXMgaXMgb24gYW5vdGhlciBlbGVtZW50LCB3ZSBhcmUgbm90IGFsbG93ZWQgdG8gbW92ZSB0aGF0IGZvY3VzIGJhY2sgdG8gdGhpcyB0cmlnZ2VyIGFnYWluLlxuICAgIGlmICghdGhpcy5pc09wZW4gJiYgdGhpcy5kb2N1bWVudC5hY3RpdmVFbGVtZW50ID09PSB0aGlzLmRvY3VtZW50LmJvZHkpIHtcbiAgICAgIHRoaXMuc2lnbnBvc3RGb2N1c01hbmFnZXIuZm9jdXNUcmlnZ2VyKCk7XG4gICAgfVxuICB9XG5cbiAgbmdPbkRlc3Ryb3koKSB7XG4gICAgdGhpcy5zdWJzY3JpcHRpb25zLmZvckVhY2goKHN1YjogU3Vic2NyaXB0aW9uKSA9PiBzdWIudW5zdWJzY3JpYmUoKSk7XG4gIH1cblxuICAvKioqKioqKioqKlxuICAgKlxuICAgKiBAZGVzY3JpcHRpb25cbiAgICogY2xpY2sgaGFuZGxlciBmb3IgdGhlIENsclNpZ25wb3N0IHRyaWdnZXIgYnV0dG9uIHVzZWQgdG8gaGlkZS9zaG93IENsclNpZ25wb3N0Q29udGVudC5cbiAgICovXG4gIEBIb3N0TGlzdGVuZXIoJ2NsaWNrJywgWyckZXZlbnQnXSlcbiAgb25TaWducG9zdFRyaWdnZXJDbGljayhldmVudDogRXZlbnQpOiB2b2lkIHtcbiAgICB0aGlzLnRvZ2dsZVNlcnZpY2UudG9nZ2xlV2l0aEV2ZW50KGV2ZW50KTtcbiAgfVxufVxuIl19

package/esm2020/popover/signpost/signpost.mjs

@@ -0,0 +1,89 @@
+/*
+ * 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 { Component, ContentChild, ElementRef } from '@angular/core';
+import { ClrPopoverToggleService } from '../../utils/popover/providers/popover-toggle.service';
+import { POPOVER_HOST_ANCHOR } from '../common/popover-host-anchor.token';
+import { ClrSignpostTrigger } from './signpost-trigger';
+import { SignpostIdService } from './providers/signpost-id.service';
+import { SignpostFocusManager } from './providers/signpost-focus-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../utils/i18n/common-strings.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./signpost-trigger";
+import * as i4 from "../../icon/icon";
+/*********
+ *
+ * @class ClrSignpost
+ *
+ * @description
+ * Class used to configure and control the state of a ClrSignpost and its associated ClrSignpostContent.
+ * It supports the clrPosition with a 'right-middle' default.
+ *
+ */
+export class ClrSignpost {
+    constructor(commonStrings) {
+        this.commonStrings = commonStrings;
+        /**********
+         * @property useCustomTrigger
+         *
+         * @description
+         * Flag used to determine if we need to use the default trigger or a user supplied trigger element.
+         *
+         */
+        this.useCustomTrigger = false;
+    }
+    /**********
+     * @property signPostTrigger
+     *
+     * @description
+     * Uses ContentChild to check for a user supplied element with the ClrSignpostTrigger on it.
+     *
+     */
+    set customTrigger(trigger) {
+        this.useCustomTrigger = !!trigger;
+    }
+}
+ClrSignpost.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpost, deps: [{ token: i1.ClrCommonStringsService }], target: i0.ɵɵFactoryTarget.Component });
+ClrSignpost.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrSignpost, selector: "clr-signpost", host: { properties: { "class.signpost": "true" } }, providers: [
+        ClrPopoverToggleService,
+        SignpostFocusManager,
+        { provide: POPOVER_HOST_ANCHOR, useExisting: ElementRef },
+        SignpostIdService,
+    ], queries: [{ propertyName: "customTrigger", first: true, predicate: ClrSignpostTrigger, descendants: true }], ngImport: i0, template: `
+    <ng-container *ngIf="!useCustomTrigger">
+      <button type="button" class="signpost-action btn btn-small btn-link" clrSignpostTrigger>
+        <cds-icon shape="info-circle" [attr.title]="commonStrings.keys.info"></cds-icon>
+      </button>
+    </ng-container>
+
+    <ng-content></ng-content>
+  `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.ClrSignpostTrigger, selector: "[clrSignpostTrigger]" }, { type: i4.CdsIconCustomTag, selector: "cds-icon" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpost, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-signpost',
+                    template: `
+    <ng-container *ngIf="!useCustomTrigger">
+      <button type="button" class="signpost-action btn btn-small btn-link" clrSignpostTrigger>
+        <cds-icon shape="info-circle" [attr.title]="commonStrings.keys.info"></cds-icon>
+      </button>
+    </ng-container>
+
+    <ng-content></ng-content>
+  `,
+                    host: { '[class.signpost]': 'true' },
+                    providers: [
+                        ClrPopoverToggleService,
+                        SignpostFocusManager,
+                        { provide: POPOVER_HOST_ANCHOR, useExisting: ElementRef },
+                        SignpostIdService,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ClrCommonStringsService }]; }, propDecorators: { customTrigger: [{
+                type: ContentChild,
+                args: [ClrSignpostTrigger]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover/signpost/signpost.module.mjs

@@ -0,0 +1,33 @@
+/*
+ * 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 { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ClarityIcons, infoCircleIcon, windowCloseIcon } from '@cds/core/icon';
+import { ClrIconModule } from '../../icon/icon.module';
+import { ClrConditionalModule } from '../../utils/conditional/conditional.module';
+import { ClrFocusOnViewInitModule } from '../../utils/focus/focus-on-view-init/focus-on-view-init.module';
+import { ClrSignpost } from './signpost';
+import { ClrSignpostContent } from './signpost-content';
+import { ClrSignpostTrigger } from './signpost-trigger';
+import * as i0 from "@angular/core";
+export const CLR_SIGNPOST_DIRECTIVES = [ClrSignpost, ClrSignpostContent, ClrSignpostTrigger];
+export class ClrSignpostModule {
+    constructor() {
+        ClarityIcons.addIcons(windowCloseIcon, infoCircleIcon);
+    }
+}
+ClrSignpostModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrSignpostModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostModule, declarations: [ClrSignpost, ClrSignpostContent, ClrSignpostTrigger], imports: [CommonModule, ClrIconModule, ClrFocusOnViewInitModule], exports: [ClrSignpost, ClrSignpostContent, ClrSignpostTrigger, ClrConditionalModule] });
+ClrSignpostModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostModule, imports: [[CommonModule, ClrIconModule, ClrFocusOnViewInitModule], ClrConditionalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrSignpostModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ClrIconModule, ClrFocusOnViewInitModule],
+                    declarations: [CLR_SIGNPOST_DIRECTIVES],
+                    exports: [CLR_SIGNPOST_DIRECTIVES, ClrConditionalModule],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover/tooltip/providers/tooltip-id.service.mjs

@@ -0,0 +1,25 @@
+/*
+ * 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 { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TooltipIdService {
+    constructor() {
+        this._id = new Subject();
+    }
+    updateId(id) {
+        this._id.next(id);
+    }
+    get id() {
+        return this._id.asObservable();
+    }
+}
+TooltipIdService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TooltipIdService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TooltipIdService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TooltipIdService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: TooltipIdService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC1pZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci9zcmMvcG9wb3Zlci90b29sdGlwL3Byb3ZpZGVycy90b29sdGlwLWlkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLGdCQUFnQjtJQUQ3QjtRQUVVLFFBQUcsR0FBb0IsSUFBSSxPQUFPLEVBQVUsQ0FBQztLQVN0RDtJQVBDLFFBQVEsQ0FBQyxFQUFVO1FBQ2pCLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3BCLENBQUM7SUFFRCxJQUFJLEVBQUU7UUFDSixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDakMsQ0FBQzs7NkdBVFUsZ0JBQWdCO2lIQUFoQixnQkFBZ0I7MkZBQWhCLGdCQUFnQjtrQkFENUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMSBWTXdhcmUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqIFRoaXMgc29mdHdhcmUgaXMgcmVsZWFzZWQgdW5kZXIgTUlUIGxpY2Vuc2UuXG4gKiBUaGUgZnVsbCBsaWNlbnNlIGluZm9ybWF0aW9uIGNhbiBiZSBmb3VuZCBpbiBMSUNFTlNFIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHByb2plY3QuXG4gKi9cblxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgVG9vbHRpcElkU2VydmljZSB7XG4gIHByaXZhdGUgX2lkOiBTdWJqZWN0PHN0cmluZz4gPSBuZXcgU3ViamVjdDxzdHJpbmc+KCk7XG5cbiAgdXBkYXRlSWQoaWQ6IHN0cmluZykge1xuICAgIHRoaXMuX2lkLm5leHQoaWQpO1xuICB9XG5cbiAgZ2V0IGlkKCk6IE9ic2VydmFibGU8c3RyaW5nPiB7XG4gICAgcmV0dXJuIHRoaXMuX2lkLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,132 @@
+/*
+ * 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 { Component, Inject, Input, Optional } from '@angular/core';
+import { AbstractPopover } from '../common/abstract-popover';
+import { Point } from '../common/popover';
+import { POPOVER_HOST_ANCHOR } from '../common/popover-host-anchor.token';
+import { UNIQUE_ID } from '../../utils/id-generator/id-generator.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/tooltip-id.service";
+const POSITIONS = ['bottom-left', 'bottom-right', 'top-left', 'top-right', 'right', 'left'];
+const SIZES = ['xs', 'sm', 'md', 'lg'];
+export class ClrTooltipContent extends AbstractPopover {
+    constructor(injector, parentHost, uniqueId, tooltipIdService) {
+        super(injector, parentHost);
+        this.uniqueId = uniqueId;
+        this.tooltipIdService = tooltipIdService;
+        if (!parentHost) {
+            throw new Error('clr-tooltip-content should only be used inside of a clr-tooltip');
+        }
+        // Defaults
+        this.position = 'right';
+        this.size = 'sm';
+        // Set the default id in case consumer does not supply a custom id.
+        this.updateId(uniqueId);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this.updateId(value || '');
+    }
+    updateId(id) {
+        this._id = id;
+        this.tooltipIdService.updateId(id);
+    }
+    get position() {
+        return this._position;
+    }
+    set position(position) {
+        // Ugh
+        this.renderer.removeClass(this.el.nativeElement, 'tooltip-' + this.position);
+        if (position && POSITIONS.indexOf(position) > -1) {
+            this._position = position;
+        }
+        else {
+            this._position = 'right';
+        }
+        // Ugh
+        this.renderer.addClass(this.el.nativeElement, 'tooltip-' + this.position);
+        // set the popover values based on direction
+        switch (position) {
+            case 'top-right':
+                this.anchorPoint = Point.TOP_CENTER;
+                this.popoverPoint = Point.LEFT_BOTTOM;
+                break;
+            case 'top-left':
+                this.anchorPoint = Point.TOP_CENTER;
+                this.popoverPoint = Point.RIGHT_BOTTOM;
+                break;
+            case 'bottom-right':
+                this.anchorPoint = Point.BOTTOM_CENTER;
+                this.popoverPoint = Point.LEFT_TOP;
+                break;
+            case 'bottom-left':
+                this.anchorPoint = Point.BOTTOM_CENTER;
+                this.popoverPoint = Point.RIGHT_TOP;
+                break;
+            case 'right':
+                this.anchorPoint = Point.RIGHT_CENTER;
+                this.popoverPoint = Point.LEFT_TOP;
+                break;
+            case 'left':
+                this.anchorPoint = Point.LEFT_CENTER;
+                this.popoverPoint = Point.RIGHT_TOP;
+                break;
+            default:
+                this.anchorPoint = Point.RIGHT_CENTER;
+                this.popoverPoint = Point.LEFT_TOP;
+                break;
+        }
+    }
+    get size() {
+        return this._size;
+    }
+    set size(size) {
+        // Ugh
+        this.renderer.removeClass(this.el.nativeElement, 'tooltip-' + this.size);
+        if (size && SIZES.indexOf(size) > -1) {
+            this._size = size;
+        }
+        else {
+            this._size = 'sm';
+        }
+        // Ugh
+        this.renderer.addClass(this.el.nativeElement, 'tooltip-' + this.size);
+    }
+}
+ClrTooltipContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrTooltipContent, deps: [{ token: i0.Injector }, { token: POPOVER_HOST_ANCHOR, optional: true }, { token: UNIQUE_ID }, { token: i1.TooltipIdService }], target: i0.ɵɵFactoryTarget.Component });
+ClrTooltipContent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrTooltipContent, selector: "clr-tooltip-content", inputs: { id: "id", position: ["clrPosition", "position"], size: ["clrSize", "size"] }, host: { properties: { "class.tooltip-content": "true", "style.opacity": "1", "attr.role": "\"tooltip\"", "id": "id" } }, usesInheritance: true, ngImport: i0, template: ` <ng-content></ng-content> `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrTooltipContent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-tooltip-content',
+                    template: ` <ng-content></ng-content> `,
+                    host: {
+                        '[class.tooltip-content]': 'true',
+                        '[style.opacity]': '1',
+                        '[attr.role]': '"tooltip"',
+                        '[id]': 'id',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.ElementRef, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [POPOVER_HOST_ANCHOR]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [UNIQUE_ID]
+                }] }, { type: i1.TooltipIdService }]; }, propDecorators: { id: [{
+                type: Input
+            }], position: [{
+                type: Input,
+                args: ['clrPosition']
+            }], size: [{
+                type: Input,
+                args: ['clrSize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip-content.js","sourceRoot":"","sources":["../../../../../projects/angular/src/popover/tooltip/tooltip-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 */\nimport { Component, ElementRef, Inject, Injector, Input, Optional } from '@angular/core';\nimport { AbstractPopover } from '../common/abstract-popover';\nimport { Point } from '../common/popover';\nimport { POPOVER_HOST_ANCHOR } from '../common/popover-host-anchor.token';\nimport { UNIQUE_ID } from '../../utils/id-generator/id-generator.service';\nimport { TooltipIdService } from './providers/tooltip-id.service';\n\nconst POSITIONS: string[] = ['bottom-left', 'bottom-right', 'top-left', 'top-right', 'right', 'left'];\n\nconst SIZES: string[] = ['xs', 'sm', 'md', 'lg'];\n\n@Component({\n  selector: 'clr-tooltip-content',\n  template: ` <ng-content></ng-content> `,\n  host: {\n    '[class.tooltip-content]': 'true',\n    '[style.opacity]': '1',\n    '[attr.role]': '\"tooltip\"',\n    '[id]': 'id',\n  },\n})\nexport class ClrTooltipContent extends AbstractPopover {\n  constructor(\n    injector: Injector,\n    @Optional()\n    @Inject(POPOVER_HOST_ANCHOR)\n    parentHost: ElementRef,\n    @Inject(UNIQUE_ID) public uniqueId: string,\n    private tooltipIdService: TooltipIdService\n  ) {\n    super(injector, parentHost);\n\n    if (!parentHost) {\n      throw new Error('clr-tooltip-content should only be used inside of a clr-tooltip');\n    }\n\n    // Defaults\n    this.position = 'right';\n    this.size = 'sm';\n\n    // Set the default id in case consumer does not supply a custom id.\n    this.updateId(uniqueId);\n  }\n\n  get id(): string {\n    return this._id;\n  }\n\n  @Input()\n  set id(value: string) {\n    this.updateId(value || '');\n  }\n  private _id: string;\n\n  private updateId(id: string) {\n    this._id = id;\n    this.tooltipIdService.updateId(id);\n  }\n\n  private _position: string;\n\n  get position() {\n    return this._position;\n  }\n\n  @Input('clrPosition')\n  set position(position: string) {\n    // Ugh\n    this.renderer.removeClass(this.el.nativeElement, 'tooltip-' + this.position);\n    if (position && POSITIONS.indexOf(position) > -1) {\n      this._position = position;\n    } else {\n      this._position = 'right';\n    }\n    // Ugh\n    this.renderer.addClass(this.el.nativeElement, 'tooltip-' + this.position);\n\n    // set the popover values based on direction\n    switch (position) {\n      case 'top-right':\n        this.anchorPoint = Point.TOP_CENTER;\n        this.popoverPoint = Point.LEFT_BOTTOM;\n        break;\n      case 'top-left':\n        this.anchorPoint = Point.TOP_CENTER;\n        this.popoverPoint = Point.RIGHT_BOTTOM;\n        break;\n      case 'bottom-right':\n        this.anchorPoint = Point.BOTTOM_CENTER;\n        this.popoverPoint = Point.LEFT_TOP;\n        break;\n      case 'bottom-left':\n        this.anchorPoint = Point.BOTTOM_CENTER;\n        this.popoverPoint = Point.RIGHT_TOP;\n        break;\n      case 'right':\n        this.anchorPoint = Point.RIGHT_CENTER;\n        this.popoverPoint = Point.LEFT_TOP;\n        break;\n      case 'left':\n        this.anchorPoint = Point.LEFT_CENTER;\n        this.popoverPoint = Point.RIGHT_TOP;\n        break;\n      default:\n        this.anchorPoint = Point.RIGHT_CENTER;\n        this.popoverPoint = Point.LEFT_TOP;\n        break;\n    }\n  }\n\n  private _size: string;\n\n  get size() {\n    return this._size;\n  }\n\n  @Input('clrSize')\n  set size(size: string) {\n    // Ugh\n    this.renderer.removeClass(this.el.nativeElement, 'tooltip-' + this.size);\n    if (size && SIZES.indexOf(size) > -1) {\n      this._size = size;\n    } else {\n      this._size = 'sm';\n    }\n    // Ugh\n    this.renderer.addClass(this.el.nativeElement, 'tooltip-' + this.size);\n  }\n}\n"]}