@impartner/design-components 1.0.0

package/esm2020/lib/scrollable/scrollable.component.mjs

@@ -0,0 +1,193 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../size-detection/directive/size-detector.directive";
+/**
+ * The `ScrollableComponent` (`<impdc-scrollable` or `<div impdc-scrollable`) is a container that hides items that wouldn't fit
+ * with arrows on the left and right to slide between them.
+ * To use, import `ScrollableModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ScrollableModule` also imports and exports [BrandingModule](./?path=/docs/design-components-directives-impdcbranded).
+ */
+export class ScrollableComponent {
+    constructor(_cd) {
+        this._cd = _cd;
+        /**
+         * The base amount to scroll.
+         */
+        this.scrollUnit = 20;
+        /**
+         * Used in combination with `scrollUnit` to determine how far the Scrollable scrolls when directional arrows are clicked.
+         */
+        this.clickScrollMultiplier = 5;
+        this._scrollableBgColor = null;
+        this._width = 0;
+    }
+    get canScrollLeft() {
+        if (!this._contentElement) {
+            return false;
+        }
+        return Math.floor(this._contentElement.scrollLeft) > 0;
+    }
+    get canScrollRight() {
+        if (!this._contentElement) {
+            return false;
+        }
+        return (Math.ceil(this._contentElement.scrollLeft + this._width) <
+            this._contentElement.scrollWidth);
+    }
+    get _containerElement() {
+        if (!this.containerRef) {
+            return null;
+        }
+        return this.containerRef.nativeElement;
+    }
+    get _contentElement() {
+        if (!this.contentRef) {
+            return null;
+        }
+        return this.contentRef.nativeElement;
+    }
+    ngOnChanges(changes) {
+        if (changes['scrollUnit'] || changes['clickScrollMultiplier']) {
+            if (this._containerElement) {
+                this._width = this._containerElement?.clientWidth;
+                this._cd.detectChanges();
+            }
+        }
+        this._getBackgroundColorForButtons();
+    }
+    ngAfterViewInit() {
+        this._width = this.contentRef?.nativeElement.width;
+        this._getBackgroundColorForButtons();
+        this._cd.detectChanges();
+    }
+    async scroll(direction) {
+        if (!this._contentElement) {
+            return;
+        }
+        let pixels = direction * this.scrollUnit * this.clickScrollMultiplier;
+        let position = 0;
+        if (!pixels) {
+            if (direction === 1) {
+                position = this._contentElement.scrollWidth;
+            }
+        }
+        else {
+            position = this._contentElement.scrollLeft + pixels;
+        }
+        await this._scrollToPosition(this._contentElement, position);
+        this._cd.detectChanges();
+    }
+    widthChanged(elementSize) {
+        if (!elementSize || !elementSize.width) {
+            return;
+        }
+        this._width = elementSize.width;
+        this._cd.detectChanges();
+    }
+    async _scrollToPosition(container, position) {
+        position = Math.round(position);
+        if (container.scrollLeft === position) {
+            return;
+        }
+        let resolveFn;
+        let scrollListener;
+        let timeoutId;
+        const promise = new Promise(resolve => {
+            resolveFn = resolve;
+        });
+        const finished = () => {
+            container.removeEventListener('scroll', scrollListener);
+            resolveFn(null);
+        };
+        scrollListener = () => {
+            clearTimeout(timeoutId);
+            // scroll is finished when either the position has been reached, or 100ms have elapsed since the last scroll event
+            if (container.scrollLeft === position) {
+                finished();
+            }
+            else {
+                timeoutId = setTimeout(finished, 100);
+            }
+        };
+        container.addEventListener('scroll', scrollListener);
+        container.scrollTo({
+            left: position,
+            behavior: 'smooth'
+        });
+        return promise;
+    }
+    _getBackgroundColorForButtons() {
+        if (!this.contentRef) {
+            return;
+        }
+        const projectedElementCollection = this.contentRef.nativeElement.children;
+        if (!projectedElementCollection || !projectedElementCollection.length) {
+            return;
+        }
+        const firstElement = projectedElementCollection[0];
+        let backgroundColor = this._getBackGroundColor(firstElement);
+        if (!backgroundColor) {
+            backgroundColor = this._getAncestorBackgroundColor();
+        }
+        this._scrollableBgColor = backgroundColor;
+    }
+    _getAncestorBackgroundColor() {
+        if (!this.contentRef) {
+            return null;
+        }
+        let result = {
+            parent: this.contentRef.nativeElement.parentElement,
+            backgroundColor: null
+        };
+        let count = 6;
+        function getParentBackgroundColor(currentContext, getBackgroundColor) {
+            const result = { parent: null, backgroundColor: null };
+            if (currentContext && currentContext.parent) {
+                result.backgroundColor = getBackgroundColor(currentContext.parent);
+                if (!result.backgroundColor) {
+                    result.parent = currentContext.parent.parentElement;
+                }
+            }
+            return result;
+        }
+        while (count > 0) {
+            if (result.backgroundColor) {
+                break;
+            }
+            result = getParentBackgroundColor(result, this._getBackGroundColor);
+            if (!result.parent) {
+                break;
+            }
+            count = count - 1;
+        }
+        return result.backgroundColor;
+    }
+    _getBackGroundColor(element) {
+        const computedBackgroundColor = getComputedStyle(element)['backgroundColor'];
+        if (computedBackgroundColor !== 'rgba(0, 0, 0, 0)') {
+            return computedBackgroundColor;
+        }
+        return element.style.backgroundColor;
+    }
+}
+ScrollableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ScrollableComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+ScrollableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ScrollableComponent, selector: "impdc-scrollable, div[impdc-scrollable]", inputs: { scrollUnit: "scrollUnit", clickScrollMultiplier: "clickScrollMultiplier" }, host: { properties: { "style.--impdc-scrollable-bg": "this._scrollableBgColor" } }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["container"], descendants: true }, { propertyName: "contentRef", first: true, predicate: ["content"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"impdc-scrollable\"\n  #container\n  impdcSizeDetector\n  (resized)=\"widthChanged($event)\">\n  <a class=\"impdc-scrollable-left\" (click)=\"scroll(-1)\" *ngIf=\"canScrollLeft\">\n    <i class=\"fas fa-chevron-left default\"></i>\n  </a>\n  <div #content class=\"content-container\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"impdc-scrollable-right\" (click)=\"scroll(1)\" *ngIf=\"canScrollRight\">\n    <i class=\"fas fa-chevron-right default\"></i>\n  </a>\n</div>\n", styles: [".impdc-scrollable{position:relative;overflow-y:hidden}.impdc-scrollable .impdc-scrollable-base,.impdc-scrollable .impdc-scrollable-right,.impdc-scrollable .impdc-scrollable-left{position:absolute;top:0px;bottom:0px;display:flex;align-items:center;text-align:center;width:6.9rem;z-index:1;color:var(--impd-color-motion-blue-600, #01606d)}.impdc-scrollable .impdc-scrollable-left{justify-content:left;padding-left:1.5rem;background-image:linear-gradient(to right,var(--impdc-scrollable-bg, #fff) 50%,rgba(255,255,255,.0001) 86.46%)}.impdc-scrollable .impdc-scrollable-right{right:0;padding-right:1.5rem;justify-content:right;background-image:linear-gradient(to left,var(--impdc-scrollable-bg, #fff) 50%,rgba(255,255,255,.0001) 86.46%)}.impdc-scrollable .content-container{overflow-x:hidden;-webkit-overflow-scrolling:touch;white-space:nowrap}:host(.branded) .impdc-scrollable .impdc-scrollable-left,:host(.branded) .impdc-scrollable .impdc-scrollable-right{color:var(--px-primary-color, var(--impd-color-motion-blue-600, #01606d))}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.SizeDetectorDirective, selector: "[impdcSizeDetector]", outputs: ["resized"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ScrollableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'impdc-scrollable, div[impdc-scrollable]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  class=\"impdc-scrollable\"\n  #container\n  impdcSizeDetector\n  (resized)=\"widthChanged($event)\">\n  <a class=\"impdc-scrollable-left\" (click)=\"scroll(-1)\" *ngIf=\"canScrollLeft\">\n    <i class=\"fas fa-chevron-left default\"></i>\n  </a>\n  <div #content class=\"content-container\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"impdc-scrollable-right\" (click)=\"scroll(1)\" *ngIf=\"canScrollRight\">\n    <i class=\"fas fa-chevron-right default\"></i>\n  </a>\n</div>\n", styles: [".impdc-scrollable{position:relative;overflow-y:hidden}.impdc-scrollable .impdc-scrollable-base,.impdc-scrollable .impdc-scrollable-right,.impdc-scrollable .impdc-scrollable-left{position:absolute;top:0px;bottom:0px;display:flex;align-items:center;text-align:center;width:6.9rem;z-index:1;color:var(--impd-color-motion-blue-600, #01606d)}.impdc-scrollable .impdc-scrollable-left{justify-content:left;padding-left:1.5rem;background-image:linear-gradient(to right,var(--impdc-scrollable-bg, #fff) 50%,rgba(255,255,255,.0001) 86.46%)}.impdc-scrollable .impdc-scrollable-right{right:0;padding-right:1.5rem;justify-content:right;background-image:linear-gradient(to left,var(--impdc-scrollable-bg, #fff) 50%,rgba(255,255,255,.0001) 86.46%)}.impdc-scrollable .content-container{overflow-x:hidden;-webkit-overflow-scrolling:touch;white-space:nowrap}:host(.branded) .impdc-scrollable .impdc-scrollable-left,:host(.branded) .impdc-scrollable .impdc-scrollable-right{color:var(--px-primary-color, var(--impd-color-motion-blue-600, #01606d))}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { scrollUnit: [{
+                type: Input
+            }], clickScrollMultiplier: [{
+                type: Input
+            }], _scrollableBgColor: [{
+                type: HostBinding,
+                args: ['style.--impdc-scrollable-bg']
+            }], containerRef: [{
+                type: ViewChild,
+                args: ['container', { static: false }]
+            }], contentRef: [{
+                type: ViewChild,
+                args: ['content', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrollable.component.js","sourceRoot":"","sources":["../../../../../../projects/design-components/src/lib/scrollable/scrollable.component.ts","../../../../../../projects/design-components/src/lib/scrollable/scrollable.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  HostBinding,\n  Input,\n  OnChanges,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { IElementSize } from '../size-detection';\n\n/**\n * The `ScrollableComponent` (`<impdc-scrollable` or `<div impdc-scrollable`) is a container that hides items that wouldn't fit\n * with arrows on the left and right to slide between them.\n * To use, import `ScrollableModule` or another module that imports and exports that module from `@impartner/design-components`.\n * `ScrollableModule` also imports and exports [BrandingModule](./?path=/docs/design-components-directives-impdcbranded).\n */\n@Component({\n  selector: 'impdc-scrollable, div[impdc-scrollable]',\n  templateUrl: './scrollable.component.html',\n  styleUrls: ['./scrollable.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ScrollableComponent implements OnChanges, AfterViewInit {\n  /**\n   * The base amount to scroll.\n   */\n  @Input()\n  public scrollUnit: number = 20;\n\n  /**\n   * Used in combination with `scrollUnit` to determine how far the Scrollable scrolls when directional arrows are clicked.\n   */\n  @Input()\n  public clickScrollMultiplier = 5;\n\n  @HostBinding('style.--impdc-scrollable-bg')\n  private _scrollableBgColor: string | null = null;\n\n  public get canScrollLeft(): boolean {\n    if (!this._contentElement) {\n      return false;\n    }\n\n    return Math.floor(this._contentElement.scrollLeft) > 0;\n  }\n\n  public get canScrollRight(): boolean {\n    if (!this._contentElement) {\n      return false;\n    }\n\n    return (\n      Math.ceil(this._contentElement.scrollLeft + this._width) <\n      this._contentElement.scrollWidth\n    );\n  }\n\n  private _width: number = 0;\n\n  @ViewChild('container', { static: false })\n  public containerRef: ElementRef | undefined;\n\n  private get _containerElement(): HTMLDivElement | null {\n    if (!this.containerRef) {\n      return null;\n    }\n\n    return this.containerRef.nativeElement;\n  }\n\n  @ViewChild('content', { static: false })\n  public contentRef: ElementRef | undefined;\n\n  private get _contentElement(): HTMLDivElement | null {\n    if (!this.contentRef) {\n      return null;\n    }\n\n    return this.contentRef.nativeElement;\n  }\n\n  constructor(private _cd: ChangeDetectorRef) {}\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (changes['scrollUnit'] || changes['clickScrollMultiplier']) {\n      if (this._containerElement) {\n        this._width = this._containerElement?.clientWidth;\n        this._cd.detectChanges();\n      }\n    }\n    this._getBackgroundColorForButtons();\n  }\n\n  public ngAfterViewInit(): void {\n    this._width = this.contentRef?.nativeElement.width;\n    this._getBackgroundColorForButtons();\n    this._cd.detectChanges();\n  }\n\n  public async scroll(direction: number): Promise<void> {\n    if (!this._contentElement) {\n      return;\n    }\n\n    let pixels = direction * this.scrollUnit * this.clickScrollMultiplier;\n    let position = 0;\n\n    if (!pixels) {\n      if (direction === 1) {\n        position = this._contentElement.scrollWidth;\n      }\n    } else {\n      position = this._contentElement.scrollLeft + pixels;\n    }\n\n    await this._scrollToPosition(this._contentElement, position);\n\n    this._cd.detectChanges();\n  }\n\n  public widthChanged(elementSize: IElementSize): void {\n    if (!elementSize || !elementSize.width) {\n      return;\n    }\n    this._width = elementSize.width;\n    this._cd.detectChanges();\n  }\n\n  private async _scrollToPosition(container: HTMLDivElement, position: number) {\n    position = Math.round(position);\n\n    if (container.scrollLeft === position) {\n      return;\n    }\n\n    let resolveFn: (value: unknown) => void;\n    let scrollListener: () => void;\n    let timeoutId: any;\n\n    const promise = new Promise(resolve => {\n      resolveFn = resolve;\n    });\n\n    const finished = () => {\n      container.removeEventListener('scroll', scrollListener);\n      resolveFn(null);\n    };\n\n    scrollListener = () => {\n      clearTimeout(timeoutId);\n\n      // scroll is finished when either the position has been reached, or 100ms have elapsed since the last scroll event\n      if (container.scrollLeft === position) {\n        finished();\n      } else {\n        timeoutId = setTimeout(finished, 100);\n      }\n    };\n\n    container.addEventListener('scroll', scrollListener);\n\n    container.scrollTo({\n      left: position,\n      behavior: 'smooth'\n    });\n\n    return promise;\n  }\n\n  private _getBackgroundColorForButtons(): void {\n    if (!this.contentRef) {\n      return;\n    }\n\n    const projectedElementCollection: HTMLCollection =\n      this.contentRef.nativeElement.children;\n\n    if (!projectedElementCollection || !projectedElementCollection.length) {\n      return;\n    }\n\n    const firstElement = projectedElementCollection[0] as HTMLElement;\n    let backgroundColor: string | null = this._getBackGroundColor(firstElement);\n\n    if (!backgroundColor) {\n      backgroundColor = this._getAncestorBackgroundColor();\n    }\n\n    this._scrollableBgColor = backgroundColor;\n  }\n\n  private _getAncestorBackgroundColor(): string | null {\n    if (!this.contentRef) {\n      return null;\n    }\n\n    type parentBgResult = {\n      parent: HTMLElement | null;\n      backgroundColor: string | null;\n    };\n\n    let result: parentBgResult = {\n      parent: (this.contentRef.nativeElement as HTMLElement).parentElement,\n      backgroundColor: null\n    };\n\n    let count = 6;\n\n    function getParentBackgroundColor(\n      currentContext: parentBgResult,\n      getBackgroundColor: (element: HTMLElement) => string | null\n    ): parentBgResult {\n      const result: parentBgResult = { parent: null, backgroundColor: null };\n      if (currentContext && currentContext.parent) {\n        result.backgroundColor = getBackgroundColor(currentContext.parent);\n\n        if (!result.backgroundColor) {\n          result.parent = currentContext.parent.parentElement;\n        }\n      }\n\n      return result;\n    }\n\n    while (count > 0) {\n      if (result.backgroundColor) {\n        break;\n      }\n      result = getParentBackgroundColor(result, this._getBackGroundColor);\n\n      if (!result.parent) {\n        break;\n      }\n      count = count - 1;\n    }\n\n    return result.backgroundColor;\n  }\n\n  private _getBackGroundColor(element: HTMLElement): string | null {\n    const computedBackgroundColor =\n      getComputedStyle(element)['backgroundColor'];\n\n    if (computedBackgroundColor !== 'rgba(0, 0, 0, 0)') {\n      return computedBackgroundColor;\n    }\n\n    return element.style.backgroundColor;\n  }\n}\n","<div\n  class=\"impdc-scrollable\"\n  #container\n  impdcSizeDetector\n  (resized)=\"widthChanged($event)\">\n  <a class=\"impdc-scrollable-left\" (click)=\"scroll(-1)\" *ngIf=\"canScrollLeft\">\n    <i class=\"fas fa-chevron-left default\"></i>\n  </a>\n  <div #content class=\"content-container\">\n    <ng-content></ng-content>\n  </div>\n  <a class=\"impdc-scrollable-right\" (click)=\"scroll(1)\" *ngIf=\"canScrollRight\">\n    <i class=\"fas fa-chevron-right default\"></i>\n  </a>\n</div>\n"]}

package/esm2020/lib/scrollable/scrollable.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { BrandingModule } from '../branding';
+import { SizeDetectionModule } from '../size-detection';
+import { ScrollableComponent } from './scrollable.component';
+import * as i0 from "@angular/core";
+export class ScrollableModule {
+    constructor() { }
+}
+ScrollableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ScrollableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ScrollableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: ScrollableModule, declarations: [ScrollableComponent], imports: [CommonModule, SizeDetectionModule, BrandingModule], exports: [ScrollableComponent, BrandingModule] });
+ScrollableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ScrollableModule, imports: [CommonModule, SizeDetectionModule, BrandingModule, BrandingModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ScrollableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SizeDetectionModule, BrandingModule],
+                    declarations: [ScrollableComponent],
+                    exports: [ScrollableComponent, BrandingModule]
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsYWJsZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tY29tcG9uZW50cy9zcmMvbGliL3Njcm9sbGFibGUvc2Nyb2xsYWJsZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM3QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFPN0QsTUFBTSxPQUFPLGdCQUFnQjtJQUMzQixnQkFBZSxDQUFDOzs4R0FETCxnQkFBZ0I7K0dBQWhCLGdCQUFnQixpQkFIWixtQkFBbUIsYUFEeEIsWUFBWSxFQUFFLG1CQUFtQixFQUFFLGNBQWMsYUFFakQsbUJBQW1CLEVBQUUsY0FBYzsrR0FFbEMsZ0JBQWdCLFlBSmpCLFlBQVksRUFBRSxtQkFBbUIsRUFBRSxjQUFjLEVBRTVCLGNBQWM7NEZBRWxDLGdCQUFnQjtrQkFMNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsbUJBQW1CLEVBQUUsY0FBYyxDQUFDO29CQUM1RCxZQUFZLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztvQkFDbkMsT0FBTyxFQUFFLENBQUMsbUJBQW1CLEVBQUUsY0FBYyxDQUFDO2lCQUMvQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQnJhbmRpbmdNb2R1bGUgfSBmcm9tICcuLi9icmFuZGluZyc7XG5pbXBvcnQgeyBTaXplRGV0ZWN0aW9uTW9kdWxlIH0gZnJvbSAnLi4vc2l6ZS1kZXRlY3Rpb24nO1xuaW1wb3J0IHsgU2Nyb2xsYWJsZUNvbXBvbmVudCB9IGZyb20gJy4vc2Nyb2xsYWJsZS5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBTaXplRGV0ZWN0aW9uTW9kdWxlLCBCcmFuZGluZ01vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogW1Njcm9sbGFibGVDb21wb25lbnRdLFxuICBleHBvcnRzOiBbU2Nyb2xsYWJsZUNvbXBvbmVudCwgQnJhbmRpbmdNb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIFNjcm9sbGFibGVNb2R1bGUge1xuICBjb25zdHJ1Y3RvcigpIHt9XG59XG4iXX0=

package/esm2020/lib/select-icon/index.mjs

@@ -0,0 +1,3 @@
+export * from './select-icon.component';
+export * from './select-icon.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tY29tcG9uZW50cy9zcmMvbGliL3NlbGVjdC1pY29uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LWljb24uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VsZWN0LWljb24ubW9kdWxlJztcbiJdfQ==

package/esm2020/lib/select-icon/select-icon.component.mjs

@@ -0,0 +1,307 @@
+/* eslint-disable @angular-eslint/no-conflicting-lifecycle */
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Inject, Input, Optional, Output, Self, ViewChild } from '@angular/core';
+import { FormControl, Validators } from '@angular/forms';
+import { nanoid } from 'nanoid';
+import { BehaviorSubject, combineLatest, debounceTime, distinctUntilChanged, map, startWith, Subject } from 'rxjs';
+import { FontAwesomeIcons } from '../../constants';
+import { coerceBooleanPropertyValue } from '../../utilities';
+import { ImpdcFormFieldControl, IMPDC_FORM_ROOT, mixinDisabled, mixinErrorState, mixinTabIndex } from '../form-field';
+import * as i0 from "@angular/core";
+import * as i1 from "../form-field";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+import * as i5 from "../form-field/form-field.component";
+import * as i6 from "../form-field/controls/input/input.directive";
+import * as i7 from "../form-field/directives/prefix.directive";
+export class ImpdcSelectIconChange {
+    constructor(source, value) {
+        this.source = source;
+        this.value = value;
+    }
+}
+const _SelectIconComponentBase = mixinTabIndex(mixinDisabled(mixinErrorState(class {
+    constructor(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._formRoot = _formRoot;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this.ngControl = ngControl;
+        this.stateChanges = new Subject();
+    }
+})));
+/**
+ * The `SelectIconComponent` (`<impdc-select-icon`) is a select dropdown with search that shows all standard icons from Bootstrap 5.
+ * To use, import `SelectIconModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export class SelectIconComponent extends _SelectIconComponentBase {
+    constructor(_changeDetector, _defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        super(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl);
+        this._changeDetector = _changeDetector;
+        this.searchControl = new FormControl('');
+        this._uid = `impdc-select-icon-${nanoid()}`;
+        this._dropdownOpen = false;
+        this._iconOptionsSubject = new BehaviorSubject(FontAwesomeIcons);
+        this._cvaOnChange = () => { };
+        this._cvaOnTouched = () => { };
+        this._placeholder = '- Select -';
+        /** Events fire when selection has been changed by the user. */
+        this.selectionChange = new EventEmitter();
+        /**
+         * Events fire when raw value of select changes. Mainly exists to handle
+         * two-way binding of `value` input property.
+         * @ignore
+         */
+        this.valueChange = new EventEmitter();
+        this._value = null;
+        this._focused = false;
+        this.controlType = 'impdc-select-icon';
+        this.supportsAffixes = true;
+        this.allowSearch = false;
+        this.showText = true;
+        this.showSelectedText = true;
+        const debouncedSearchValues = this.searchControl.valueChanges.pipe(startWith(''), debounceTime(200), distinctUntilChanged());
+        this.filteredOptions$ = combineLatest([
+            debouncedSearchValues,
+            this._iconOptionsSubject.asObservable()
+        ]).pipe(map(([searchTerm, iconOptions]) => {
+            if (!searchTerm) {
+                return [...iconOptions];
+            }
+            const searchTermLowerCase = searchTerm.toLowerCase();
+            return iconOptions.filter(option => option.toLowerCase().indexOf(searchTermLowerCase) > -1);
+        }));
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        this.id = this.id;
+    }
+    get iconOptions() {
+        return [...this._iconOptionsSubject.value];
+    }
+    /**
+     * Set to override the default set of FontAwesome icon options.
+     */
+    set iconOptions(iconOptions) {
+        if (iconOptions) {
+            this._iconOptionsSubject.next([...iconOptions]);
+        }
+    }
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default \- Select -
+     */
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    get empty() {
+        return !this.value;
+    }
+    /** @ignore */
+    focus(options) {
+        this._toggleButtonRef.nativeElement.focus(options);
+    }
+    /* Lifecycle Hooks */
+    /** @ignore */
+    ngDoCheck() {
+        const ngControl = this.ngControl;
+        if (!ngControl) {
+            return;
+        }
+        if (this._previousControl !== ngControl.control) {
+            if (this._previousControl !== undefined &&
+                ngControl.disabled !== null &&
+                ngControl.disabled !== this.disabled) {
+                this.disabled = ngControl?.disabled;
+            }
+            this._previousControl = ngControl.control;
+        }
+        this.updateErrorState();
+    }
+    /** @ignore */
+    ngOnChanges(changes) {
+        // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal
+        // to the parent form field so it can run change detection when disabled state is changed.
+        if (changes['disabled']) {
+            this.stateChanges.next();
+        }
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    /* ControlValueAccessor */
+    /** @ignore */
+    writeValue(value) {
+        this.value = value;
+        this._changeDetector.markForCheck();
+    }
+    /** @ignore */
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this._cvaOnTouched = fn;
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetector.markForCheck();
+    }
+    /* ImpdcFormFieldControl */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        const newValue = (value && this.iconOptions.find(opt => opt === value)) || null;
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.stateChanges.next();
+        }
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this._uid;
+        this.stateChanges.next();
+    }
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required() {
+        return (this._required ??
+            this.ngControl?.control?.hasValidator(Validators.required) ??
+            false);
+    }
+    set required(value) {
+        this._required = coerceBooleanPropertyValue(value);
+        this.stateChanges.next();
+    }
+    get focused() {
+        return this._focused || this._dropdownOpen;
+    }
+    /* Internals */
+    handleOpenChange(isOpen) {
+        this._dropdownOpen = isOpen;
+        this.searchControl.reset();
+        if (isOpen) {
+            this._onFocus();
+        }
+        else {
+            this._onBlur();
+        }
+        this.stateChanges.next();
+    }
+    selectIcon(iconName) {
+        if (iconName !== this.value) {
+            this.value = iconName;
+            this.valueChange.emit(this.value);
+            this._cvaOnChange(this.value);
+            this.selectionChange.emit(this._buildChangeEvent(this.value));
+            this._changeDetector.markForCheck();
+        }
+        if (this._dropdownOpen) {
+            this.focus();
+        }
+    }
+    _onFocus() {
+        if (!this.disabled) {
+            this._focused = true;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Calls the CVA touched callback only if the dropdown is closed.
+     */
+    _onBlur() {
+        this._focused = false;
+        if (!this.disabled && !this._dropdownOpen) {
+            this._cvaOnTouched();
+            this._changeDetector.markForCheck();
+            this.stateChanges.next();
+        }
+    }
+    _buildChangeEvent(value) {
+        return new ImpdcSelectIconChange(this, value);
+    }
+}
+SelectIconComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectIconComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ErrorStateMatcher }, { token: IMPDC_FORM_ROOT, optional: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+SelectIconComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: SelectIconComponent, selector: "impdc-select-icon", inputs: { disabled: "disabled", tabIndex: "tabIndex", allowSearch: "allowSearch", iconOptions: "iconOptions", showText: "showText", showSelectedText: "showSelectedText", placeholder: "placeholder", errorStateMatcher: "errorStateMatcher", value: "value", id: "id", required: "required" }, outputs: { selectionChange: "selectionChange", valueChange: "valueChange" }, host: { listeners: { "focus": "_onFocus(); focus()" }, properties: { "attr.id": "id", "attr.tabindex": "tabIndex", "attr.aria-required": "required.toString()", "attr.aria-disabled": "disabled.toString()", "attr.aria-invalid": "errorState", "class.form-select": "true", "class.is-invalid": "errorState", "class.impdc-form-field-control": "true", "class.impdc-select-icon--required": "required", "class.impdc-select-icon--disabled": "disabled", "class.impdc-select-icon--invalid": "errorState", "class.impdc-select-icon--empty": "empty" }, classAttribute: "impdc-select-icon" }, providers: [
+        {
+            provide: ImpdcFormFieldControl,
+            useExisting: SelectIconComponent
+        }
+    ], viewQueries: [{ propertyName: "_toggleButtonRef", first: true, predicate: ["toggleButton"], descendants: true, read: ElementRef, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div\n  ngbDropdown\n  autoClose=\"outside\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select-icon--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select-icon--text impdc-select-icon--placeholder\"\n        *ngSwitchCase=\"true\">\n        {{ placeholder }}\n      </span>\n      <div\n        class=\"impdc-select-icon--text impdc-select-icon--value-text\"\n        *ngSwitchCase=\"false\">\n        <i class=\"fas fa-{{ value }}\"></i>\n        <span *ngIf=\"showSelectedText\" class=\"ms-2\">{{ value }}</span>\n      </div>\n    </ng-container>\n  </button>\n  <div ngbDropdownMenu class=\"select-icon-dropdown-menu\" tabindex=\"-1\">\n    <div *ngIf=\"allowSearch\" class=\"select-icon-search\">\n      <impdc-form-field>\n        <span impdcTextPrefix><i class=\"fas fa-search\"></i></span>\n        <input\n          impdcInput\n          [formControl]=\"searchControl\"\n          class=\"select-icon-search-input\"\n          type=\"search\" />\n      </impdc-form-field>\n    </div>\n    <div class=\"select-icon-grid\">\n      <button\n        *ngFor=\"let iconName of filteredOptions$ | async\"\n        type=\"button\"\n        (click)=\"selectIcon(iconName)\"\n        class=\"icon-option\"\n        [class.selected]=\"value === iconName\"\n        [title]=\"iconName\"\n        [attr.aria-labelledby]=\"showText ? id + '_' + iconName : null\">\n        <div class=\"icon-container\">\n          <i class=\"fs-2xl fas fa-{{ iconName }}\"></i>\n        </div>\n        <div\n          id=\"{{ id }}_{{ iconName }}\"\n          class=\"icon-label\"\n          [class.sr-only]=\"!showText\">\n          {{ iconName }}\n        </div>\n      </button>\n    </div>\n  </div>\n</div>\n", styles: [":host{padding:0!important;position:relative}:host.impdc-select-icon--disabled{background-color:var(--impd-color-gray-100)}.impdc-select-icon--toggle{font-weight:inherit;padding-right:3.6rem;-webkit-user-select:none;user-select:none;width:100%}:host-context(.is-invalid) .impdc-select-icon--toggle{padding-right:6.6rem}.impdc-select-icon--text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:100%}.select-icon-dropdown-menu{background-color:var(--impd-color-white);color:var(--impd-color-gray-600);max-width:51.2rem;min-width:32rem;overflow:hidden;width:100%}.select-icon-search{margin:var(--impd-size-2);font-size:var(--impd-font-size-sm)}.select-icon-grid{display:grid;align-items:start;grid-template-columns:repeat(auto-fit,minmax(4.8rem,1fr));gap:var(--impd-size-4);width:100%;max-height:var(--impd-size-40);overflow-y:auto;overflow-x:hidden;padding:var(--impd-size-4);-webkit-user-select:none;user-select:none}button[ngbDropdownToggle].dropdown-toggle:after{display:none}.icon-option{padding:0;background:unset;border:none}.icon-option:focus{outline:0}.icon-container{height:4rem;width:4rem;margin-left:auto;margin-right:auto;display:flex;align-items:center;justify-content:center;border-radius:50%;justify-items:center}.selected>.icon-container,:hover>.icon-container,:focus>.icon-container{background-color:var(--impartner-hex-primary);color:var(--impartner-hex-white)}.icon-label{text-align:center;font-size:1rem}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i3.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i4.NgbDropdown, selector: "[ngbDropdown]", inputs: ["autoClose", "dropdownClass", "open", "placement", "popperOptions", "container", "display"], outputs: ["openChange"], exportAs: ["ngbDropdown"] }, { kind: "directive", type: i4.NgbDropdownToggle, selector: "[ngbDropdownToggle]" }, { kind: "directive", type: i4.NgbDropdownMenu, selector: "[ngbDropdownMenu]" }, { kind: "component", type: i5.FormFieldComponent, selector: "impdc-form-field", exportAs: ["impdcFormField"] }, { kind: "directive", type: i6.InputDirective, selector: "input[impdcInput], textarea[impdcInput], select[impdcNativeSelect]", inputs: ["disabled", "id", "type", "required", "readonly", "errorStateMatcher", "value"], exportAs: ["impdcInput"] }, { kind: "directive", type: i7.PrefixDirective, selector: "[impdcPrefix], [impdcTextPrefix]", inputs: ["impdcTextPrefix"] }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: SelectIconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'impdc-select-icon', inputs: ['disabled', 'tabIndex'], changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'impdc-select-icon',
+                        '[attr.id]': 'id',
+                        '[attr.tabindex]': 'tabIndex',
+                        '[attr.aria-required]': 'required.toString()',
+                        '[attr.aria-disabled]': 'disabled.toString()',
+                        '[attr.aria-invalid]': 'errorState',
+                        '[class.form-select]': 'true',
+                        '[class.is-invalid]': 'errorState',
+                        '[class.impdc-form-field-control]': 'true',
+                        '[class.impdc-select-icon--required]': 'required',
+                        '[class.impdc-select-icon--disabled]': 'disabled',
+                        '[class.impdc-select-icon--invalid]': 'errorState',
+                        '[class.impdc-select-icon--empty]': 'empty',
+                        '(focus)': '_onFocus(); focus()'
+                    }, providers: [
+                        {
+                            provide: ImpdcFormFieldControl,
+                            useExisting: SelectIconComponent
+                        }
+                    ], template: "<div\n  ngbDropdown\n  autoClose=\"outside\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select-icon--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select-icon--text impdc-select-icon--placeholder\"\n        *ngSwitchCase=\"true\">\n        {{ placeholder }}\n      </span>\n      <div\n        class=\"impdc-select-icon--text impdc-select-icon--value-text\"\n        *ngSwitchCase=\"false\">\n        <i class=\"fas fa-{{ value }}\"></i>\n        <span *ngIf=\"showSelectedText\" class=\"ms-2\">{{ value }}</span>\n      </div>\n    </ng-container>\n  </button>\n  <div ngbDropdownMenu class=\"select-icon-dropdown-menu\" tabindex=\"-1\">\n    <div *ngIf=\"allowSearch\" class=\"select-icon-search\">\n      <impdc-form-field>\n        <span impdcTextPrefix><i class=\"fas fa-search\"></i></span>\n        <input\n          impdcInput\n          [formControl]=\"searchControl\"\n          class=\"select-icon-search-input\"\n          type=\"search\" />\n      </impdc-form-field>\n    </div>\n    <div class=\"select-icon-grid\">\n      <button\n        *ngFor=\"let iconName of filteredOptions$ | async\"\n        type=\"button\"\n        (click)=\"selectIcon(iconName)\"\n        class=\"icon-option\"\n        [class.selected]=\"value === iconName\"\n        [title]=\"iconName\"\n        [attr.aria-labelledby]=\"showText ? id + '_' + iconName : null\">\n        <div class=\"icon-container\">\n          <i class=\"fs-2xl fas fa-{{ iconName }}\"></i>\n        </div>\n        <div\n          id=\"{{ id }}_{{ iconName }}\"\n          class=\"icon-label\"\n          [class.sr-only]=\"!showText\">\n          {{ iconName }}\n        </div>\n      </button>\n    </div>\n  </div>\n</div>\n", styles: [":host{padding:0!important;position:relative}:host.impdc-select-icon--disabled{background-color:var(--impd-color-gray-100)}.impdc-select-icon--toggle{font-weight:inherit;padding-right:3.6rem;-webkit-user-select:none;user-select:none;width:100%}:host-context(.is-invalid) .impdc-select-icon--toggle{padding-right:6.6rem}.impdc-select-icon--text{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:100%}.select-icon-dropdown-menu{background-color:var(--impd-color-white);color:var(--impd-color-gray-600);max-width:51.2rem;min-width:32rem;overflow:hidden;width:100%}.select-icon-search{margin:var(--impd-size-2);font-size:var(--impd-font-size-sm)}.select-icon-grid{display:grid;align-items:start;grid-template-columns:repeat(auto-fit,minmax(4.8rem,1fr));gap:var(--impd-size-4);width:100%;max-height:var(--impd-size-40);overflow-y:auto;overflow-x:hidden;padding:var(--impd-size-4);-webkit-user-select:none;user-select:none}button[ngbDropdownToggle].dropdown-toggle:after{display:none}.icon-option{padding:0;background:unset;border:none}.icon-option:focus{outline:0}.icon-container{height:4rem;width:4rem;margin-left:auto;margin-right:auto;display:flex;align-items:center;justify-content:center;border-radius:50%;justify-items:center}.selected>.icon-container,:hover>.icon-container,:focus>.icon-container{background-color:var(--impartner-hex-primary);color:var(--impartner-hex-white)}.icon-label{text-align:center;font-size:1rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IMPDC_FORM_ROOT]
+                }] }, { type: i2.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i2.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { _toggleButtonRef: [{
+                type: ViewChild,
+                args: ['toggleButton', { static: true, read: ElementRef }]
+            }], allowSearch: [{
+                type: Input
+            }], iconOptions: [{
+                type: Input
+            }], showText: [{
+                type: Input
+            }], showSelectedText: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-icon.component.js","sourceRoot":"","sources":["../../../../../../projects/design-components/src/lib/select-icon/select-icon.component.ts","../../../../../../projects/design-components/src/lib/select-icon/select-icon.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-conflicting-lifecycle */\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  Self,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormControl,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  Validators\n} from '@angular/forms';\nimport { nanoid } from 'nanoid';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  debounceTime,\n  distinctUntilChanged,\n  map,\n  Observable,\n  startWith,\n  Subject\n} from 'rxjs';\nimport { FontAwesomeIcons } from '../../constants';\nimport { BooleanInput, coerceBooleanPropertyValue } from '../../utilities';\nimport {\n  ErrorStateMatcher,\n  ICanUpdateErrorState,\n  IHasErrorState,\n  ImpdcFormFieldControl,\n  ImpdcFormRoot,\n  IMPDC_FORM_ROOT,\n  mixinDisabled,\n  mixinErrorState,\n  mixinTabIndex\n} from '../form-field';\n\nexport class ImpdcSelectIconChange {\n  constructor(public source: SelectIconComponent, public value: any) {}\n}\n\nconst _SelectIconComponentBase = mixinTabIndex(\n  mixinDisabled(\n    mixinErrorState(\n      class {\n        public readonly stateChanges = new Subject<void>();\n\n        constructor(\n          public _defaultErrorStateMatcher: ErrorStateMatcher,\n          public _formRoot: ImpdcFormRoot,\n          public _parentForm: NgForm,\n          public _parentFormGroup: FormGroupDirective,\n          public ngControl: NgControl | null\n        ) {}\n      }\n    )\n  )\n);\n\n/**\n * The `SelectIconComponent` (`<impdc-select-icon`) is a select dropdown with search that shows all standard icons from Bootstrap 5.\n * To use, import `SelectIconModule` or another module that imports and exports that module from `@impartner/design-components`.\n */\n@Component({\n  selector: 'impdc-select-icon',\n  templateUrl: './select-icon.component.html',\n  styleUrls: ['./select-icon.component.scss'],\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['disabled', 'tabIndex'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    class: 'impdc-select-icon',\n    '[attr.id]': 'id',\n    '[attr.tabindex]': 'tabIndex',\n    '[attr.aria-required]': 'required.toString()',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.aria-invalid]': 'errorState',\n    '[class.form-select]': 'true',\n    '[class.is-invalid]': 'errorState',\n    '[class.impdc-form-field-control]': 'true',\n    '[class.impdc-select-icon--required]': 'required',\n    '[class.impdc-select-icon--disabled]': 'disabled',\n    '[class.impdc-select-icon--invalid]': 'errorState',\n    '[class.impdc-select-icon--empty]': 'empty',\n    '(focus)': '_onFocus(); focus()'\n  },\n  providers: [\n    {\n      provide: ImpdcFormFieldControl,\n      useExisting: SelectIconComponent\n    }\n  ]\n})\nexport class SelectIconComponent\n  extends _SelectIconComponentBase\n  implements\n    ControlValueAccessor,\n    ImpdcFormFieldControl<string | null>,\n    ICanUpdateErrorState,\n    IHasErrorState,\n    DoCheck,\n    OnChanges,\n    OnDestroy\n{\n  @ViewChild('toggleButton', { static: true, read: ElementRef })\n  protected _toggleButtonRef!: ElementRef<HTMLButtonElement>;\n\n  protected readonly filteredOptions$: Observable<string[]>;\n  protected readonly searchControl = new FormControl<string>('');\n  protected readonly _uid = `impdc-select-icon-${nanoid()}`;\n  protected _dropdownOpen = false;\n\n  private readonly _iconOptionsSubject = new BehaviorSubject<readonly string[]>(\n    FontAwesomeIcons\n  );\n  private _previousControl?: AbstractControl | null;\n  private _cvaOnChange: (value: any) => void = () => {};\n  private _cvaOnTouched = () => {};\n\n  /**\n   * Set whether or not an input field will appear for searching and\n   * filtering icon options.\n   * @default true\n   */\n  @Input()\n  public allowSearch: boolean;\n\n  public get iconOptions(): string[] {\n    return [...this._iconOptionsSubject.value];\n  }\n\n  /**\n   * Set to override the default set of FontAwesome icon options.\n   */\n  @Input()\n  public set iconOptions(iconOptions: string[]) {\n    if (iconOptions) {\n      this._iconOptionsSubject.next([...iconOptions]);\n    }\n  }\n\n  /**\n   * Set whether or not to show the icon names as labels for icon options.\n   * @default true\n   */\n  @Input()\n  public showText: boolean;\n\n  /**\n   * Set whether or not to show the name of the selected icon inside the control.\n   * @default true\n   */\n  @Input()\n  public showSelectedText: boolean;\n\n  /**\n   * The placeholder text that will be displayed when no selection has been made.\n   *\n   * @default \\- Select -\n   */\n  @Input()\n  public get placeholder(): string {\n    return this._placeholder;\n  }\n  public set placeholder(value: string) {\n    this._placeholder = value;\n    this.stateChanges.next();\n  }\n  private _placeholder: string = '- Select -';\n\n  @Input()\n  public override errorStateMatcher!: ErrorStateMatcher;\n\n  /** Events fire when selection has been changed by the user. */\n  @Output()\n  public readonly selectionChange: EventEmitter<ImpdcSelectIconChange> = new EventEmitter<ImpdcSelectIconChange>();\n\n  /**\n   * Events fire when raw value of select changes. Mainly exists to handle\n   * two-way binding of `value` input property.\n   * @ignore\n   */\n  @Output()\n  public readonly valueChange = new EventEmitter<string | null>();\n\n  constructor(\n    private readonly _changeDetector: ChangeDetectorRef,\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n    @Optional() @Inject(IMPDC_FORM_ROOT) _formRoot: ImpdcFormRoot,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    @Self() @Optional() ngControl: NgControl\n  ) {\n    super(\n      _defaultErrorStateMatcher,\n      _formRoot,\n      _parentForm,\n      _parentFormGroup,\n      ngControl\n    );\n\n    this.allowSearch = false;\n    this.showText = true;\n    this.showSelectedText = true;\n\n    const debouncedSearchValues = this.searchControl.valueChanges.pipe(\n      startWith(''),\n      debounceTime(200),\n      distinctUntilChanged()\n    );\n    this.filteredOptions$ = combineLatest([\n      debouncedSearchValues,\n      this._iconOptionsSubject.asObservable()\n    ]).pipe(\n      map(([searchTerm, iconOptions]) => {\n        if (!searchTerm) {\n          return [...iconOptions];\n        }\n\n        const searchTermLowerCase = searchTerm.toLowerCase();\n        return iconOptions.filter(\n          option => option.toLowerCase().indexOf(searchTermLowerCase) > -1\n        );\n      })\n    );\n\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n\n    this.id = this.id;\n  }\n\n  public get empty(): boolean {\n    return !this.value;\n  }\n\n  /** @ignore */\n  public focus(options?: FocusOptions): void {\n    this._toggleButtonRef.nativeElement.focus(options);\n  }\n\n  /* Lifecycle Hooks */\n\n  /** @ignore */\n  public ngDoCheck(): void {\n    const ngControl = this.ngControl;\n\n    if (!ngControl) {\n      return;\n    }\n\n    if (this._previousControl !== ngControl.control) {\n      if (\n        this._previousControl !== undefined &&\n        ngControl.disabled !== null &&\n        ngControl.disabled !== this.disabled\n      ) {\n        this.disabled = ngControl?.disabled;\n      }\n\n      this._previousControl = ngControl.control;\n    }\n\n    this.updateErrorState();\n  }\n\n  /** @ignore */\n  public ngOnChanges(changes: SimpleChanges): void {\n    // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal\n    // to the parent form field so it can run change detection when disabled state is changed.\n    if (changes['disabled']) {\n      this.stateChanges.next();\n    }\n  }\n\n  /** @ignore */\n  public ngOnDestroy(): void {\n    this.stateChanges.complete();\n  }\n\n  /* ControlValueAccessor */\n\n  /** @ignore */\n  public writeValue(value: string): void {\n    this.value = value;\n    this._changeDetector.markForCheck();\n  }\n\n  /** @ignore */\n  public registerOnChange(fn: (value: any) => void): void {\n    this._cvaOnChange = fn;\n  }\n\n  /** @ignore */\n  public registerOnTouched(fn: () => {}): void {\n    this._cvaOnTouched = fn;\n  }\n\n  /** @ignore */\n  public setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this._changeDetector.markForCheck();\n  }\n\n  /* ImpdcFormFieldControl */\n\n  @Input()\n  public get value(): string | null {\n    return this._value;\n  }\n  public set value(value: string | null) {\n    const newValue =\n      (value && this.iconOptions.find(opt => opt === value)) || null;\n\n    if (newValue !== this._value) {\n      this._value = newValue;\n      this.stateChanges.next();\n    }\n  }\n  private _value: string | null = null;\n\n  @Input()\n  public get id(): string {\n    return this._id;\n  }\n  public set id(value: string) {\n    this._id = value || this._uid;\n    this.stateChanges.next();\n  }\n  protected _id!: string;\n\n  /**\n   * Used to set requiredness of control in a template-based manner;\n   * not necessary when using the Angular reactive forms API and `required` validator.\n   *\n   * @default false\n   */\n  @Input()\n  public get required(): boolean {\n    return (\n      this._required ??\n      this.ngControl?.control?.hasValidator(Validators.required) ??\n      false\n    );\n  }\n  public set required(value: BooleanInput) {\n    this._required = coerceBooleanPropertyValue(value);\n    this.stateChanges.next();\n  }\n  private _required: boolean | undefined;\n\n  public get focused(): boolean {\n    return this._focused || this._dropdownOpen;\n  }\n  protected _focused = false;\n\n  public readonly controlType: string = 'impdc-select-icon';\n  public readonly supportsAffixes: boolean = true;\n\n  /* Internals */\n\n  protected handleOpenChange(isOpen: boolean): void {\n    this._dropdownOpen = isOpen;\n    this.searchControl.reset();\n\n    if (isOpen) {\n      this._onFocus();\n    } else {\n      this._onBlur();\n    }\n\n    this.stateChanges.next();\n  }\n\n  protected selectIcon(iconName: string): void {\n    if (iconName !== this.value) {\n      this.value = iconName;\n      this.valueChange.emit(this.value);\n      this._cvaOnChange(this.value);\n      this.selectionChange.emit(this._buildChangeEvent(this.value));\n      this._changeDetector.markForCheck();\n    }\n\n    if (this._dropdownOpen) {\n      this.focus();\n    }\n  }\n\n  protected _onFocus(): void {\n    if (!this.disabled) {\n      this._focused = true;\n      this.stateChanges.next();\n    }\n  }\n\n  /**\n   * Calls the CVA touched callback only if the dropdown is closed.\n   */\n  protected _onBlur(): void {\n    this._focused = false;\n\n    if (!this.disabled && !this._dropdownOpen) {\n      this._cvaOnTouched();\n      this._changeDetector.markForCheck();\n      this.stateChanges.next();\n    }\n  }\n\n  private _buildChangeEvent(value: string | null): ImpdcSelectIconChange {\n    return new ImpdcSelectIconChange(this, value);\n  }\n}\n","<div\n  ngbDropdown\n  autoClose=\"outside\"\n  container=\"body\"\n  dropdownClass=\"impartner-hex\"\n  (openChange)=\"handleOpenChange($event)\"\n  class=\"w-100\">\n  <button\n    #toggleButton\n    class=\"impdc-select-icon--toggle btn border-0 text-start\"\n    type=\"button\"\n    role=\"combobox\"\n    [disabled]=\"disabled\"\n    ngbDropdownToggle>\n    <ng-container [ngSwitch]=\"empty\">\n      <span\n        class=\"impdc-select-icon--text impdc-select-icon--placeholder\"\n        *ngSwitchCase=\"true\">\n        {{ placeholder }}\n      </span>\n      <div\n        class=\"impdc-select-icon--text impdc-select-icon--value-text\"\n        *ngSwitchCase=\"false\">\n        <i class=\"fas fa-{{ value }}\"></i>\n        <span *ngIf=\"showSelectedText\" class=\"ms-2\">{{ value }}</span>\n      </div>\n    </ng-container>\n  </button>\n  <div ngbDropdownMenu class=\"select-icon-dropdown-menu\" tabindex=\"-1\">\n    <div *ngIf=\"allowSearch\" class=\"select-icon-search\">\n      <impdc-form-field>\n        <span impdcTextPrefix><i class=\"fas fa-search\"></i></span>\n        <input\n          impdcInput\n          [formControl]=\"searchControl\"\n          class=\"select-icon-search-input\"\n          type=\"search\" />\n      </impdc-form-field>\n    </div>\n    <div class=\"select-icon-grid\">\n      <button\n        *ngFor=\"let iconName of filteredOptions$ | async\"\n        type=\"button\"\n        (click)=\"selectIcon(iconName)\"\n        class=\"icon-option\"\n        [class.selected]=\"value === iconName\"\n        [title]=\"iconName\"\n        [attr.aria-labelledby]=\"showText ? id + '_' + iconName : null\">\n        <div class=\"icon-container\">\n          <i class=\"fs-2xl fas fa-{{ iconName }}\"></i>\n        </div>\n        <div\n          id=\"{{ id }}_{{ iconName }}\"\n          class=\"icon-label\"\n          [class.sr-only]=\"!showText\">\n          {{ iconName }}\n        </div>\n      </button>\n    </div>\n  </div>\n</div>\n"]}