@theseam/ui-common 0.3.11 → 0.4.0-beta.0

package/esm2020/shared/directives/auto-focus.directive.mjs

@@ -0,0 +1,54 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Input, Optional } from '@angular/core';
+import { getClosestModal } from '@theseam/ui-common/modal';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/modal";
+export class AutoFocusDirective {
+    constructor(_elementRef, _modal, _modalRef) {
+        this._elementRef = _elementRef;
+        this._modal = _modal;
+        this._modalRef = _modalRef;
+        this._focus = true;
+        this.modalRef = _modalRef;
+    }
+    ngOnInit() {
+        if (!this.modalRef) {
+            // When this directive is included in a dialog via TemplateRef (rather than being
+            // in a Component), the DialogRef isn't available via injection because embedded
+            // views cannot be given a custom injector. Instead, we look up the DialogRef by
+            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't
+            // be resolved at constructor time.
+            this.modalRef = getClosestModal(this._elementRef, this._modal.openDialogs);
+        }
+        if (!this.modalRef) {
+            if (this._focus) {
+                setTimeout(() => { this.focus(); });
+            }
+        }
+        else {
+            this.modalRef.afterOpened().subscribe(() => {
+                setTimeout(() => { this.focus(); });
+            });
+        }
+    }
+    set seamAutoFocus(condition) {
+        this._focus = coerceBooleanProperty(condition) !== false;
+    }
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+}
+AutoFocusDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: AutoFocusDirective, deps: [{ token: i0.ElementRef }, { token: i1.Modal }, { token: i1.ModalRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+AutoFocusDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: AutoFocusDirective, selector: "[seamAutoFocus]", inputs: { seamAutoFocus: "seamAutoFocus" }, exportAs: ["seamAutoFocus"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: AutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamAutoFocus]',
+                    exportAs: 'seamAutoFocus'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Modal }, { type: i1.ModalRef, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { seamAutoFocus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/directives/click-outside.directive.mjs

@@ -0,0 +1,52 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickOutsideDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this._active = true;
+        this.seamClickOutside = new EventEmitter();
+    }
+    get seamClickOutsideActive() {
+        return this._active;
+    }
+    set seamClickOutsideActive(value) {
+        if (this._active === value) {
+            return;
+        }
+        if (value) {
+            // `setTimeout` is used to avoid the click event triggering when the value
+            // changes if the value was changed with a click.
+            setTimeout(() => { this._active = value; });
+        }
+        else {
+            this._active = value;
+        }
+    }
+    // NOTE: This should probably be changed from a `HostListener` to allow the
+    // subscription to be unsubscribed.
+    onDocumentClick(event) {
+        if (this._active) {
+            const targetElement = event.target;
+            // Check if the click was outside the element
+            if (targetElement && !this.elementRef.nativeElement.contains(targetElement)) {
+                this.seamClickOutside.emit(event);
+            }
+        }
+    }
+}
+ClickOutsideDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ClickOutsideDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClickOutsideDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: ClickOutsideDirective, selector: "[seamClickOutside]", inputs: { seamClickOutsideActive: "seamClickOutsideActive" }, outputs: { seamClickOutside: "seamClickOutside" }, host: { listeners: { "document:click": "onDocumentClick($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamClickOutside]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { seamClickOutsideActive: [{
+                type: Input
+            }], seamClickOutside: [{
+                type: Output
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/directives/disable-control.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+// Source: https://netbasal.com/disabling-form-controls-when-working-with-reactive-forms-in-angular-549dd7b42110
+export class DisableControlDirective {
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    set seamDisableControl(condition) {
+        const action = condition ? 'disable' : 'enable';
+        const control = this.ngControl.control;
+        if (control) {
+            control[action]();
+        }
+    }
+}
+DisableControlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DisableControlDirective, deps: [{ token: i1.NgControl }], target: i0.ɵɵFactoryTarget.Directive });
+DisableControlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: DisableControlDirective, selector: "[seamDisableControl]", inputs: { seamDisableControl: "seamDisableControl" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DisableControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamDisableControl]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl }]; }, propDecorators: { seamDisableControl: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzYWJsZS1jb250cm9sLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zaGFyZWQvZGlyZWN0aXZlcy9kaXNhYmxlLWNvbnRyb2wuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFBOzs7QUFHaEQsZ0hBQWdIO0FBS2hILE1BQU0sT0FBTyx1QkFBdUI7SUFVbEMsWUFBb0IsU0FBb0I7UUFBcEIsY0FBUyxHQUFULFNBQVMsQ0FBVztJQUFJLENBQUM7SUFSN0MsSUFBYSxrQkFBa0IsQ0FBQyxTQUFrQjtRQUNoRCxNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFBO1FBQy9DLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFBO1FBQ3RDLElBQUksT0FBTyxFQUFFO1lBQ1gsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUE7U0FDbEI7SUFDSCxDQUFDOztvSEFSVSx1QkFBdUI7d0dBQXZCLHVCQUF1QjsyRkFBdkIsdUJBQXVCO2tCQUhuQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxzQkFBc0I7aUJBQ2pDO2dHQUdjLGtCQUFrQjtzQkFBOUIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgTmdDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnXG5cbi8vIFNvdXJjZTogaHR0cHM6Ly9uZXRiYXNhbC5jb20vZGlzYWJsaW5nLWZvcm0tY29udHJvbHMtd2hlbi13b3JraW5nLXdpdGgtcmVhY3RpdmUtZm9ybXMtaW4tYW5ndWxhci01NDlkZDdiNDIxMTBcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3NlYW1EaXNhYmxlQ29udHJvbF0nXG59KVxuZXhwb3J0IGNsYXNzIERpc2FibGVDb250cm9sRGlyZWN0aXZlIHtcblxuICBASW5wdXQoKSBzZXQgc2VhbURpc2FibGVDb250cm9sKGNvbmRpdGlvbjogYm9vbGVhbikge1xuICAgIGNvbnN0IGFjdGlvbiA9IGNvbmRpdGlvbiA/ICdkaXNhYmxlJyA6ICdlbmFibGUnXG4gICAgY29uc3QgY29udHJvbCA9IHRoaXMubmdDb250cm9sLmNvbnRyb2xcbiAgICBpZiAoY29udHJvbCkge1xuICAgICAgY29udHJvbFthY3Rpb25dKClcbiAgICB9XG4gIH1cblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIG5nQ29udHJvbDogTmdDb250cm9sKSB7IH1cblxufVxuIl19

package/esm2020/shared/directives/elem-resized.directive.mjs

@@ -0,0 +1,28 @@
+import { Directive, EventEmitter, Output } from '@angular/core';
+import { ResizeSensor } from 'css-element-queries';
+import * as i0 from "@angular/core";
+export class ElemResizedDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.seamElemResized = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        this.sensor = new ResizeSensor(this.elementRef.nativeElement, (event) => {
+            this.seamElemResized.emit({ element: this.elementRef.nativeElement, size: event });
+        });
+    }
+    ngOnDestroy() {
+        this.sensor?.detach();
+    }
+}
+ElemResizedDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ElemResizedDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ElemResizedDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: ElemResizedDirective, selector: "[seamElemResized]", outputs: { seamElemResized: "seamElemResized" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ElemResizedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamElemResized]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { seamElemResized: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbS1yZXNpemVkLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zaGFyZWQvZGlyZWN0aXZlcy9lbGVtLXJlc2l6ZWQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBaUIsU0FBUyxFQUFjLFlBQVksRUFBYSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFFckcsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFBOztBQVVsRCxNQUFNLE9BQU8sb0JBQW9CO0lBTS9CLFlBQW9CLFVBQXNCO1FBQXRCLGVBQVUsR0FBVixVQUFVLENBQVk7UUFKaEMsb0JBQWUsR0FBRyxJQUFJLFlBQVksRUFBd0IsQ0FBQTtJQUl0QixDQUFDO0lBRS9DLGVBQWU7UUFDYixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksWUFBWSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxFQUFFLENBQUMsS0FBSyxFQUFFLEVBQUU7WUFDdEUsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUE7UUFDcEYsQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLENBQUE7SUFDdkIsQ0FBQzs7aUhBaEJVLG9CQUFvQjtxR0FBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBSGhDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG1CQUFtQjtpQkFDOUI7aUdBR1csZUFBZTtzQkFBeEIsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyVmlld0luaXQsIERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgRXZlbnRFbWl0dGVyLCBPbkRlc3Ryb3ksIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IFJlc2l6ZVNlbnNvciB9IGZyb20gJ2Nzcy1lbGVtZW50LXF1ZXJpZXMnXG5cbmV4cG9ydCBpbnRlcmZhY2UgSUVsZW1lbnRSZXNpemVkRXZlbnQge1xuICBlbGVtZW50OiBIVE1MRWxlbWVudFxuICBzaXplOiB7IHdpZHRoOiBudW1iZXIsIGhlaWdodDogbnVtYmVyIH1cbn1cblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3NlYW1FbGVtUmVzaXplZF0nXG59KVxuZXhwb3J0IGNsYXNzIEVsZW1SZXNpemVkRGlyZWN0aXZlIGltcGxlbWVudHMgT25EZXN0cm95LCBBZnRlclZpZXdJbml0IHtcblxuICBAT3V0cHV0KCkgc2VhbUVsZW1SZXNpemVkID0gbmV3IEV2ZW50RW1pdHRlcjxJRWxlbWVudFJlc2l6ZWRFdmVudD4oKVxuXG4gIHNlbnNvcj86IFJlc2l6ZVNlbnNvclxuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgZWxlbWVudFJlZjogRWxlbWVudFJlZikgeyB9XG5cbiAgbmdBZnRlclZpZXdJbml0KCkge1xuICAgIHRoaXMuc2Vuc29yID0gbmV3IFJlc2l6ZVNlbnNvcih0aGlzLmVsZW1lbnRSZWYubmF0aXZlRWxlbWVudCwgKGV2ZW50KSA9PiB7XG4gICAgICB0aGlzLnNlYW1FbGVtUmVzaXplZC5lbWl0KHsgZWxlbWVudDogdGhpcy5lbGVtZW50UmVmLm5hdGl2ZUVsZW1lbnQsIHNpemU6IGV2ZW50IH0pXG4gICAgfSlcbiAgfVxuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIHRoaXMuc2Vuc29yPy5kZXRhY2goKVxuICB9XG5cbn1cbiJdfQ==

package/esm2020/shared/directives/hover-class-toggle.directive.mjs

@@ -0,0 +1,88 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Don't use this directive unless there is a reason not to use css `:hover`,
+ * because the accuracy of detecting the hover is not as good. If an element is
+ * moved while the mouse is idle the hover class will remain until the mouse
+ * enters and leaves again.
+ *
+ * I have tried multiple ways of detecting the mouse no longer hovering, but all
+ * have introduced a slight performance issue that just builds for each element
+ * containing this directive.
+ */
+export class HoverClassToggleDirective {
+    constructor(_element) {
+        this._element = _element;
+        this._hovered = false;
+        this._defaultClasses = [];
+        this._hoverClasses = [];
+    }
+    onMouseOver($event) {
+        this._setHovered(true);
+    }
+    onMouseOut($event) {
+        this._setHovered(false);
+    }
+    onPointerOver($event) {
+        this._setHovered(true);
+    }
+    onPointerOut($event) {
+        this._setHovered(false);
+    }
+    set seamHoverClassToggle(value) {
+        if (value) {
+            if (value.default) {
+                this._defaultClasses = value.default.split(' ').filter(c => c.length > 0);
+            }
+            if (value.hover) {
+                this._hoverClasses = value.hover.split(' ').filter(c => c.length > 0);
+            }
+        }
+        this._hoverClasses = this._hoverClasses.filter(v => !this._defaultClasses.find(_v => _v === v));
+        this._update();
+    }
+    _update() {
+        for (const c of this._defaultClasses) {
+            this._hovered ? this._removeClass(c) : this._addClass(c);
+        }
+        for (const c of this._hoverClasses) {
+            this._hovered ? this._addClass(c) : this._removeClass(c);
+        }
+    }
+    _setHovered(hovered) {
+        const doUpdate = this._hovered !== hovered;
+        this._hovered = hovered;
+        if (doUpdate) {
+            this._update();
+        }
+    }
+    _addClass(c) {
+        this._element.nativeElement.classList.add(c);
+    }
+    _removeClass(c) {
+        this._element.nativeElement.classList.remove(c);
+    }
+}
+HoverClassToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: HoverClassToggleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+HoverClassToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: HoverClassToggleDirective, selector: "[seamHoverClassToggle]", inputs: { seamHoverClassToggle: "seamHoverClassToggle" }, host: { listeners: { "mouseover": "onMouseOver($event)", "mouseout": "onMouseOut($event)", "pointerover": "onPointerOver($event)", "pointerout": "onPointerOut($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: HoverClassToggleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamHoverClassToggle]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onMouseOver: [{
+                type: HostListener,
+                args: ['mouseover', ['$event']]
+            }], onMouseOut: [{
+                type: HostListener,
+                args: ['mouseout', ['$event']]
+            }], onPointerOver: [{
+                type: HostListener,
+                args: ['pointerover', ['$event']]
+            }], onPointerOut: [{
+                type: HostListener,
+                args: ['pointerout', ['$event']]
+            }], seamHoverClassToggle: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/directives/hover-class.directive.mjs

@@ -0,0 +1,82 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Don't use this directive unless there is a reason not to use css `:hover`,
+ * because the accuracy of detecting the hover is not as good. If an element is
+ * moved while the mouse is idle the hover class will remain until the mouse
+ * enters and leaves again.
+ *
+ * I have tried multiple ways of detecting the mouse no longer hovering, but all
+ * have introduced a slight performance issue that just builds for each element
+ * containing this directive.
+ */
+export class HoverClassDirective {
+    constructor(_element) {
+        this._element = _element;
+        this._hovered = false;
+        this._classes = [];
+    }
+    onMouseOver($event) {
+        this._setHovered(true);
+    }
+    onMouseOut($event) {
+        this._setHovered(false);
+    }
+    onPointerOver($event) {
+        this._setHovered(true);
+    }
+    onPointerOut($event) {
+        this._setHovered(false);
+    }
+    set seamHoverClass(classList) {
+        const newClasses = classList.split(' ').filter(c => c.length > 0);
+        for (const c of this._classes) {
+            if (newClasses.indexOf(c) !== 0) {
+                this._removeClass(c);
+            }
+        }
+        this._classes = newClasses;
+        this._update();
+    }
+    _update() {
+        for (const c of this._classes) {
+            this._hovered ? this._addClass(c) : this._removeClass(c);
+        }
+    }
+    _setHovered(hovered) {
+        const doUpdate = this._hovered !== hovered;
+        this._hovered = hovered;
+        if (doUpdate) {
+            this._update();
+        }
+    }
+    _addClass(c) {
+        this._element.nativeElement.classList.add(c);
+    }
+    _removeClass(c) {
+        this._element.nativeElement.classList.remove(c);
+    }
+}
+HoverClassDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: HoverClassDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+HoverClassDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: HoverClassDirective, selector: "[seamHoverClass]", inputs: { seamHoverClass: "seamHoverClass" }, host: { listeners: { "mouseover": "onMouseOver($event)", "mouseout": "onMouseOut($event)", "pointerover": "onPointerOver($event)", "pointerout": "onPointerOut($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: HoverClassDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamHoverClass]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onMouseOver: [{
+                type: HostListener,
+                args: ['mouseover', ['$event']]
+            }], onMouseOut: [{
+                type: HostListener,
+                args: ['mouseout', ['$event']]
+            }], onPointerOver: [{
+                type: HostListener,
+                args: ['pointerover', ['$event']]
+            }], onPointerOut: [{
+                type: HostListener,
+                args: ['pointerout', ['$event']]
+            }], seamHoverClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/directives/ng-select-extra.directive.mjs

@@ -0,0 +1,184 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Optional, Self } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { ResizeSensor } from 'css-element-queries';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-select/ng-select";
+import * as i2 from "@angular/forms";
+export class NgSelectExtraDirective {
+    constructor(elementRef, _ngZone, ngSelect, ngControl) {
+        this.elementRef = elementRef;
+        this._ngZone = _ngZone;
+        this.ngSelect = ngSelect;
+        this.ngControl = ngControl;
+        this._ngUnsubscribe = new Subject();
+        this._markedItem = null;
+        this._checkMarked = false;
+        this._keyPressWorkaroundSub = null;
+        this._resizedEvent = new EventEmitter();
+        this._onScroll = (event) => {
+            if (this.ngSelect && this.ngSelect.isOpen) {
+                const isScrollingInScrollHost = event.target.className.indexOf('ng-dropdown-panel-items') !== -1;
+                const isInSensor = event.target.className.indexOf('resize-sensor-shrink') !== -1 ||
+                    event.target.className.indexOf('os-resize-observer-host') !== -1;
+                if (isScrollingInScrollHost || isInSensor) {
+                    return;
+                }
+                this.ngSelect.close();
+            }
+        };
+    }
+    /**
+     * Set the tab index to `-1` to allow the root element of the ng-select
+     * component to receive `focus` event from javascript, but not get focused by
+     * keyboard navigation.
+     */
+    get _tabIndex() { return this.ngSelect.disabled ? undefined : -1; }
+    /**
+     * Listening for focus event on root of component to allow javascript
+     * `focus()` function to trigger the components focus.
+     */
+    onFocus($event) {
+        const target = $event.target;
+        if (target === this.elementRef.nativeElement && !this.ngSelect.disabled) {
+            this.ngSelect.focus();
+        }
+        // ng-select has an input `labelForId` that sets the autocomplete attribute
+        // in ngOnInit. I am not positive that it is wrong by doing that, but this
+        // hack makes it set the attributes again on focus, because that gives the
+        // result I was expecting, since we don't manually set the `labelForId`
+        // input.
+        const _ngSelect = this.ngSelect;
+        _ngSelect._setInputAttributes();
+    }
+    get _isInvalid() {
+        return this.ngControl ? this.ngControl.invalid && (this.ngControl.dirty || this.ngControl.touched) : false;
+    }
+    get _isEmptyStringValue() {
+        return this.ngControl ? this.ngControl.value === '' ? true : false : false;
+    }
+    ngOnInit() {
+        this.ngSelect.focusEvent
+            .subscribe(v => this._enableKeyPressWorkaround());
+        this.ngSelect.blurEvent
+            .subscribe(v => this._disableKeyPressWorkaround());
+        window.addEventListener('scroll', this._onScroll, true);
+        // When the input is allowed to change its height the position doesn't update itself.
+        // this._resizedEvent.pipe(
+        //   auditTime(30)
+        // ).subscribe(event => {
+        //   if (this.elementRef && this.elementRef.nativeElement) {
+        //     if (this.elementRef.nativeElement.classList.contains('ng-select-value-grow-h')) {
+        //       if (this.ngSelect.isOpen && this.ngSelect.dropdownPanel) {
+        //         this.ngSelect.dropdownPanel.updateDropdownPosition()
+        //       }
+        //     } else {
+        //       this.elementRef.nativeElement.classList.remove('ng-select-value-grow-h')
+        //     }
+        //   }
+        // })
+        // this._patch_ngSelect_open()
+    }
+    ngOnDestroy() {
+        this._resizeSensor?.detach();
+        window.removeEventListener('scroll', this._onScroll, true);
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewChecked() {
+        if (this.ngSelect.dropdownPanel) {
+            if (this._checkMarked) {
+                if (this.ngSelect.dropdownPanel && this._markedItem !== null) {
+                    if (this._markedItem.index !== this.ngSelect.dropdownPanel.markedItem.index) {
+                        this.ngSelect.dropdownPanel.scrollTo(this.ngSelect.dropdownPanel.markedItem);
+                    }
+                }
+            }
+        }
+        this._checkMarked = false;
+        this._resizeSensor = new ResizeSensor(this.elementRef.nativeElement, (event) => {
+            this._resizedEvent.emit({ element: this.elementRef.nativeElement, size: event });
+        });
+    }
+    /**
+     * Temp fix for: https://github.com/ng-select/ng-select/issues/1122
+     */
+    // private _patch_ngSelect_open() {
+    //   const original = this.ngSelect.open
+    //   const _self = this
+    //   this.ngSelect.open = function() {
+    //     original.apply(this, arguments)
+    //     _self._patch_ngSelectDropdownPanel_updateDropdownPosition()
+    //   }
+    // }
+    /** Should ONLY be called by `_patch_ngSelect_open`. */
+    // private _patch_ngSelectDropdownPanel_updateDropdownPosition() {
+    //   if (!this.ngSelect.dropdownPanel) { return }
+    //   const drop: any = this.ngSelect.dropdownPanel
+    //   // Only needed once, to update the position before the timeout in
+    //   // `updateDropdownPosition()`. So, using this variable to check if I already called
+    //   // `_updateAppendedDropdownPosition()`.
+    //   if (!drop.__libPatched) {
+    //     drop.__libPatched = 'patched'
+    //     const original = drop.updateDropdownPosition
+    //     const _self = this
+    //     drop.updateDropdownPosition = function() {
+    //       original.apply(this, arguments)
+    //       if (!!_self.ngSelect.appendTo) {
+    //         drop._updateAppendedDropdownPosition()
+    //       }
+    //     }
+    //   }
+    // }
+    _enableKeyPressWorkaround() {
+        if (this._keyPressWorkaroundSub) {
+            return;
+        }
+        const _ngSelect = this.ngSelect;
+        this._keyPressWorkaroundSub = _ngSelect._keyPress$
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .pipe(filter(() => !this.ngSelect.searchable))
+            .subscribe(() => {
+            this._ngZone.runOutsideAngular(() => {
+                window.requestAnimationFrame(() => {
+                    if (this.ngSelect.dropdownPanel) {
+                        this._markedItem = this.ngSelect.dropdownPanel.markedItem;
+                    }
+                    this._checkMarked = true;
+                });
+            });
+        });
+    }
+    _disableKeyPressWorkaround() {
+        if (this._keyPressWorkaroundSub) {
+            this._keyPressWorkaroundSub.unsubscribe();
+            this._keyPressWorkaroundSub = null;
+        }
+    }
+}
+NgSelectExtraDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: NgSelectExtraDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.NgSelectComponent }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive });
+NgSelectExtraDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.3", type: NgSelectExtraDirective, selector: "ng-select", host: { listeners: { "focus": "onFocus($event)" }, properties: { "attr.tabIndex": "this._tabIndex", "class.is-invalid": "this._isInvalid", "class.ng-empty-string-value": "this._isEmptyStringValue" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: NgSelectExtraDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // tslint:disable-next-line:directive-selector
+                    selector: 'ng-select'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.NgSelectComponent }, { type: i2.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; }, propDecorators: { _tabIndex: [{
+                type: HostBinding,
+                args: ['attr.tabIndex']
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus', ['$event']]
+            }], _isInvalid: [{
+                type: HostBinding,
+                args: ['class.is-invalid']
+            }], _isEmptyStringValue: [{
+                type: HostBinding,
+                args: ['class.ng-empty-string-value']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-select-extra.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/shared/directives/ng-select-extra.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewChecked, Directive, ElementRef, EventEmitter, HostBinding,\n  HostListener, NgZone, OnDestroy, OnInit, Optional, Self } from '@angular/core'\nimport { NgControl } from '@angular/forms'\nimport { Subject, Subscription } from 'rxjs'\nimport { filter, takeUntil } from 'rxjs/operators'\n\nimport { NgOption, NgSelectComponent } from '@ng-select/ng-select'\nimport { ResizeSensor } from 'css-element-queries'\n\nimport { IElementResizedEvent } from './elem-resized.directive'\n\n@Directive({\n  // tslint:disable-next-line:directive-selector\n  selector: 'ng-select'\n})\nexport class NgSelectExtraDirective implements OnInit, AfterViewChecked, OnDestroy {\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  private _markedItem: NgOption | null = null\n  private _checkMarked = false\n  private _keyPressWorkaroundSub: Subscription | null = null\n\n  private _resizedEvent = new EventEmitter<IElementResizedEvent>()\n  private _resizeSensor?: ResizeSensor\n\n  /**\n   * Set the tab index to `-1` to allow the root element of the ng-select\n   * component to receive `focus` event from javascript, but not get focused by\n   * keyboard navigation.\n   */\n  @HostBinding('attr.tabIndex')\n  get _tabIndex() { return this.ngSelect.disabled ? undefined : -1 }\n\n  /**\n   * Listening for focus event on root of component to allow javascript\n   * `focus()` function to trigger the components focus.\n   */\n  @HostListener('focus', ['$event']) onFocus($event: FocusEvent) {\n    const target = $event.target as HTMLElement\n    if (target === this.elementRef.nativeElement && !this.ngSelect.disabled) {\n      this.ngSelect.focus()\n    }\n\n    // ng-select has an input `labelForId` that sets the autocomplete attribute\n    // in ngOnInit. I am not positive that it is wrong by doing that, but this\n    // hack makes it set the attributes again on focus, because that gives the\n    // result I was expecting, since we don't manually set the `labelForId`\n    // input.\n    const _ngSelect = this.ngSelect as any\n    _ngSelect._setInputAttributes()\n  }\n\n  @HostBinding('class.is-invalid') get _isInvalid() {\n    return this.ngControl ? this.ngControl.invalid && (this.ngControl.dirty || this.ngControl.touched) : false\n  }\n\n  @HostBinding('class.ng-empty-string-value') get _isEmptyStringValue() {\n    return this.ngControl ? this.ngControl.value === '' ? true : false : false\n  }\n\n  constructor(\n    private readonly elementRef: ElementRef,\n    private readonly _ngZone: NgZone,\n    private readonly ngSelect: NgSelectComponent,\n    @Optional() @Self() public readonly ngControl: NgControl\n  ) { }\n\n  ngOnInit() {\n    this.ngSelect.focusEvent\n      .subscribe(v => this._enableKeyPressWorkaround())\n\n    this.ngSelect.blurEvent\n      .subscribe(v => this._disableKeyPressWorkaround())\n\n    window.addEventListener('scroll', this._onScroll, true)\n\n    // When the input is allowed to change its height the position doesn't update itself.\n    // this._resizedEvent.pipe(\n    //   auditTime(30)\n    // ).subscribe(event => {\n    //   if (this.elementRef && this.elementRef.nativeElement) {\n    //     if (this.elementRef.nativeElement.classList.contains('ng-select-value-grow-h')) {\n    //       if (this.ngSelect.isOpen && this.ngSelect.dropdownPanel) {\n    //         this.ngSelect.dropdownPanel.updateDropdownPosition()\n    //       }\n    //     } else {\n    //       this.elementRef.nativeElement.classList.remove('ng-select-value-grow-h')\n    //     }\n    //   }\n    // })\n\n    // this._patch_ngSelect_open()\n  }\n\n  ngOnDestroy() {\n    this._resizeSensor?.detach()\n\n    window.removeEventListener('scroll', this._onScroll, true)\n\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  ngAfterViewChecked() {\n    if (this.ngSelect.dropdownPanel) {\n      if (this._checkMarked) {\n        if (this.ngSelect.dropdownPanel && this._markedItem !== null) {\n          if (this._markedItem.index !== this.ngSelect.dropdownPanel.markedItem.index) {\n            this.ngSelect.dropdownPanel.scrollTo(this.ngSelect.dropdownPanel.markedItem)\n          }\n        }\n      }\n    }\n    this._checkMarked = false\n\n    this._resizeSensor = new ResizeSensor(this.elementRef.nativeElement, (event) => {\n      this._resizedEvent.emit({ element: this.elementRef.nativeElement, size: event })\n    })\n  }\n\n  private _onScroll = (event: any) => {\n    if (this.ngSelect && this.ngSelect.isOpen) {\n      const isScrollingInScrollHost = (event.target.className as string).indexOf('ng-dropdown-panel-items') !== -1\n      const isInSensor = (event.target.className as string).indexOf('resize-sensor-shrink') !== -1 ||\n        (event.target.className as string).indexOf('os-resize-observer-host') !== -1\n      if (isScrollingInScrollHost || isInSensor) { return }\n      this.ngSelect.close()\n    }\n}\n\n  /**\n   * Temp fix for: https://github.com/ng-select/ng-select/issues/1122\n   */\n  // private _patch_ngSelect_open() {\n  //   const original = this.ngSelect.open\n  //   const _self = this\n  //   this.ngSelect.open = function() {\n  //     original.apply(this, arguments)\n  //     _self._patch_ngSelectDropdownPanel_updateDropdownPosition()\n  //   }\n  // }\n\n  /** Should ONLY be called by `_patch_ngSelect_open`. */\n  // private _patch_ngSelectDropdownPanel_updateDropdownPosition() {\n  //   if (!this.ngSelect.dropdownPanel) { return }\n  //   const drop: any = this.ngSelect.dropdownPanel\n  //   // Only needed once, to update the position before the timeout in\n  //   // `updateDropdownPosition()`. So, using this variable to check if I already called\n  //   // `_updateAppendedDropdownPosition()`.\n  //   if (!drop.__libPatched) {\n  //     drop.__libPatched = 'patched'\n  //     const original = drop.updateDropdownPosition\n  //     const _self = this\n  //     drop.updateDropdownPosition = function() {\n  //       original.apply(this, arguments)\n  //       if (!!_self.ngSelect.appendTo) {\n  //         drop._updateAppendedDropdownPosition()\n  //       }\n  //     }\n  //   }\n  // }\n\n  private _enableKeyPressWorkaround() {\n    if (this._keyPressWorkaroundSub) { return }\n    const _ngSelect = <any>this.ngSelect\n\n    this._keyPressWorkaroundSub = _ngSelect._keyPress$\n      .pipe(takeUntil(this._ngUnsubscribe))\n      .pipe(filter(() => !this.ngSelect.searchable))\n      .subscribe(() => {\n        this._ngZone.runOutsideAngular(() => {\n          window.requestAnimationFrame(() => {\n            if (this.ngSelect.dropdownPanel) {\n              this._markedItem = this.ngSelect.dropdownPanel.markedItem\n            }\n            this._checkMarked = true\n          })\n        })\n      })\n  }\n\n  private _disableKeyPressWorkaround() {\n    if (this._keyPressWorkaroundSub) {\n      this._keyPressWorkaroundSub.unsubscribe()\n      this._keyPressWorkaroundSub = null\n    }\n  }\n\n}\n"]}