@flywheel-io/vision 2.0.0-beta-4 → 2.0.0-beta.10

package/esm2022/components/select-menu/select-menu.component.mjs

@@ -0,0 +1,332 @@
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { CdkMenuTrigger } from '@angular/cdk/menu';
+import { Component, ContentChildren, EventEmitter, HostListener, Input, Optional, Output, Self, ViewChild, } from '@angular/core';
+import { FwMenuComponent } from '../menu/menu.component';
+import { FwMenuItemComponent } from '../menu/menu-item/menu-item.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/menu";
+import * as i4 from "../menu/menu.component";
+import * as i5 from "../menu/menu-container/menu-container.component";
+import * as i6 from "../menu/menu-item/menu-item.component";
+import * as i7 from "../text-input/text-input.component";
+import * as i8 from "../../directives/menu-register.directive";
+export class FwSelectMenuComponent {
+    outsideClick(evt) {
+        if (this._isOpen && evt.nodeName !== 'INPUT') {
+            this.onTouched();
+            this.close();
+            this._isOpen = false;
+        }
+        if (this.trigger && this.trigger.isOpen()) {
+            this._isOpen = true;
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    set value(newValue) {
+        this.updateValue(newValue);
+    }
+    constructor(_changeDetectorRef, ngControl) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this.ngControl = ngControl;
+        // bind it for the template
+        this.JSON = JSON;
+        this.options = [];
+        this.valueProperty = 'value';
+        this.useFullOptionAsValue = false;
+        this.titleProperty = 'title';
+        this.iconProperty = 'icon';
+        this.descriptionProperty = 'description';
+        this.showFilter = false;
+        this.showReset = false;
+        this.disabled = false;
+        this.errored = false;
+        this.width = '200px';
+        this.size = 'medium';
+        this.placeholder = 'Select something...';
+        // eslint-disable-next-line @angular-eslint/no-output-native
+        this.change = new EventEmitter();
+        this.filterChanged = new EventEmitter();
+        this.selectValue = '';
+        this.selectTitle = '';
+        this.selectIcon = '';
+        this.filterValue = '';
+        this.subscriptions = [];
+        this._isOpen = false;
+        this.focused = 0;
+        this.inFocusOpen = false;
+        this.onTouched = () => {
+        };
+        // this is just a different way of binding the controlValueAccessor
+        // it can be accessed in the component this way
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    ngOnChanges(changes) {
+        const currentOptions = changes.options?.currentValue;
+        // if the options change check if the title we should be displaying has changed
+        if (currentOptions && currentOptions !== changes.options?.previousValue) {
+            const selectedOption = currentOptions.find(item => item['value']?.toString() === this.selectValue);
+            if (selectedOption) {
+                this.selectTitle = selectedOption['title'];
+            }
+        }
+    }
+    ngAfterContentInit() {
+        if (!this.options || (this.options.length === 0 && this.menuItems && this.menuItems.length > 0)) {
+            this.options = [];
+            this.menuItems.forEach(item => {
+                this.options.push({
+                    value: item.value.toString(),
+                    title: item.title.toString(),
+                    icon: item.icon,
+                    description: item.description,
+                });
+                const sub = item.click.subscribe(value => this.menu.writeValue(value));
+                this.subscriptions.push(sub);
+                if (item.value.toString() === this.selectValue) {
+                    this.selectTitle = item.title.toString();
+                    this.selectIcon = item.icon;
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        for (const subscription of this.subscriptions) {
+            subscription.unsubscribe();
+        }
+    }
+    get invalid() {
+        return this.ngControl?.invalid;
+    }
+    get touched() {
+        return this.ngControl?.touched;
+    }
+    onChange(newValue) {
+        this._value = typeof newValue === 'object' ? JSON.stringify(newValue) : newValue;
+        this.change.emit(newValue);
+        this.externalOnChange?.(newValue);
+    }
+    ;
+    registerOnChange(fn) {
+        this.externalOnChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        // eslint-disable-next-line @rx-angular/no-explicit-change-detection-apis
+        this._changeDetectorRef.markForCheck();
+    }
+    writeValue(value) {
+        this.updateValue(value);
+    }
+    handleClick(e) {
+        this.onTouched();
+        if (this.selectValue === e) {
+            this.close();
+            return;
+        }
+        if (this.useFullOptionAsValue) {
+            const parsedValue = JSON.parse(e);
+            this.updateValue(parsedValue);
+        }
+        else {
+            this.updateValue(e);
+        }
+        this.close();
+    }
+    moveFocused(direction) {
+        switch (direction) {
+            case 'down': {
+                this.focused++;
+                if (this.focused >= this.options.length) {
+                    this.focused = 0;
+                }
+                break;
+            }
+            case 'up': {
+                this.focused--;
+                if (this.focused < 0) {
+                    this.focused = this.options.length - 1;
+                }
+                break;
+            }
+            default: {
+                this.focused = 0;
+                break;
+            }
+        }
+    }
+    handleKeyDown(event) {
+        if (this.trigger.isOpen()) {
+            if (this.inFocusOpen) {
+                if (event.key === 'ArrowDown') {
+                    this.moveFocused('down');
+                    this.updateValue(this.options[this.focused]);
+                }
+                if (event.key === 'ArrowUp') {
+                    this.moveFocused('up');
+                    this.updateValue(this.options[this.focused]);
+                }
+                if (event.key === 'Tab') {
+                    this.close();
+                    this.inFocusOpen = false;
+                    this.updateValue(this.preFocusValue);
+                }
+                if (event.key === 'Enter') {
+                    this.close();
+                    this.inFocusOpen = false;
+                    const newValue = this.useFullOptionAsValue ? this.JSON.parse(this.value) : this.value;
+                    this.updateValue(newValue);
+                }
+            }
+            else {
+                this.inFocusOpen = true;
+                this.preFocusValue = this.value;
+            }
+        }
+        else {
+            if (event.key === 'Enter') {
+                this.inFocusOpen = false;
+                this.preFocusValue = this.value;
+            }
+        }
+    }
+    handleKeyUp(event) {
+        if (this.trigger.isOpen()) {
+            if (event.key === 'Escape') {
+                this.close();
+                this.inFocusOpen = false;
+                this.updateValue(this.preFocusValue);
+            }
+        }
+        else {
+            if (this.showReset) {
+                if (event.key === 'Escape') {
+                    this.handleReset();
+                }
+            }
+        }
+    }
+    updateValue(newValue) {
+        // do housekeeping first
+        this.onTouched();
+        // null guard
+        if (!newValue) {
+            this.selectValue = '';
+            this.selectTitle = '';
+            this.selectIcon = '';
+            return this.onChange(newValue);
+        }
+        if (typeof newValue === 'object') {
+            this.selectValue = newValue?.[this.valueProperty]?.toString();
+            this.selectTitle = newValue?.[this.titleProperty]?.toString();
+            this.selectIcon = newValue?.[this.iconProperty];
+            const changeToEmit = this.useFullOptionAsValue ? newValue : newValue[this.valueProperty];
+            return this.onChange(changeToEmit);
+        }
+        // try and find a matching option
+        const matchedOption = this.options.find(option => {
+            const matchesValue = option[this.valueProperty] === newValue;
+            const matchesTitle = option[this.titleProperty] === newValue;
+            return matchesValue || matchesTitle;
+        });
+        if (matchedOption) {
+            this.selectValue = matchedOption[this.valueProperty]?.toString();
+            this.selectTitle = matchedOption[this.titleProperty]?.toString();
+            this.selectIcon = matchedOption[this.iconProperty];
+            const changeToEmit = this.useFullOptionAsValue ? matchedOption : matchedOption[this.valueProperty];
+            return this.onChange(changeToEmit);
+        }
+        else {
+            // fall back to stringify
+            const stringified = newValue.toString() || '';
+            this.selectValue = stringified;
+            this.selectTitle = stringified;
+            return this.onChange(stringified);
+        }
+    }
+    handleReset() {
+        if (this.showReset) {
+            this.updateValue(null);
+        }
+    }
+    close() {
+        this.trigger.close();
+        this.filterValue = '';
+        this.filterChanged.emit(this.filterValue);
+    }
+    onFilterChanged(value) {
+        this.filterValue = value;
+        this.filterChanged.emit(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FwSelectMenuComponent, selector: "fw-select", inputs: { options: "options", valueProperty: "valueProperty", useFullOptionAsValue: "useFullOptionAsValue", titleProperty: "titleProperty", iconProperty: "iconProperty", staticIcon: "staticIcon", descriptionProperty: "descriptionProperty", showFilter: "showFilter", showReset: "showReset", disabled: "disabled", errored: "errored", width: "width", optionsWidth: "optionsWidth", minOptionsHeight: "minOptionsHeight", maxOptionsHeight: "maxOptionsHeight", size: "size", placeholder: "placeholder", value: "value" }, outputs: { change: "change", filterChanged: "filterChanged" }, host: { listeners: { "document:click": "outsideClick($event.target)" } }, queries: [{ propertyName: "menuItems", predicate: FwMenuItemComponent, descendants: true }], viewQueries: [{ propertyName: "trigger", first: true, predicate: CdkMenuTrigger, descendants: true }, { propertyName: "menu", first: true, predicate: FwMenuComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div #wrapper [ngStyle]=\"{width: width, cursor: 'pointer'}\">\n  <fw-text-input\n    fwMenuRegister\n    [cdkMenuTriggerFor]=\"selectMenu\"\n    [value]=\"selectTitle\"\n    [leftIcon]=\"staticIcon || selectIcon\"\n    [rightIcon]=\"(selectTitle&&showReset)?'close-circled':'chevron-down'\"\n    (rightIconAction)=\"handleReset()\"\n    [useActionableIcons]=\"true\"\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled\"\n    [size]=\"size\"\n    [error]=\"errored || (invalid && touched)\"\n    (keyup)=\"handleKeyUp($event)\"\n    (keydown)=\"handleKeyDown($event)\"\n    readOnly=\"true\">\n  </fw-text-input>\n  <ng-template #selectMenu>\n    <fw-menu-container\n      [filterText]=\"filterValue\"\n      *ngIf=\"!disabled\" [showFilter]=\"showFilter\" [width]=\"optionsWidth || wrapper.offsetWidth + 'px'\"\n      [maxHeight]=\"maxOptionsHeight\" [minHeight]=\"minOptionsHeight\" (filterChanged)=\"onFilterChanged($event)\">\n      <fw-menu [disabled]=\"disabled\" [value]=\"selectValue\" (change)=\"handleClick($event)\">\n        <ng-container *ngIf=\"menuItems.length===0\">\n          <fw-menu-item\n            *ngFor=\"let item of options\"\n            [title]=\"item[titleProperty]?.toString()\"\n            [description]=\"item[descriptionProperty]\"\n            [value]=\"useFullOptionAsValue ? JSON.stringify(item) : item?.[valueProperty]?.toString()\"\n            [icon]=\"item[iconProperty]\"\n          >\n          </fw-menu-item>\n        </ng-container>\n        <div #menuContentWrapper>\n          <ng-content select=\"[fw-menu-item, fw-menu-separator, fw-menu-item-group]\"></ng-content>\n        </div>\n      </fw-menu>\n    </fw-menu-container>\n  </ng-template>\n</div>\n", styles: [":host{box-sizing:border-box;max-width:100%}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i3.CdkMenuTrigger, selector: "[cdkMenuTriggerFor]", inputs: ["cdkMenuTriggerFor", "cdkMenuPosition", "cdkMenuTriggerData"], outputs: ["cdkMenuOpened", "cdkMenuClosed"], exportAs: ["cdkMenuTriggerFor"] }, { kind: "component", type: i4.FwMenuComponent, selector: "fw-menu", inputs: ["disabled", "size", "multiSelect", "useCheckbox", "value", "variant", "collapsed", "collapsedWidth", "openWidth"], outputs: ["change", "filteredItemsChange"] }, { kind: "component", type: i5.FwMenuContainerComponent, selector: "fw-menu-container", inputs: ["width", "maxHeight", "minHeight", "border", "shadow", "showFilter", "filterText", "offset", "collapsed"], outputs: ["filterChanged"] }, { kind: "component", type: i6.FwMenuItemComponent, selector: "fw-menu-item", inputs: ["value", "size", "title", "description", "icon", "iconColor", "disabled", "showCheckbox", "checkboxColor", "multiSelect", "hidden", "collapsed", "href", "target", "subItemsOpen", "focused", "selected", "variant"], outputs: ["click"] }, { kind: "component", type: i7.FwTextInputComponent, selector: "fw-text-input", inputs: ["disabled", "useActionableIcons", "leftIcon", "rightIcon", "prefix", "context", "helperText", "errorText", "placeholder", "readOnly", "size", "type", "maxLength", "autofocus", "autocomplete", "error", "value"], outputs: ["leftIconAction", "rightIconAction"] }, { kind: "directive", type: i8.MenuRegisterDirective, selector: "[fwMenuRegister]" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fw-select', template: "<div #wrapper [ngStyle]=\"{width: width, cursor: 'pointer'}\">\n  <fw-text-input\n    fwMenuRegister\n    [cdkMenuTriggerFor]=\"selectMenu\"\n    [value]=\"selectTitle\"\n    [leftIcon]=\"staticIcon || selectIcon\"\n    [rightIcon]=\"(selectTitle&&showReset)?'close-circled':'chevron-down'\"\n    (rightIconAction)=\"handleReset()\"\n    [useActionableIcons]=\"true\"\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled\"\n    [size]=\"size\"\n    [error]=\"errored || (invalid && touched)\"\n    (keyup)=\"handleKeyUp($event)\"\n    (keydown)=\"handleKeyDown($event)\"\n    readOnly=\"true\">\n  </fw-text-input>\n  <ng-template #selectMenu>\n    <fw-menu-container\n      [filterText]=\"filterValue\"\n      *ngIf=\"!disabled\" [showFilter]=\"showFilter\" [width]=\"optionsWidth || wrapper.offsetWidth + 'px'\"\n      [maxHeight]=\"maxOptionsHeight\" [minHeight]=\"minOptionsHeight\" (filterChanged)=\"onFilterChanged($event)\">\n      <fw-menu [disabled]=\"disabled\" [value]=\"selectValue\" (change)=\"handleClick($event)\">\n        <ng-container *ngIf=\"menuItems.length===0\">\n          <fw-menu-item\n            *ngFor=\"let item of options\"\n            [title]=\"item[titleProperty]?.toString()\"\n            [description]=\"item[descriptionProperty]\"\n            [value]=\"useFullOptionAsValue ? JSON.stringify(item) : item?.[valueProperty]?.toString()\"\n            [icon]=\"item[iconProperty]\"\n          >\n          </fw-menu-item>\n        </ng-container>\n        <div #menuContentWrapper>\n          <ng-content select=\"[fw-menu-item, fw-menu-separator, fw-menu-item-group]\"></ng-content>\n        </div>\n      </fw-menu>\n    </fw-menu-container>\n  </ng-template>\n</div>\n", styles: [":host{box-sizing:border-box;max-width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; }, propDecorators: { outsideClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event.target']]
+            }], options: [{
+                type: Input
+            }], valueProperty: [{
+                type: Input
+            }], useFullOptionAsValue: [{
+                type: Input
+            }], titleProperty: [{
+                type: Input
+            }], iconProperty: [{
+                type: Input
+            }], staticIcon: [{
+                type: Input
+            }], descriptionProperty: [{
+                type: Input
+            }], showFilter: [{
+                type: Input
+            }], showReset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], errored: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], optionsWidth: [{
+                type: Input
+            }], minOptionsHeight: [{
+                type: Input
+            }], maxOptionsHeight: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], trigger: [{
+                type: ViewChild,
+                args: [CdkMenuTrigger]
+            }], menu: [{
+                type: ViewChild,
+                args: [FwMenuComponent]
+            }], menuItems: [{
+                type: ContentChildren,
+                args: [FwMenuItemComponent, { descendants: true }]
+            }], change: [{
+                type: Output
+            }], filterChanged: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-menu.component.js","sourceRoot":"","sources":["../../../../../src/components/select-menu/select-menu.component.ts","../../../../../src/components/select-menu/select-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable  @typescript-eslint/no-explicit-any */\nimport { CdkMenuTrigger } from '@angular/cdk/menu';\nimport {\n  AfterContentInit,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  Self,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\nimport { Subscription } from 'rxjs';\n\nimport { IconType } from '../icon/icon.types';\nimport { FwMenuComponent } from '../menu/menu.component';\nimport { FwMenuItemComponent } from '../menu/menu-item/menu-item.component';\n\n@Component({\n  selector: 'fw-select',\n  templateUrl: './select-menu.component.html',\n  styleUrls: ['./select-menu.component.scss'],\n})\nexport class FwSelectMenuComponent implements OnChanges, AfterContentInit, OnDestroy, ControlValueAccessor {\n  @HostListener('document:click', ['$event.target']) outsideClick(evt: any): void {\n    if (this._isOpen && evt.nodeName !== 'INPUT') {\n      this.onTouched();\n      this.close();\n      this._isOpen = false;\n    }\n    if (this.trigger && this.trigger.isOpen()) {\n      this._isOpen = true;\n    }\n  }\n\n  // bind it for the template\n  public JSON = JSON;\n\n  @Input() options: object[] = [];\n  @Input() valueProperty?: string = 'value';\n  @Input() useFullOptionAsValue = false;\n  @Input() titleProperty?: string = 'title';\n  @Input() iconProperty?: string = 'icon';\n  @Input() staticIcon?: IconType;\n  @Input() descriptionProperty?: string = 'description';\n  @Input() showFilter?: boolean = false;\n  @Input() showReset?: boolean = false;\n  @Input() disabled?: boolean = false;\n  @Input() errored?: boolean = false;\n  @Input() width: string = '200px';\n  @Input() optionsWidth?: string;\n  @Input() minOptionsHeight?: string;\n  @Input() maxOptionsHeight?: string;\n  @Input() size?: 'small' | 'medium' | 'large' = 'medium';\n  @Input() placeholder: string = 'Select something...';\n  @ViewChild(CdkMenuTrigger) trigger: CdkMenuTrigger;\n  @ViewChild(FwMenuComponent) menu: FwMenuComponent;\n  @ContentChildren(FwMenuItemComponent, { descendants: true }) menuItems: QueryList<FwMenuItemComponent>;\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  @Output() change = new EventEmitter<any>();\n  @Output() readonly filterChanged = new EventEmitter<string>();\n  selectValue: string = '';\n  selectTitle: string = '';\n  selectIcon: string = '';\n  filterValue: string = '';\n  private subscriptions: Subscription[] = [];\n  private _isOpen = false;\n  focused = 0;\n  inFocusOpen = false;\n  preFocusValue: any;\n\n  @Input()\n  get value(): any {\n    return this._value;\n  }\n\n  set value(newValue: any) {\n    this.updateValue(newValue);\n  }\n\n  private _value: any;\n\n  constructor(\n    protected _changeDetectorRef: ChangeDetectorRef,\n    @Optional() @Self() private ngControl: NgControl,\n  ) {\n    // this is just a different way of binding the controlValueAccessor\n    // it can be accessed in the component this way\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    const currentOptions = changes.options?.currentValue;\n\n    // if the options change check if the title we should be displaying has changed\n    if (currentOptions && currentOptions !== changes.options?.previousValue) {\n      const selectedOption = currentOptions.find(item => item['value']?.toString() === this.selectValue);\n\n      if (selectedOption) {\n        this.selectTitle = selectedOption['title'];\n      }\n    }\n  }\n\n  ngAfterContentInit(): void {\n    if (!this.options || (this.options.length === 0 && this.menuItems && this.menuItems.length > 0)) {\n      this.options = [];\n      this.menuItems.forEach(item => {\n        this.options.push({\n          value: item.value.toString(),\n          title: item.title.toString(),\n          icon: item.icon,\n          description: item.description,\n        });\n        const sub = item.click.subscribe(value => this.menu.writeValue(value));\n        this.subscriptions.push(sub);\n        if (item.value.toString() === this.selectValue) {\n          this.selectTitle = item.title.toString();\n          this.selectIcon = item.icon;\n        }\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    for (const subscription of this.subscriptions) {\n      subscription.unsubscribe();\n    }\n  }\n\n  get invalid(): boolean {\n    return this.ngControl?.invalid;\n  }\n\n  get touched(): boolean {\n    return this.ngControl?.touched;\n  }\n\n  onChange(newValue: any): void {\n    this._value = typeof newValue === 'object' ? JSON.stringify(newValue) : newValue;\n    this.change.emit(newValue);\n    this.externalOnChange?.(newValue);\n  };\n\n  onTouched = (): void => {\n  };\n\n  externalOnChange;\n  registerOnChange(fn: (value: any) => void): void {\n    this.externalOnChange = fn;\n  }\n\n  registerOnTouched(fn: () => {}): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    // eslint-disable-next-line @rx-angular/no-explicit-change-detection-apis\n    this._changeDetectorRef.markForCheck();\n  }\n\n  writeValue(value: any): void {\n    this.updateValue(value);\n  }\n\n  handleClick(e: string): void {\n    this.onTouched();\n\n    if (this.selectValue === e) {\n      this.close();\n      return;\n    }\n\n    if (this.useFullOptionAsValue) {\n      const parsedValue = JSON.parse(e);\n      this.updateValue(parsedValue);\n    } else {\n      this.updateValue(e);\n    }\n\n    this.close();\n  }\n\n  moveFocused(direction: string): void {\n    switch (direction) {\n      case 'down': {\n        this.focused++;\n        if (this.focused >= this.options.length) {\n          this.focused = 0;\n        }\n        break;\n      }\n      case 'up': {\n        this.focused--;\n        if (this.focused < 0) {\n          this.focused = this.options.length - 1;\n        }\n        break;\n      }\n      default: {\n        this.focused = 0;\n        break;\n      }\n    }\n  }\n\n  handleKeyDown(event: KeyboardEvent): void {\n    if (this.trigger.isOpen()) {\n      if (this.inFocusOpen) {\n        if (event.key === 'ArrowDown') {\n          this.moveFocused('down');\n          this.updateValue(this.options[this.focused]);\n        }\n        if (event.key === 'ArrowUp') {\n          this.moveFocused('up');\n          this.updateValue(this.options[this.focused]);\n        }\n        if (event.key === 'Tab') {\n          this.close();\n          this.inFocusOpen = false;\n          this.updateValue(this.preFocusValue);\n        }\n        if (event.key === 'Enter') {\n          this.close();\n          this.inFocusOpen = false;\n          const newValue = this.useFullOptionAsValue ? this.JSON.parse(this.value) : this.value;\n          this.updateValue(newValue);\n        }\n      } else {\n        this.inFocusOpen = true;\n        this.preFocusValue = this.value;\n      }\n    } else {\n      if (event.key === 'Enter') {\n        this.inFocusOpen = false;\n        this.preFocusValue = this.value;\n      }\n    }\n  }\n\n  handleKeyUp(event: KeyboardEvent): void {\n    if (this.trigger.isOpen()) {\n      if (event.key === 'Escape') {\n        this.close();\n        this.inFocusOpen = false;\n        this.updateValue(this.preFocusValue);\n      }\n    } else {\n      if (this.showReset) {\n        if (event.key === 'Escape') {\n          this.handleReset();\n        }\n      }\n    }\n  }\n\n\n  updateValue(newValue: unknown): void {\n\n    // do housekeeping first\n    this.onTouched();\n\n    // null guard\n    if (!newValue) {\n      this.selectValue = '';\n      this.selectTitle = '';\n      this.selectIcon = '';\n      return this.onChange(newValue);\n    }\n\n    if (typeof newValue === 'object') {\n      this.selectValue = newValue?.[this.valueProperty]?.toString();\n      this.selectTitle = newValue?.[this.titleProperty]?.toString();\n      this.selectIcon = newValue?.[this.iconProperty];\n\n      const changeToEmit = this.useFullOptionAsValue ? newValue : newValue[this.valueProperty];\n      return this.onChange(changeToEmit);\n    }\n\n    // try and find a matching option\n    const matchedOption = this.options.find(option => {\n      const matchesValue = option[this.valueProperty] === newValue;\n      const matchesTitle = option[this.titleProperty] === newValue;\n\n      return matchesValue || matchesTitle;\n    });\n\n    if (matchedOption) {\n      this.selectValue = matchedOption[this.valueProperty]?.toString();\n      this.selectTitle = matchedOption[this.titleProperty]?.toString();\n      this.selectIcon = matchedOption[this.iconProperty];\n\n      const changeToEmit = this.useFullOptionAsValue ? matchedOption : matchedOption[this.valueProperty];\n      return this.onChange(changeToEmit);\n    } else {\n      // fall back to stringify\n      const stringified = newValue.toString() || '';\n      this.selectValue = stringified;\n      this.selectTitle = stringified;\n      return this.onChange(stringified);\n    }\n  }\n\n  handleReset(): void {\n    if (this.showReset) {\n      this.updateValue(null);\n    }\n  }\n\n  close(): void {\n    this.trigger.close();\n    this.filterValue = '';\n    this.filterChanged.emit(this.filterValue);\n  }\n\n  onFilterChanged(value: string): void {\n    this.filterValue = value;\n    this.filterChanged.emit(value);\n  }\n}\n","<div #wrapper [ngStyle]=\"{width: width, cursor: 'pointer'}\">\n  <fw-text-input\n    fwMenuRegister\n    [cdkMenuTriggerFor]=\"selectMenu\"\n    [value]=\"selectTitle\"\n    [leftIcon]=\"staticIcon || selectIcon\"\n    [rightIcon]=\"(selectTitle&&showReset)?'close-circled':'chevron-down'\"\n    (rightIconAction)=\"handleReset()\"\n    [useActionableIcons]=\"true\"\n    [placeholder]=\"placeholder\"\n    [disabled]=\"disabled\"\n    [size]=\"size\"\n    [error]=\"errored || (invalid && touched)\"\n    (keyup)=\"handleKeyUp($event)\"\n    (keydown)=\"handleKeyDown($event)\"\n    readOnly=\"true\">\n  </fw-text-input>\n  <ng-template #selectMenu>\n    <fw-menu-container\n      [filterText]=\"filterValue\"\n      *ngIf=\"!disabled\" [showFilter]=\"showFilter\" [width]=\"optionsWidth || wrapper.offsetWidth + 'px'\"\n      [maxHeight]=\"maxOptionsHeight\" [minHeight]=\"minOptionsHeight\" (filterChanged)=\"onFilterChanged($event)\">\n      <fw-menu [disabled]=\"disabled\" [value]=\"selectValue\" (change)=\"handleClick($event)\">\n        <ng-container *ngIf=\"menuItems.length===0\">\n          <fw-menu-item\n            *ngFor=\"let item of options\"\n            [title]=\"item[titleProperty]?.toString()\"\n            [description]=\"item[descriptionProperty]\"\n            [value]=\"useFullOptionAsValue ? JSON.stringify(item) : item?.[valueProperty]?.toString()\"\n            [icon]=\"item[iconProperty]\"\n          >\n          </fw-menu-item>\n        </ng-container>\n        <div #menuContentWrapper>\n          <ng-content select=\"[fw-menu-item, fw-menu-separator, fw-menu-item-group]\"></ng-content>\n        </div>\n      </fw-menu>\n    </fw-menu-container>\n  </ng-template>\n</div>\n"]}

package/esm2022/components/select-menu/select-menu.module.mjs

@@ -0,0 +1,56 @@
+import { CdkMenuModule } from '@angular/cdk/menu';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MenuRegisterDirective } from '../../directives/menu-register.directive';
+import { FwChipModule } from '../chip/chip.module';
+import { FwIconModule } from '../icon/icon.module';
+import { FwMenuModule } from '../menu/menu.module';
+import { FwTextInputModule } from '../text-input/text-input.module';
+import { FwMultiSelectMenuComponent } from './multi-select-menu/multi-select-menu.component';
+import { FwSelectMenuComponent } from './select-menu.component';
+import * as i0 from "@angular/core";
+export class FwSelectMenuModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuModule, declarations: [FwMultiSelectMenuComponent,
+            FwSelectMenuComponent], imports: [CommonModule,
+            CdkMenuModule,
+            FormsModule,
+            FwChipModule,
+            FwIconModule,
+            FwMenuModule,
+            FwTextInputModule,
+            MenuRegisterDirective], exports: [FwMultiSelectMenuComponent,
+            FwSelectMenuComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuModule, imports: [CommonModule,
+            CdkMenuModule,
+            FormsModule,
+            FwChipModule,
+            FwIconModule,
+            FwMenuModule,
+            FwTextInputModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FwSelectMenuModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        CdkMenuModule,
+                        FormsModule,
+                        FwChipModule,
+                        FwIconModule,
+                        FwMenuModule,
+                        FwTextInputModule,
+                        MenuRegisterDirective,
+                    ],
+                    exports: [
+                        FwMultiSelectMenuComponent,
+                        FwSelectMenuComponent,
+                    ],
+                    declarations: [
+                        FwMultiSelectMenuComponent,
+                        FwSelectMenuComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LW1lbnUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvc2VsZWN0LW1lbnUvc2VsZWN0LW1lbnUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDakYsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0saURBQWlELENBQUM7QUFDN0YsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0seUJBQXlCLENBQUM7O0FBc0JoRSxNQUFNLE9BQU8sa0JBQWtCOytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFKM0IsMEJBQTBCO1lBQzFCLHFCQUFxQixhQWZqQixZQUFZO1lBQ1osYUFBYTtZQUNiLFdBQVc7WUFDWCxZQUFZO1lBQ1osWUFBWTtZQUNaLFlBQVk7WUFDWixpQkFBaUI7WUFDakIscUJBQXFCLGFBR3pCLDBCQUEwQjtZQUMxQixxQkFBcUI7Z0hBT1osa0JBQWtCLFlBbEJ2QixZQUFZO1lBQ1osYUFBYTtZQUNiLFdBQVc7WUFDWCxZQUFZO1lBQ1osWUFBWTtZQUNaLFlBQVk7WUFDWixpQkFBaUI7OzRGQVlaLGtCQUFrQjtrQkFwQjlCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFO3dCQUNMLFlBQVk7d0JBQ1osYUFBYTt3QkFDYixXQUFXO3dCQUNYLFlBQVk7d0JBQ1osWUFBWTt3QkFDWixZQUFZO3dCQUNaLGlCQUFpQjt3QkFDakIscUJBQXFCO3FCQUN4QjtvQkFDSCxPQUFPLEVBQUU7d0JBQ1AsMEJBQTBCO3dCQUMxQixxQkFBcUI7cUJBQ3RCO29CQUNELFlBQVksRUFBRTt3QkFDWiwwQkFBMEI7d0JBQzFCLHFCQUFxQjtxQkFDdEI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDZGtNZW51TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL21lbnUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3Jtc01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuaW1wb3J0IHsgTWVudVJlZ2lzdGVyRGlyZWN0aXZlIH0gZnJvbSAnLi4vLi4vZGlyZWN0aXZlcy9tZW51LXJlZ2lzdGVyLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBGd0NoaXBNb2R1bGUgfSBmcm9tICcuLi9jaGlwL2NoaXAubW9kdWxlJztcbmltcG9ydCB7IEZ3SWNvbk1vZHVsZSB9IGZyb20gJy4uL2ljb24vaWNvbi5tb2R1bGUnO1xuaW1wb3J0IHsgRndNZW51TW9kdWxlIH0gZnJvbSAnLi4vbWVudS9tZW51Lm1vZHVsZSc7XG5pbXBvcnQgeyBGd1RleHRJbnB1dE1vZHVsZSB9IGZyb20gJy4uL3RleHQtaW5wdXQvdGV4dC1pbnB1dC5tb2R1bGUnO1xuaW1wb3J0IHsgRndNdWx0aVNlbGVjdE1lbnVDb21wb25lbnQgfSBmcm9tICcuL211bHRpLXNlbGVjdC1tZW51L211bHRpLXNlbGVjdC1tZW51LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBGd1NlbGVjdE1lbnVDb21wb25lbnQgfSBmcm9tICcuL3NlbGVjdC1tZW51LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1xuICAgICAgICBDb21tb25Nb2R1bGUsXG4gICAgICAgIENka01lbnVNb2R1bGUsXG4gICAgICAgIEZvcm1zTW9kdWxlLFxuICAgICAgICBGd0NoaXBNb2R1bGUsXG4gICAgICAgIEZ3SWNvbk1vZHVsZSxcbiAgICAgICAgRndNZW51TW9kdWxlLFxuICAgICAgICBGd1RleHRJbnB1dE1vZHVsZSxcbiAgICAgICAgTWVudVJlZ2lzdGVyRGlyZWN0aXZlLFxuICAgIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBGd011bHRpU2VsZWN0TWVudUNvbXBvbmVudCxcbiAgICBGd1NlbGVjdE1lbnVDb21wb25lbnQsXG4gIF0sXG4gIGRlY2xhcmF0aW9uczogW1xuICAgIEZ3TXVsdGlTZWxlY3RNZW51Q29tcG9uZW50LFxuICAgIEZ3U2VsZWN0TWVudUNvbXBvbmVudCxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgRndTZWxlY3RNZW51TW9kdWxlIHtcbn1cbiJdfQ==

package/esm2022/components/shared/pipes/pipes.module.mjs

@@ -0,0 +1,36 @@
+import { NgModule } from '@angular/core';
+import { MinimalTranslationService, TranslationService } from '../translation.service';
+import { TranslatePipe } from './translate.pipe';
+import { TrustHtmlPipe } from './trusthtml.pipe';
+import * as i0 from "@angular/core";
+const exports = [
+    TranslatePipe,
+    TrustHtmlPipe,
+];
+export class PipesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PipesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PipesModule, declarations: [TranslatePipe,
+            TrustHtmlPipe], exports: [TranslatePipe,
+            TrustHtmlPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PipesModule, providers: [
+            {
+                provide: TranslationService,
+                useClass: MinimalTranslationService,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PipesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: exports,
+                    exports: exports,
+                    providers: [
+                        {
+                            provide: TranslationService,
+                            useClass: MinimalTranslationService,
+                        },
+                    ],
+                }]
+        }] });
+export { TranslationService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlwZXMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvc2hhcmVkL3BpcGVzL3BpcGVzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSx5QkFBeUIsRUFBQyxrQkFBa0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3RGLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNqRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7O0FBRWpELE1BQU0sT0FBTyxHQUFHO0lBQ2QsYUFBYTtJQUNiLGFBQWE7Q0FDZCxDQUFDO0FBWUYsTUFBTSxPQUFPLFdBQVc7K0dBQVgsV0FBVztnSEFBWCxXQUFXLGlCQWR0QixhQUFhO1lBQ2IsYUFBYSxhQURiLGFBQWE7WUFDYixhQUFhO2dIQWFGLFdBQVcsYUFQWDtZQUNUO2dCQUNFLE9BQU8sRUFBRSxrQkFBa0I7Z0JBQzNCLFFBQVEsRUFBRSx5QkFBeUI7YUFDcEM7U0FDRjs7NEZBRVUsV0FBVztrQkFWdkIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsT0FBTztvQkFDckIsT0FBTyxFQUFFLE9BQU87b0JBQ2hCLFNBQVMsRUFBRTt3QkFDVDs0QkFDRSxPQUFPLEVBQUUsa0JBQWtCOzRCQUMzQixRQUFRLEVBQUUseUJBQXlCO3lCQUNwQztxQkFDRjtpQkFDRjs7QUFHRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE1pbmltYWxUcmFuc2xhdGlvblNlcnZpY2UsVHJhbnNsYXRpb25TZXJ2aWNlIH0gZnJvbSAnLi4vdHJhbnNsYXRpb24uc2VydmljZSc7XG5pbXBvcnQgeyBUcmFuc2xhdGVQaXBlIH0gZnJvbSAnLi90cmFuc2xhdGUucGlwZSc7XG5pbXBvcnQgeyBUcnVzdEh0bWxQaXBlIH0gZnJvbSAnLi90cnVzdGh0bWwucGlwZSc7XG5cbmNvbnN0IGV4cG9ydHMgPSBbXG4gIFRyYW5zbGF0ZVBpcGUsXG4gIFRydXN0SHRtbFBpcGUsXG5dO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IGV4cG9ydHMsXG4gIGV4cG9ydHM6IGV4cG9ydHMsXG4gIHByb3ZpZGVyczogW1xuICAgIHtcbiAgICAgIHByb3ZpZGU6IFRyYW5zbGF0aW9uU2VydmljZSxcbiAgICAgIHVzZUNsYXNzOiBNaW5pbWFsVHJhbnNsYXRpb25TZXJ2aWNlLFxuICAgIH0sXG4gIF0sXG59KVxuZXhwb3J0IGNsYXNzIFBpcGVzTW9kdWxlIHt9XG5cbmV4cG9ydCB7IFRyYW5zbGF0aW9uU2VydmljZSB9XG4iXX0=

package/{esm2020 → esm2022}/components/shared/pipes/translate.pipe.mjs

@@ -27,14 +27,14 @@ export class TranslatePipe {
         }
         return this.messages[key] || '';
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TranslatePipe, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TranslationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TranslatePipe, name: "translate", pure: false }); }
 }
-TranslatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TranslatePipe, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TranslationService }], target: i0.ɵɵFactoryTarget.Pipe });
-TranslatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TranslatePipe, name: "translate", pure: false });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TranslatePipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TranslatePipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'translate',
                     pure: false,
                 }]
         }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TranslationService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/components/shared/pipes/trusthtml.pipe.mjs

@@ -8,14 +8,14 @@ export class TrustHtmlPipe {
     transform(html) {
         return this.sanitizer.bypassSecurityTrustHtml(html);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TrustHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TrustHtmlPipe, name: "trusthtml" }); }
 }
-TrustHtmlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TrustHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
-TrustHtmlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TrustHtmlPipe, name: "trusthtml" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TrustHtmlPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TrustHtmlPipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'trusthtml',
                     pure: true,
                 }]
         }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3RodG1sLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zaGFyZWQvcGlwZXMvdHJ1c3RodG1sLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQU9wRCxNQUFNLE9BQU8sYUFBYTtJQUN4QixZQUFxQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUVqRCxTQUFTLENBQUMsSUFBWTtRQUNwQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsdUJBQXVCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdEQsQ0FBQzs7MkdBTFUsYUFBYTt5R0FBYixhQUFhOzRGQUFiLGFBQWE7a0JBSnpCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFdBQVc7b0JBQ2pCLElBQUksRUFBRSxJQUFJO2lCQUNYIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlSHRtbCB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuXG5AUGlwZSh7XG4gIG5hbWU6ICd0cnVzdGh0bWwnLFxuICBwdXJlOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBUcnVzdEh0bWxQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIGNvbnN0cnVjdG9yIChwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7IH1cblxuICB0cmFuc2Zvcm0oaHRtbDogc3RyaW5nKTogU2FmZUh0bWwge1xuICAgIHJldHVybiB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0SHRtbChodG1sKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3RodG1sLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zaGFyZWQvcGlwZXMvdHJ1c3RodG1sLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQU9wRCxNQUFNLE9BQU8sYUFBYTtJQUN4QixZQUFxQixTQUF1QjtRQUF2QixjQUFTLEdBQVQsU0FBUyxDQUFjO0lBQUksQ0FBQztJQUVqRCxTQUFTLENBQUMsSUFBWTtRQUNwQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsdUJBQXVCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdEQsQ0FBQzsrR0FMVSxhQUFhOzZHQUFiLGFBQWE7OzRGQUFiLGFBQWE7a0JBSnpCLElBQUk7bUJBQUM7b0JBQ0osSUFBSSxFQUFFLFdBQVc7b0JBQ2pCLElBQUksRUFBRSxJQUFJO2lCQUNYIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRG9tU2FuaXRpemVyLCBTYWZlSHRtbCB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuXG5AUGlwZSh7XG4gIG5hbWU6ICd0cnVzdGh0bWwnLFxuICBwdXJlOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBUcnVzdEh0bWxQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIGNvbnN0cnVjdG9yIChwcml2YXRlIHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7IH1cblxuICB0cmFuc2Zvcm0oaHRtbDogc3RyaW5nKTogU2FmZUh0bWwge1xuICAgIHJldHVybiB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0SHRtbChodG1sKTtcbiAgfVxufVxuIl19

package/esm2022/components/shared/services/menu-manager.service.mjs

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MenuManagerService {
+    constructor() {
+        this.triggers = new Set();
+    }
+    register(trigger) {
+        this.triggers.add(trigger);
+    }
+    unregister(trigger) {
+        this.triggers.delete(trigger);
+    }
+    closeAllExcept(current) {
+        this.triggers.forEach(trigger => {
+            if (trigger !== current) {
+                trigger.close();
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MenuManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MenuManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MenuManagerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1tYW5hZ2VyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy9zaGFyZWQvc2VydmljZXMvbWVudS1tYW5hZ2VyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLGtCQUFrQjtJQUQvQjtRQUVZLGFBQVEsR0FBRyxJQUFJLEdBQUcsRUFBa0IsQ0FBQztLQWlCaEQ7SUFmVSxRQUFRLENBQUMsT0FBdUI7UUFDbkMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVNLFVBQVUsQ0FBQyxPQUF1QjtRQUNyQyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRU0sY0FBYyxDQUFDLE9BQXVCO1FBQ3pDLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQzVCLElBQUksT0FBTyxLQUFLLE9BQU8sRUFBRTtnQkFDckIsT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO2FBQ25CO1FBQ0wsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDOytHQWpCUSxrQkFBa0I7bUhBQWxCLGtCQUFrQixjQURMLE1BQU07OzRGQUNuQixrQkFBa0I7a0JBRDlCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2RrTWVudVRyaWdnZXIgfSBmcm9tICdAYW5ndWxhci9jZGsvbWVudSc7XG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgTWVudU1hbmFnZXJTZXJ2aWNlIHtcbiAgICBwcml2YXRlIHRyaWdnZXJzID0gbmV3IFNldDxDZGtNZW51VHJpZ2dlcj4oKTtcblxuICAgIHB1YmxpYyByZWdpc3Rlcih0cmlnZ2VyOiBDZGtNZW51VHJpZ2dlcik6IHZvaWQge1xuICAgICAgICB0aGlzLnRyaWdnZXJzLmFkZCh0cmlnZ2VyKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgdW5yZWdpc3Rlcih0cmlnZ2VyOiBDZGtNZW51VHJpZ2dlcik6IHZvaWQge1xuICAgICAgICB0aGlzLnRyaWdnZXJzLmRlbGV0ZSh0cmlnZ2VyKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgY2xvc2VBbGxFeGNlcHQoY3VycmVudDogQ2RrTWVudVRyaWdnZXIpOiB2b2lkIHtcbiAgICAgICAgdGhpcy50cmlnZ2Vycy5mb3JFYWNoKHRyaWdnZXIgPT4ge1xuICAgICAgICAgICAgaWYgKHRyaWdnZXIgIT09IGN1cnJlbnQpIHtcbiAgICAgICAgICAgICAgICB0cmlnZ2VyLmNsb3NlKCk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH0pO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/components/shared/translation.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TranslationService {
+}
+/**
+ * Very basic i18n implementation. Consumer apps can provide their own implementation of TranslationService to override.
+ */
+export class MinimalTranslationService {
+    static { this.messages = {
+        'common.actions.close': 'Close',
+        'confirmDialog.body': 'Are you sure?',
+        'confirmDialog.no': 'No',
+        'confirmDialog.yes': 'Yes',
+    }; }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getMessage(key, silent) {
+        return of(MinimalTranslationService.messages[key]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MinimalTranslationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MinimalTranslationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MinimalTranslationService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRpb24uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnRzL3NoYXJlZC90cmFuc2xhdGlvbi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFFdEMsTUFBTSxPQUFnQixrQkFBa0I7Q0FFdkM7QUFFRDs7R0FFRztBQUVILE1BQU0sT0FBTyx5QkFBeUI7YUFDckIsYUFBUSxHQUFHO1FBQ3hCLHNCQUFzQixFQUFFLE9BQU87UUFDL0Isb0JBQW9CLEVBQUUsZUFBZTtRQUNyQyxrQkFBa0IsRUFBRSxJQUFJO1FBQ3hCLG1CQUFtQixFQUFFLEtBQUs7S0FDM0IsQUFMc0IsQ0FLckI7SUFFRiw2REFBNkQ7SUFDN0QsVUFBVSxDQUFDLEdBQVcsRUFBRSxNQUFnQjtRQUN0QyxPQUFPLEVBQUUsQ0FBQyx5QkFBeUIsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNyRCxDQUFDOytHQVhVLHlCQUF5QjttSEFBekIseUJBQXlCOzs0RkFBekIseUJBQXlCO2tCQURyQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJztcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFRyYW5zbGF0aW9uU2VydmljZSB7XG4gIGFic3RyYWN0IGdldE1lc3NhZ2Uoa2V5OiBzdHJpbmcsIHNpbGVudD86IGJvb2xlYW4pOiBPYnNlcnZhYmxlPHN0cmluZz5cbn1cblxuLyoqXG4gKiBWZXJ5IGJhc2ljIGkxOG4gaW1wbGVtZW50YXRpb24uIENvbnN1bWVyIGFwcHMgY2FuIHByb3ZpZGUgdGhlaXIgb3duIGltcGxlbWVudGF0aW9uIG9mIFRyYW5zbGF0aW9uU2VydmljZSB0byBvdmVycmlkZS5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE1pbmltYWxUcmFuc2xhdGlvblNlcnZpY2UgaW1wbGVtZW50cyBUcmFuc2xhdGlvblNlcnZpY2Uge1xuICBwcml2YXRlIHN0YXRpYyBtZXNzYWdlcyA9IHtcbiAgICAnY29tbW9uLmFjdGlvbnMuY2xvc2UnOiAnQ2xvc2UnLFxuICAgICdjb25maXJtRGlhbG9nLmJvZHknOiAnQXJlIHlvdSBzdXJlPycsXG4gICAgJ2NvbmZpcm1EaWFsb2cubm8nOiAnTm8nLFxuICAgICdjb25maXJtRGlhbG9nLnllcyc6ICdZZXMnLFxuICB9O1xuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbiAgZ2V0TWVzc2FnZShrZXk6IHN0cmluZywgc2lsZW50PzogYm9vbGVhbik6IE9ic2VydmFibGU8c3RyaW5nPiB7XG4gICAgcmV0dXJuIG9mKE1pbmltYWxUcmFuc2xhdGlvblNlcnZpY2UubWVzc2FnZXNba2V5XSk7XG4gIH1cbn1cbiJdfQ==