@danske/sapphire-angular 1.12.4

package/esm2020/lib/popover/src/popover-trigger.directive.mjs

@@ -0,0 +1,301 @@
+import { __decorate } from "tslib";
+import { OverlayConfig, } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, EventEmitter, HostBinding, HostListener, InjectionToken, Injector, Input, Output, } from '@angular/core';
+import { merge, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { flip, toConnectedPosition } from '../../common/placement';
+import { CoerceBoolean } from '../../common/coerce-boolean.decorator';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export const POPOVER_TRIGGER = new InjectionToken('sp-popover-trigger');
+// TODO(UC-2728): improve event handling when reusable press utility is added
+export class PopoverTriggerDirective {
+    get getPopoverId() {
+        return this.overlayRef?.hostElement.querySelector('[role="dialog"]')?.id;
+    }
+    constructor(changeDetectorRef, cdkOverlay, viewContainerRef, elementRef, injector) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.cdkOverlay = cdkOverlay;
+        this.viewContainerRef = viewContainerRef;
+        this.elementRef = elementRef;
+        this.injector = injector;
+        this.placement = 'bottom';
+        this.templateRef = null;
+        /**
+         * Whether the popover should not block interaction with background.
+         */
+        this.nonModal = false;
+        /**
+         * Whether the popover should be opened on press start.
+         */
+        this.openOnPressStart = false;
+        /**
+         * Whether the popover should be closed when the container is scrolled.
+         * @default false
+         */
+        this.closeOnScroll = false;
+        /**
+         * Can be used to disable toggling popover on clicks. Useful if `spPopoverTrigger`
+         * is applied on an element which doesn't support `disabled` property.
+         */
+        this.disabled = false;
+        /** Emits when the attached popover is requested to open */
+        this.opened = new EventEmitter();
+        /** Emits when the attached popover is requested to close */
+        this.closed = new EventEmitter();
+        /** Emits when this trigger is destroyed. */
+        this.destroyed = new Subject();
+        /** A reference to the overlay which manages the triggered menu */
+        this.overlayRef = null;
+        this.isBeingPressed = false;
+    }
+    ngOnDestroy() {
+        this.destroyOverlay();
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    /** Toggle the attached popover. */
+    toggle() {
+        this.isOpen() ? this.close() : this.open();
+    }
+    /** Open the attached popover. */
+    open() {
+        if (!this.isOpen() && this.templateRef != null && !this.disabled) {
+            this.opened.next();
+            if (!this.overlayRef) {
+                this.overlayRef = this.cdkOverlay.create(this.getOverlayConfig());
+                this.overlayRef.updatePositionStrategy(this.getOverlayPositionStrategy());
+                this.overlayRef.attach(this.getContentPortal());
+                this.overlayRef.detachments().subscribe(() => {
+                    this.closed.next();
+                    this.changeDetectorRef.detectChanges();
+                });
+                this.overlayRef
+                    .outsidePointerEvents()
+                    .pipe(takeUntil(merge(this.closed, this.destroyed)))
+                    .subscribe((event) => {
+                    if (
+                    // If popover is opened on press start, an outside pointer event
+                    // is emitted as the mouse is being released, which would immediately
+                    // close the popover. Probably a bug in @angular/cdk/overlay.
+                    !(this.openOnPressStart && this.isBeingPressed) &&
+                        !this.elementRef.nativeElement.contains(event.target)) {
+                        this.close();
+                    }
+                });
+            }
+            else {
+                this.overlayRef.attach(this.getContentPortal());
+            }
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    /** Close the opened popover. */
+    close() {
+        if (this.isOpen()) {
+            this.overlayRef?.detach();
+        }
+    }
+    /** Whether the popover is open. */
+    isOpen() {
+        return !!this.overlayRef?.hasAttached();
+    }
+    handleMousedown(event) {
+        this.isBeingPressed = true;
+        if (this.openOnPressStart) {
+            if (event.currentTarget instanceof HTMLElement) {
+                // We need to focus the trigger before opening. Otherwise, the focus restoration logic will
+                // be messed up, since the wrong element would have the focus when the popover is mounted.
+                event.currentTarget.focus();
+                event.preventDefault();
+                document.addEventListener('mouseup', () => {
+                    setTimeout(() => {
+                        this.isBeingPressed = false;
+                    });
+                }, { once: true });
+            }
+            this.toggle();
+        }
+    }
+    handleClick() {
+        if (!this.openOnPressStart) {
+            this.toggle();
+        }
+    }
+    /**
+     * While onFocusout takes care of closing the popover when focus goes out, in the rare cases
+     * that there is no more focusable element between the trigger and the popover, the focus can
+     * go to the popover on pressing `Tab`. But the popover should be closed when tabbing on the
+     * trigger.
+     */
+    handleTab() {
+        this.close();
+    }
+    /**
+     * In some use cases (e.g. in searchable select) popover trigger grabs the focus, right after
+     * the popover is opened. That requires popover trigger to detect when focus goes out of it
+     * and close the popover.
+     * Note: we can't use `blur` event since it won't bubble up, and the focus can be on an element
+     * inside the trigger, but not the trigger itself.
+     *
+     */
+    onFocusout(event) {
+        if (event.relatedTarget === null &&
+            document.activeElement === event.target) {
+            // This happens on tab switch, without focus being actually moved.
+            return;
+        }
+        const focusReceivingElement = event.relatedTarget instanceof Element ? event.relatedTarget : null;
+        if (
+        // focus is going nowhere
+        !focusReceivingElement ||
+            // focus is going anywhere outside popover and popover trigger
+            !(this.elementRef?.nativeElement?.contains(focusReceivingElement) ||
+                // This is to not have the popover closed as soon as mouse is down on something inside the
+                // popover, if the focus is currently on the trigger
+                this.overlayRef?.overlayElement?.contains(focusReceivingElement))) {
+            this.close();
+        }
+    }
+    handleKeyDown(event) {
+        if (event.target === this.elementRef.nativeElement &&
+            !(this.elementRef.nativeElement instanceof HTMLButtonElement) &&
+            (event.key === 'Enter' || event.key === ' ')) {
+            event.preventDefault();
+            this.toggle();
+        }
+    }
+    destroyOverlay() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    /** Get the configuration object used to create the overlay. */
+    getOverlayConfig() {
+        return new OverlayConfig({
+            scrollStrategy: this.nonModal
+                ? this.closeOnScroll
+                    ? this.cdkOverlay.scrollStrategies.close()
+                    : this.cdkOverlay.scrollStrategies.reposition()
+                : this.cdkOverlay.scrollStrategies.block(),
+            // Including a transparent backdrop according to the latest decision of making popovers modal.
+            hasBackdrop: !this.nonModal,
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+        });
+    }
+    getContentPortal() {
+        if (this.templateRef) {
+            return new TemplatePortal(this.templateRef, this.viewContainerRef, null, Injector.create({
+                providers: [{ provide: POPOVER_TRIGGER, useValue: this }],
+                parent: this.injector,
+            }));
+        }
+        return null;
+    }
+    getOverlayPositionStrategy() {
+        const placement = this.placement || 'bottom';
+        const hasHorizontallyCenteredAlignment = !placement.includes('start') && !placement.includes('end');
+        return (this.cdkOverlay
+            .position()
+            .flexibleConnectedTo(this.elementRef)
+            .withLockedPosition()
+            .withGrowAfterOpen()
+            /**
+             * Disabling pushing, to fix an issue in FlexibleConnectedPositionStrategy where the
+             * overlay's bottom grows past the top of the trigger element (aka origin).
+             * I.e., when the overlay is supposed to be placed above the trigger element, it can
+             * grow in height and cover the trigger element. This is more of an issue when the trigger
+             * element remains interactive after the overlay is opened, such as in searchable select.
+             * Note that this is not the case when the overlay is placed above the trigger element.
+             * In that case the overlay will not eat up all available viewport height, and is sized in
+             * a way that respects the preferred placement above the trigger element.
+             * Disabling push is not the ideal solution but prevents the issue.
+             * push is disabled only for overlays where the horizontal alignment is anchored to left
+             * or right of the trigger element, based on the fair assumption that the connected
+             * element is itself within the viewport, and we won't need to push the overlay horizontally
+             * to have it within the viewport. It should also be ok not to push vertically, since we
+             * allow for vertical flipping if needed.
+             **/
+            .withPush(hasHorizontallyCenteredAlignment)
+            .withPositions([
+            toConnectedPosition(placement),
+            toConnectedPosition(flip(placement)),
+        ])
+            .withViewportMargin(placement.includes('end') ? 0 : 6));
+    }
+}
+PopoverTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: PopoverTriggerDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+PopoverTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: PopoverTriggerDirective, selector: "[spPopoverTriggerFor]", inputs: { placement: ["spPopoverPlacement", "placement"], templateRef: ["spPopoverTriggerFor", "templateRef"], nonModal: ["spPopoverNonModal", "nonModal"], openOnPressStart: ["spPopoverTriggerOpenOnPressStart", "openOnPressStart"], closeOnScroll: ["spPopoverTriggerCloseOnScroll", "closeOnScroll"], disabled: ["spPopoverTriggerDisabled", "disabled"] }, outputs: { opened: "spPopoverTriggerOpened", closed: "spPopoverTriggerClosed" }, host: { listeners: { "mousedown": "handleMousedown($event)", "click": "handleClick($event)", "keydown.tab": "handleTab()", "focusout": "onFocusout($event)", "keydown": "handleKeyDown($event)" }, properties: { "class.is-active": "isOpen()", "attr.aria-expanded": "isOpen()", "attr.aria-controls": "this.getPopoverId" } }, providers: [
+        { provide: POPOVER_TRIGGER, useExisting: PopoverTriggerDirective },
+    ], exportAs: ["spPopoverTrigger"], ngImport: i0 });
+__decorate([
+    CoerceBoolean
+], PopoverTriggerDirective.prototype, "nonModal", void 0);
+__decorate([
+    CoerceBoolean
+], PopoverTriggerDirective.prototype, "openOnPressStart", void 0);
+__decorate([
+    CoerceBoolean
+], PopoverTriggerDirective.prototype, "closeOnScroll", void 0);
+__decorate([
+    CoerceBoolean
+], PopoverTriggerDirective.prototype, "disabled", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: PopoverTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[spPopoverTriggerFor]',
+                    providers: [
+                        { provide: POPOVER_TRIGGER, useExisting: PopoverTriggerDirective },
+                    ],
+                    host: {
+                        '[class.is-active]': 'isOpen()',
+                        '[attr.aria-expanded]': 'isOpen()',
+                    },
+                    exportAs: 'spPopoverTrigger',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i0.Injector }]; }, propDecorators: { placement: [{
+                type: Input,
+                args: ['spPopoverPlacement']
+            }], templateRef: [{
+                type: Input,
+                args: ['spPopoverTriggerFor']
+            }], nonModal: [{
+                type: Input,
+                args: ['spPopoverNonModal']
+            }], openOnPressStart: [{
+                type: Input,
+                args: ['spPopoverTriggerOpenOnPressStart']
+            }], closeOnScroll: [{
+                type: Input,
+                args: ['spPopoverTriggerCloseOnScroll']
+            }], disabled: [{
+                type: Input,
+                args: ['spPopoverTriggerDisabled']
+            }], opened: [{
+                type: Output,
+                args: ['spPopoverTriggerOpened']
+            }], closed: [{
+                type: Output,
+                args: ['spPopoverTriggerClosed']
+            }], getPopoverId: [{
+                type: HostBinding,
+                args: ['attr.aria-controls']
+            }], handleMousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], handleClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], handleTab: [{
+                type: HostListener,
+                args: ['keydown.tab']
+            }], onFocusout: [{
+                type: HostListener,
+                args: ['focusout', ['$event']]
+            }], handleKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-trigger.directive.js","sourceRoot":"","sources":["../../../../../src/lib/popover/src/popover-trigger.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  FlexibleConnectedPositionStrategy,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n} from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  InjectionToken,\n  Injector,\n  Input,\n  Output,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { merge, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { flip, Placement, toConnectedPosition } from '../../common/placement';\nimport { BooleanInput } from '@angular/cdk/coercion';\nimport { CoerceBoolean } from '../../common/coerce-boolean.decorator';\n\nexport interface PopoverTrigger {\n  toggle(): void;\n  open(): void;\n  close(): void;\n  elementRef: ElementRef<HTMLElement>;\n}\nexport const POPOVER_TRIGGER = new InjectionToken<PopoverTrigger>(\n  'sp-popover-trigger'\n);\n\n// TODO(UC-2728): improve event handling when reusable press utility is added\n\n@Directive({\n  selector: '[spPopoverTriggerFor]',\n  providers: [\n    { provide: POPOVER_TRIGGER, useExisting: PopoverTriggerDirective },\n  ],\n  host: {\n    '[class.is-active]': 'isOpen()',\n    '[attr.aria-expanded]': 'isOpen()',\n  },\n  exportAs: 'spPopoverTrigger',\n})\nexport class PopoverTriggerDirective implements PopoverTrigger {\n  @Input('spPopoverPlacement')\n  public placement: Placement = 'bottom';\n\n  @Input('spPopoverTriggerFor')\n  templateRef: TemplateRef<unknown> | null = null;\n\n  /**\n   * Whether the popover should not block interaction with background.\n   */\n  @Input('spPopoverNonModal')\n  @CoerceBoolean\n  nonModal: BooleanInput = false;\n\n  /**\n   * Whether the popover should be opened on press start.\n   */\n  @Input('spPopoverTriggerOpenOnPressStart')\n  @CoerceBoolean\n  openOnPressStart: BooleanInput = false;\n\n  /**\n   * Whether the popover should be closed when the container is scrolled.\n   * @default false\n   */\n  @Input('spPopoverTriggerCloseOnScroll')\n  @CoerceBoolean\n  closeOnScroll: BooleanInput = false;\n\n  /**\n   * Can be used to disable toggling popover on clicks. Useful if `spPopoverTrigger`\n   * is applied on an element which doesn't support `disabled` property.\n   */\n  @Input('spPopoverTriggerDisabled')\n  @CoerceBoolean\n  disabled: BooleanInput = false;\n\n  /** Emits when the attached popover is requested to open */\n  @Output('spPopoverTriggerOpened')\n  readonly opened: EventEmitter<void> = new EventEmitter();\n\n  /** Emits when the attached popover is requested to close */\n  @Output('spPopoverTriggerClosed')\n  readonly closed: EventEmitter<void> = new EventEmitter();\n\n  /** Emits when this trigger is destroyed. */\n  protected readonly destroyed: Subject<void> = new Subject();\n\n  /** A reference to the overlay which manages the triggered menu */\n  protected overlayRef: OverlayRef | null = null;\n\n  private isBeingPressed = false;\n\n  @HostBinding('attr.aria-controls')\n  public get getPopoverId() {\n    return this.overlayRef?.hostElement.querySelector('[role=\"dialog\"]')?.id;\n  }\n\n  constructor(\n    private changeDetectorRef: ChangeDetectorRef,\n    private cdkOverlay: Overlay,\n    private viewContainerRef: ViewContainerRef,\n    public elementRef: ElementRef<HTMLElement>,\n    private injector: Injector\n  ) {}\n\n  ngOnDestroy() {\n    this.destroyOverlay();\n\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  /** Toggle the attached popover. */\n  toggle() {\n    this.isOpen() ? this.close() : this.open();\n  }\n\n  /** Open the attached popover. */\n  open() {\n    if (!this.isOpen() && this.templateRef != null && !this.disabled) {\n      this.opened.next();\n      if (!this.overlayRef) {\n        this.overlayRef = this.cdkOverlay.create(this.getOverlayConfig());\n        this.overlayRef.updatePositionStrategy(\n          this.getOverlayPositionStrategy()\n        );\n        this.overlayRef.attach(this.getContentPortal());\n        this.overlayRef.detachments().subscribe(() => {\n          this.closed.next();\n          this.changeDetectorRef.detectChanges();\n        });\n        this.overlayRef\n          .outsidePointerEvents()\n          .pipe(takeUntil(merge(this.closed, this.destroyed)))\n          .subscribe((event: MouseEvent) => {\n            if (\n              // If popover is opened on press start, an outside pointer event\n              // is emitted as the mouse is being released, which would immediately\n              // close the popover. Probably a bug in @angular/cdk/overlay.\n              !(this.openOnPressStart && this.isBeingPressed) &&\n              !this.elementRef.nativeElement.contains(event.target as Element)\n            ) {\n              this.close();\n            }\n          });\n      } else {\n        this.overlayRef.attach(this.getContentPortal());\n      }\n      this.changeDetectorRef.detectChanges();\n    }\n  }\n\n  /** Close the opened popover. */\n  close() {\n    if (this.isOpen()) {\n      this.overlayRef?.detach();\n    }\n  }\n\n  /** Whether the popover is open. */\n  isOpen() {\n    return !!this.overlayRef?.hasAttached();\n  }\n\n  @HostListener('mousedown', ['$event'])\n  private handleMousedown(event: MouseEvent) {\n    this.isBeingPressed = true;\n    if (this.openOnPressStart) {\n      if (event.currentTarget instanceof HTMLElement) {\n        // We need to focus the trigger before opening. Otherwise, the focus restoration logic will\n        // be messed up, since the wrong element would have the focus when the popover is mounted.\n        event.currentTarget.focus();\n        event.preventDefault();\n        document.addEventListener(\n          'mouseup',\n          () => {\n            setTimeout(() => {\n              this.isBeingPressed = false;\n            });\n          },\n          { once: true }\n        );\n      }\n      this.toggle();\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  private handleClick() {\n    if (!this.openOnPressStart) {\n      this.toggle();\n    }\n  }\n\n  /**\n   * While onFocusout takes care of closing the popover when focus goes out, in the rare cases\n   * that there is no more focusable element between the trigger and the popover, the focus can\n   * go to the popover on pressing `Tab`. But the popover should be closed when tabbing on the\n   * trigger.\n   */\n  @HostListener('keydown.tab')\n  private handleTab() {\n    this.close();\n  }\n\n  /**\n   * In some use cases (e.g. in searchable select) popover trigger grabs the focus, right after\n   * the popover is opened. That requires popover trigger to detect when focus goes out of it\n   * and close the popover.\n   * Note: we can't use `blur` event since it won't bubble up, and the focus can be on an element\n   * inside the trigger, but not the trigger itself.\n   *\n   */\n  @HostListener('focusout', ['$event'])\n  private onFocusout(event: FocusEvent) {\n    if (\n      event.relatedTarget === null &&\n      document.activeElement === event.target\n    ) {\n      // This happens on tab switch, without focus being actually moved.\n      return;\n    }\n    const focusReceivingElement =\n      event.relatedTarget instanceof Element ? event.relatedTarget : null;\n    if (\n      // focus is going nowhere\n      !focusReceivingElement ||\n      // focus is going anywhere outside popover and popover trigger\n      !(\n        this.elementRef?.nativeElement?.contains(focusReceivingElement) ||\n        // This is to not have the popover closed as soon as mouse is down on something inside the\n        // popover, if the focus is currently on the trigger\n        this.overlayRef?.overlayElement?.contains(focusReceivingElement)\n      )\n    ) {\n      this.close();\n    }\n  }\n\n  @HostListener('keydown', ['$event'])\n  private handleKeyDown(event: KeyboardEvent) {\n    if (\n      event.target === this.elementRef.nativeElement &&\n      !(this.elementRef.nativeElement instanceof HTMLButtonElement) &&\n      (event.key === 'Enter' || event.key === ' ')\n    ) {\n      event.preventDefault();\n      this.toggle();\n    }\n  }\n\n  private destroyOverlay() {\n    if (this.overlayRef) {\n      this.overlayRef.dispose();\n      this.overlayRef = null;\n    }\n  }\n\n  /** Get the configuration object used to create the overlay. */\n  private getOverlayConfig() {\n    return new OverlayConfig({\n      scrollStrategy: this.nonModal\n        ? this.closeOnScroll\n          ? this.cdkOverlay.scrollStrategies.close()\n          : this.cdkOverlay.scrollStrategies.reposition()\n        : this.cdkOverlay.scrollStrategies.block(), // to match what we have in react\n\n      // Including a transparent backdrop according to the latest decision of making popovers modal.\n      hasBackdrop: !this.nonModal,\n      backdropClass: 'cdk-overlay-transparent-backdrop',\n    });\n  }\n  private getContentPortal(): TemplatePortal | null {\n    if (this.templateRef) {\n      return new TemplatePortal(\n        this.templateRef,\n        this.viewContainerRef,\n        null,\n        Injector.create({\n          providers: [{ provide: POPOVER_TRIGGER, useValue: this }],\n          parent: this.injector,\n        })\n      );\n    }\n    return null;\n  }\n\n  private getOverlayPositionStrategy(): FlexibleConnectedPositionStrategy {\n    const placement = this.placement || 'bottom';\n    const hasHorizontallyCenteredAlignment =\n      !placement.includes('start') && !placement.includes('end');\n    return (\n      this.cdkOverlay\n        .position()\n        .flexibleConnectedTo(this.elementRef)\n        .withLockedPosition()\n        .withGrowAfterOpen()\n        /**\n         * Disabling pushing, to fix an issue in FlexibleConnectedPositionStrategy where the\n         * overlay's bottom grows past the top of the trigger element (aka origin).\n         * I.e., when the overlay is supposed to be placed above the trigger element, it can\n         * grow in height and cover the trigger element. This is more of an issue when the trigger\n         * element remains interactive after the overlay is opened, such as in searchable select.\n         * Note that this is not the case when the overlay is placed above the trigger element.\n         * In that case the overlay will not eat up all available viewport height, and is sized in\n         * a way that respects the preferred placement above the trigger element.\n         * Disabling push is not the ideal solution but prevents the issue.\n         * push is disabled only for overlays where the horizontal alignment is anchored to left\n         * or right of the trigger element, based on the fair assumption that the connected\n         * element is itself within the viewport, and we won't need to push the overlay horizontally\n         * to have it within the viewport. It should also be ok not to push vertically, since we\n         * allow for vertical flipping if needed.\n         **/\n        .withPush(hasHorizontallyCenteredAlignment)\n        .withPositions([\n          toConnectedPosition(placement),\n          toConnectedPosition(flip(placement)),\n        ])\n        .withViewportMargin(placement.includes('end') ? 0 : 6)\n    );\n  }\n}\n"]}

package/esm2020/lib/popover/src/popover.component.mjs

@@ -0,0 +1,88 @@
+import { __decorate } from "tslib";
+import { Component, ContentChild, ElementRef, HostListener, Inject, Input, Optional, ViewChild, } from '@angular/core';
+import { hasModifierKey } from '@angular/cdk/keycodes';
+import { ThemeCheckDirective } from '../../theme/src/theme-check.directive';
+import { CoerceBoolean } from '../../common/coerce-boolean.decorator';
+import { POPOVER_TRIGGER } from './popover-trigger.directive';
+import { PopoverTitleDirective } from './popover-title.directive';
+import { UseComponentStylesOnHost } from '../../common/sapphire-view-encapsulation';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+import * as i2 from "../../common/sapphire-view-encapsulation";
+import * as i3 from "@angular/cdk/a11y";
+/**
+ * A generic popover component which lets you render arbitrary
+ * content in a popover overlay which is linked to a trigger, and is accessible
+ * as
+ * [dialog](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles/dialog_role).
+ */
+export class PopoverComponent {
+    constructor(trigger) {
+        this.trigger = trigger;
+        this.ID = `sp-popover-${Math.floor(Math.random() * 1000000000)}`;
+        /**
+         * Keeps track of if the content is focused
+         */
+        this.contentFocused = false;
+    }
+    ngAfterViewInit() {
+        if (!this.contentFocused) {
+            this.contentWrapper?.nativeElement.focus();
+        }
+    }
+    handleEscape(event) {
+        if (!hasModifierKey(event)) {
+            event.preventDefault();
+            this.trigger?.close();
+        }
+    }
+    _contentFocusChanged(origin) {
+        this.contentFocused = origin != null;
+        if (!this.contentFocused) {
+            // cdkFocusChange doesn't give access to the native event, so we can't figure out where the
+            // focus is going. So we asynchronously check if the focus is outside the trigger and close
+            // in that case.
+            setTimeout(() => {
+                if (!this.trigger?.elementRef.nativeElement.contains(document.activeElement)) {
+                    this.trigger?.close();
+                }
+            });
+        }
+    }
+}
+PopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: PopoverComponent, deps: [{ token: POPOVER_TRIGGER, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+PopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.0", type: PopoverComponent, selector: "sp-popover", inputs: { noPadding: "noPadding", noMaxWidth: "noMaxWidth" }, host: { attributes: { "role": "presentation" }, listeners: { "keydown.Escape": "handleEscape($event)" }, properties: { "class.sapphire-popover": "true", "class.sapphire-popover--padded": "!noPadding", "class.sapphire-popover--max-width": "!noMaxWidth" } }, queries: [{ propertyName: "title", first: true, predicate: PopoverTitleDirective, descendants: true }], viewQueries: [{ propertyName: "contentWrapper", first: true, predicate: ["contentWrapper"], descendants: true, read: ElementRef }], hostDirectives: [{ directive: i1.ThemeCheckDirective }, { directive: i2.UseComponentStylesOnHost }], ngImport: i0, template: "<!--\nNOTE: cdkTrapFocus is required for cdkTrapFocusAutoCapture to work, which would be similar to\n <FocusScope autoFocus /> in react-aria. It does NOT prevent focus from going out of popover,\n which is good, as we want the popover to close on blur.\n  -->\n<div\n  #contentWrapper\n  [id]=\"ID\"\n  role=\"dialog\"\n  tabindex=\"-1\"\n  cdkMonitorSubtreeFocus\n  cdkTrapFocus\n  cdkTrapFocusAutoCapture\n  class=\"dialog\"\n  [attr.aria-labelledby]=\"title?.ID\"\n  (cdkFocusChange)=\"_contentFocusChanged($event)\"\n>\n  <ng-content></ng-content>\n</div>\n", styles: ["@keyframes fade-in{0%{opacity:0}to{opacity:1}}.sapphire-popover{box-sizing:border-box;background-color:var(--sapphire-popover-color-background);box-shadow:var(--sapphire-popover-shadow);animation:fade-in var(--sapphire-popover-time-transition) ease-in-out;border-radius:var(--sapphire-popover-size-radius);overflow:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.sapphire-popover--padded{padding:var(--sapphire-popover-size-spacing-padded)}.sapphire-popover--max-width{max-width:var(--sapphire-popover-size-max-width)}.dialog{outline:none}\n"], dependencies: [{ kind: "directive", type: i3.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }, { kind: "directive", type: i3.CdkMonitorFocus, selector: "[cdkMonitorElementFocus], [cdkMonitorSubtreeFocus]", outputs: ["cdkFocusChange"], exportAs: ["cdkMonitorFocus"] }] });
+__decorate([
+    CoerceBoolean
+], PopoverComponent.prototype, "noPadding", void 0);
+__decorate([
+    CoerceBoolean
+], PopoverComponent.prototype, "noMaxWidth", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: PopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sp-popover', host: {
+                        '[class.sapphire-popover]': 'true',
+                        '[class.sapphire-popover--padded]': '!noPadding',
+                        '[class.sapphire-popover--max-width]': '!noMaxWidth',
+                        role: 'presentation',
+                    }, hostDirectives: [ThemeCheckDirective, UseComponentStylesOnHost], template: "<!--\nNOTE: cdkTrapFocus is required for cdkTrapFocusAutoCapture to work, which would be similar to\n <FocusScope autoFocus /> in react-aria. It does NOT prevent focus from going out of popover,\n which is good, as we want the popover to close on blur.\n  -->\n<div\n  #contentWrapper\n  [id]=\"ID\"\n  role=\"dialog\"\n  tabindex=\"-1\"\n  cdkMonitorSubtreeFocus\n  cdkTrapFocus\n  cdkTrapFocusAutoCapture\n  class=\"dialog\"\n  [attr.aria-labelledby]=\"title?.ID\"\n  (cdkFocusChange)=\"_contentFocusChanged($event)\"\n>\n  <ng-content></ng-content>\n</div>\n", styles: ["@keyframes fade-in{0%{opacity:0}to{opacity:1}}.sapphire-popover{box-sizing:border-box;background-color:var(--sapphire-popover-color-background);box-shadow:var(--sapphire-popover-shadow);animation:fade-in var(--sapphire-popover-time-transition) ease-in-out;border-radius:var(--sapphire-popover-size-radius);overflow:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.sapphire-popover--padded{padding:var(--sapphire-popover-size-spacing-padded)}.sapphire-popover--max-width{max-width:var(--sapphire-popover-size-max-width)}.dialog{outline:none}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [POPOVER_TRIGGER]
+                }] }]; }, propDecorators: { noPadding: [{
+                type: Input
+            }], noMaxWidth: [{
+                type: Input
+            }], title: [{
+                type: ContentChild,
+                args: [PopoverTitleDirective]
+            }], contentWrapper: [{
+                type: ViewChild,
+                args: ['contentWrapper', { read: ElementRef }]
+            }], handleEscape: [{
+                type: HostListener,
+                args: ['keydown.Escape', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/popover/src/popover.module.mjs

@@ -0,0 +1,38 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { A11yModule } from '@angular/cdk/a11y';
+import { PopoverTriggerDirective } from './popover-trigger.directive';
+import { PopoverComponent } from './popover.component';
+import { PopoverCloseButtonDirective } from './popover-close-button.directive';
+import { PopoverTitleDirective } from './popover-title.directive';
+import * as i0 from "@angular/core";
+export class SapphirePopoverModule {
+}
+SapphirePopoverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SapphirePopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SapphirePopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.0", ngImport: i0, type: SapphirePopoverModule, declarations: [PopoverComponent,
+        PopoverTriggerDirective,
+        PopoverCloseButtonDirective,
+        PopoverTitleDirective], imports: [CommonModule, A11yModule], exports: [PopoverComponent,
+        PopoverTriggerDirective,
+        PopoverCloseButtonDirective,
+        PopoverTitleDirective] });
+SapphirePopoverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SapphirePopoverModule, imports: [CommonModule, A11yModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SapphirePopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        PopoverComponent,
+                        PopoverTriggerDirective,
+                        PopoverCloseButtonDirective,
+                        PopoverTitleDirective,
+                    ],
+                    imports: [CommonModule, A11yModule],
+                    exports: [
+                        PopoverComponent,
+                        PopoverTriggerDirective,
+                        PopoverCloseButtonDirective,
+                        PopoverTitleDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/radio/public_api.mjs

@@ -0,0 +1,8 @@
+// We have separate public_api.ts file for each angular module, to have them
+// exposed as separate entry points. The build is still not emitting separate
+// entry points, which will be addressed in this task:
+// WCCJ-838
+export * from './src/radio.component';
+export * from './src/radio-group.component';
+export * from './src/radio.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvcmFkaW8vcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw0RUFBNEU7QUFDNUUsNkVBQTZFO0FBQzdFLHNEQUFzRDtBQUN0RCxXQUFXO0FBQ1gsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBXZSBoYXZlIHNlcGFyYXRlIHB1YmxpY19hcGkudHMgZmlsZSBmb3IgZWFjaCBhbmd1bGFyIG1vZHVsZSwgdG8gaGF2ZSB0aGVtXG4vLyBleHBvc2VkIGFzIHNlcGFyYXRlIGVudHJ5IHBvaW50cy4gVGhlIGJ1aWxkIGlzIHN0aWxsIG5vdCBlbWl0dGluZyBzZXBhcmF0ZVxuLy8gZW50cnkgcG9pbnRzLCB3aGljaCB3aWxsIGJlIGFkZHJlc3NlZCBpbiB0aGlzIHRhc2s6XG4vLyBXQ0NKLTgzOFxuZXhwb3J0ICogZnJvbSAnLi9zcmMvcmFkaW8uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3JhZGlvLWdyb3VwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9yYWRpby5tb2R1bGUnO1xuIl19