@dereekb/dbx-form 0.0.1

package/esm2020/lib/formly/field/selection/pickable/pickable.field.directive.mjs

@@ -0,0 +1,244 @@
+import { beginLoading, LoadingStateContextInstance, successResult, mapLoadingStateResults, filterMaybe } from "@dereekb/rxjs";
+import { convertMaybeToArray, findUnique, makeValuesGroupMap } from "@dereekb/util";
+import { Directive, ViewChild } from "@angular/core";
+import { FormControl } from "@angular/forms";
+import { MatInput } from "@angular/material/input";
+import { FieldType } from "@ngx-formly/core";
+import { BehaviorSubject, combineLatest, of } from "rxjs";
+import { filter, map, debounceTime, distinctUntilChanged, switchMap, startWith, shareReplay, mergeMap, first, delay } from "rxjs/operators";
+import * as i0 from "@angular/core";
+/**
+ * Used for picking pre-set values using items as the presentation.
+ */
+export class AbstractDbxPickableItemFieldDirective extends FieldType {
+    constructor() {
+        super(...arguments);
+        this.inputCtrl = new FormControl('');
+        this._formControlObs = new BehaviorSubject(undefined);
+        this.formControl$ = this._formControlObs.pipe(filterMaybe());
+        this._displayHashMap = new BehaviorSubject(new Map());
+        this.filterInputValue$ = this.inputCtrl.valueChanges.pipe(startWith(undefined));
+        this.filterInputValueString$ = this.filterInputValue$.pipe(debounceTime(200), distinctUntilChanged(), shareReplay(1));
+        this.loadResultsDisplayValuesState$ = this.formControl$.pipe(first(), switchMap(() => this.loadValuesFn().pipe(switchMap((x) => this.loadDisplayValuesForFieldValues(x)), startWith(beginLoading()))), shareReplay(1));
+        this._formControlValue = this.formControl$.pipe(switchMap(control => control.valueChanges.pipe(startWith(control.value), shareReplay(1))));
+        this.loadResultsDisplayValues$ = this.loadResultsDisplayValuesState$.pipe(map(x => x?.value ?? []));
+        /**
+         * Current values in the form control.
+         */
+        this.values$ = this._formControlValue.pipe(map(convertMaybeToArray), shareReplay(1));
+        /**
+         * Current values with their display value.
+         */
+        this.displayValuesState$ = combineLatest([this.loadResultsDisplayValues$, this.values$]).pipe(switchMap(([displayValues, currentValues]) => {
+            const displayValuesMap = makeValuesGroupMap(displayValues, (x) => this.hashForValue(x.value));
+            const valuesNotInDisplayMap = [];
+            currentValues.forEach((x) => {
+                const key = this.hashForValue(x);
+                let displayValue = displayValuesMap.get(key)?.[0];
+                if (!displayValue) {
+                    valuesNotInDisplayMap.push(x);
+                }
+            });
+            if (valuesNotInDisplayMap.length) {
+                return this.loadDisplayValuesForValues(valuesNotInDisplayMap).pipe(map(x => mapLoadingStateResults(x, {
+                    mapValue: (loadedValues) => {
+                        loadedValues.forEach(x => x.isUnknown = x.isUnknown ?? true); // Assign unknown flag.
+                        return ([...displayValues, ...loadedValues]);
+                    }
+                })));
+            }
+            else {
+                return of(successResult(displayValues));
+            }
+        }));
+        /**
+         * Results to be displayed if filtered.
+         */
+        this.filteredSearchResultsState$ = this.loadResultsDisplayValues$.pipe(switchMap((values) => this.filterInputValueString$.pipe(switchMap(text => combineLatest([this._filterValues(text, values), this.displayValuesState$]).pipe(map(([values, displayState]) => mapLoadingStateResults(displayState, {
+            mapValue: (displayValues) => {
+                const valueHashSet = new Set(values.map(x => this.hashForValue(x)));
+                return displayValues.filter(x => !x.isUnknown && valueHashSet.has(x._hash));
+            }
+        })))))), shareReplay(1));
+        this.filteredSearchResults$ = this.filteredSearchResultsState$.pipe(map(x => x?.value), filterMaybe(), shareReplay(1));
+        this.items$ = combineLatest([this.filteredSearchResults$, this.values$]).pipe(map(([displayValues, values]) => {
+            const selectedHashValuesSet = new Set(values.map(x => this.hashForValue(x)));
+            let items = displayValues.map((x) => ({ display: x, selected: selectedHashValuesSet.has(x._hash) }));
+            if (this.sortItems) {
+                items = this.sortItems(items);
+            }
+            return items;
+        }), shareReplay(1));
+        this.itemsLoadingState$ = this.loadResultsDisplayValues$.pipe(switchMap(x => this.items$.pipe(first(), map(x => successResult(x)), startWith(beginLoading()), shareReplay(1))));
+        /**
+         * Context used for managing the loading of items, or when the current results change.
+         */
+        this.context = new LoadingStateContextInstance({ obs: this.itemsLoadingState$, showLoadingOnNoValue: false });
+        this.filterItemsLoadingState$ = this.items$.pipe(map(x => successResult(x)), startWith(beginLoading()), shareReplay(1));
+        /**
+         * Context used for searching/filtering.
+         */
+        this.filterResultsContext = new LoadingStateContextInstance({ obs: this.loadResultsDisplayValuesState$, showLoadingOnNoValue: true });
+    }
+    get multiSelect() {
+        return this.field.multiSelect ?? true;
+    }
+    get asArrayValue() {
+        return this.field.asArrayValue ?? true;
+    }
+    get filterLabel() {
+        return this.field.filterLabel;
+    }
+    get readonly() {
+        return this.field.templateOptions?.readonly;
+    }
+    get required() {
+        return this.field.templateOptions?.required;
+    }
+    get placeholder() {
+        return this.field.templateOptions?.placeholder ?? '';
+    }
+    get description() {
+        return this.field.templateOptions?.description;
+    }
+    get sortItems() {
+        return this.field.sortItems;
+    }
+    get hashForValue() {
+        return this.field.hashForValue ?? ((x) => x);
+    }
+    get displayForValue() {
+        return this.field.displayForValue;
+    }
+    get showFilterInput() {
+        return Boolean(this.field.filterValues);
+    }
+    get filterValuesFn() {
+        return this.field.filterValues ?? ((_, x) => of(x.map(y => y.value)));
+    }
+    get skipFilterFnOnEmpty() {
+        return this.field.skipFilterFnOnEmpty ?? true;
+    }
+    get _filterValues() {
+        let fn;
+        if (this.skipFilterFnOnEmpty) {
+            fn = (filterText, values) => {
+                let result;
+                if (filterText) {
+                    result = this.filterValuesFn(filterText, values);
+                }
+                else {
+                    result = of(values.map(x => x.value));
+                }
+                return result;
+            };
+        }
+        else {
+            fn = this.filterValuesFn;
+        }
+        return fn;
+    }
+    get showTextFilter() {
+        return this.field.showTextFilter ?? Boolean(this.field.filterValues);
+    }
+    get loadValuesFn() {
+        return this.field.loadValues;
+    }
+    get values() {
+        return this._getValueOnFormControl(this.formControl.value) ?? [];
+    }
+    get footerConfig() {
+        return this.field.footerConfig;
+    }
+    loadDisplayValuesForValues(values) {
+        return this.loadDisplayValuesForFieldValues(values.map((value) => ({ value })));
+    }
+    loadDisplayValuesForFieldValues(values) {
+        return this.getDisplayValuesForFieldValues(values).pipe(map((displayValues) => ({ loading: false, model: displayValues })), startWith({ loading: true }), shareReplay(1));
+    }
+    getDisplayValuesForFieldValues(values) {
+        return this._displayHashMap.pipe(mergeMap((displayMap) => {
+            const mappingResult = values
+                .map(x => [x, this.hashForValue(x.value)])
+                .map(([x, hash], i) => [i, hash, x, displayMap.get(hash)]);
+            const hasDisplay = mappingResult.filter(x => Boolean(x[3]));
+            const needsDisplay = mappingResult.filter(x => !x[3]);
+            if (needsDisplay.length > 0) {
+                // Go get the display value.
+                const displayValuesObs = this.displayForValue(needsDisplay.map(x => x[2]));
+                return displayValuesObs.pipe(first(), map((displayResults) => {
+                    const displayResultsWithHash = displayResults.map((x) => {
+                        x._hash = this.hashForValue(x.value);
+                        return x;
+                    });
+                    // Create a map to re-join values later.
+                    const displayResultsMapping = displayResultsWithHash.map(x => [x, x._hash]);
+                    const valueIndexHashMap = new Map(displayResultsMapping.map(([x, hash]) => [hash, x]));
+                    // Update displayMap. No need to push an update notification.
+                    displayResultsMapping.forEach(([x, hash]) => displayMap.set(hash, x));
+                    // Zip values back together.
+                    const newDisplayValues = mappingResult.map(x => x[3] ?? valueIndexHashMap.get(x[1]));
+                    // Return display values.
+                    return newDisplayValues;
+                }));
+            }
+            else {
+                // If all display values are hashed return that.
+                return of(hasDisplay.map(x => x[3]));
+            }
+        }));
+    }
+    ngOnInit() {
+        this._formControlObs.next(this.formControl);
+        // Focus after finished loading for the first time.
+        this.context.loading$.pipe(delay(10), filter(x => x), first()).subscribe(() => {
+            this.filterMatInput?.focus();
+        });
+    }
+    ngOnDestroy() {
+        this._displayHashMap.complete();
+        this._formControlObs.complete();
+        this.filterResultsContext.destroy();
+    }
+    _getValueOnFormControl(valueOnFormControl) {
+        const value = (valueOnFormControl != null) ? [].concat(valueOnFormControl) : []; // Always return an array.
+        return value;
+    }
+    addValue(value) {
+        this.setValues([...this.values, value]);
+    }
+    removeValue(value) {
+        const hashToFilter = this.hashForValue(value);
+        const values = this.values.filter(x => this.hashForValue(x) !== hashToFilter);
+        this.setValues(values);
+    }
+    setValues(values) {
+        // Use to filter non-unique values.
+        if (this.hashForValue) {
+            values = findUnique(values, this.hashForValue);
+        }
+        if (!this.multiSelect) {
+            values = [values[0]].filter(x => x != null);
+        }
+        this._setValueOnFormControl(values);
+    }
+    // MARK: Internal
+    _setValueOnFormControl(values) {
+        let newValue = values;
+        if (!this.asArrayValue) {
+            newValue = [values[0]].filter(x => x != null)[0];
+        }
+        this.formControl.setValue(newValue);
+        this.formControl.markAsTouched();
+        this.formControl.markAsDirty();
+    }
+}
+AbstractDbxPickableItemFieldDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbxPickableItemFieldDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbxPickableItemFieldDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractDbxPickableItemFieldDirective, viewQueries: [{ propertyName: "filterMatInput", first: true, predicate: ["filterMatInput"], descendants: true, static: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbxPickableItemFieldDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { filterMatInput: [{
+                type: ViewChild,
+                args: ['filterMatInput', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pickable.field.directive.js","sourceRoot":"","sources":["../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/pickable/pickable.field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DbxInjectedComponentConfig } from \"@dereekb/dbx-core\";\nimport { beginLoading, LoadingStateContextInstance, LoadingState, successResult, mapLoadingStateResults, filterMaybe } from \"@dereekb/rxjs\";\nimport { convertMaybeToArray, findUnique, groupValues, makeValuesGroupMap, Maybe } from \"@dereekb/util\";\nimport { Component, Directive, ElementRef, OnDestroy, OnInit, Type, ViewChild } from \"@angular/core\";\nimport { FormControl, AbstractControl } from \"@angular/forms\";\nimport { MatInput } from \"@angular/material/input\";\nimport { FieldType, FormlyFieldConfig } from \"@ngx-formly/core\";\nimport { BehaviorSubject, combineLatest, Observable, of } from \"rxjs\";\nimport { filter, map, debounceTime, distinctUntilChanged, switchMap, startWith, shareReplay, mergeMap, first, tap, delay } from \"rxjs/operators\";\nimport { PickableValueFieldDisplayFn, PickableValueFieldDisplayValue, PickableValueFieldFilterFn, PickableValueFieldHashFn, PickableValueFieldLoadValuesFn, PickableValueFieldValue } from \"./pickable\";\n\n/**\n * Wraps the selected state with the items.\n */\nexport interface PickableItemFieldItem<T> {\n  display: PickableValueFieldDisplayValue<T>;\n  selected?: boolean;\n}\n\nexport type PickableItemFieldItemSortFn<T> = (items: PickableItemFieldItem<T>[]) => PickableItemFieldItem<T>[];\n\nexport interface PickableValueFieldsFieldConfig<T> {\n  /**\n   * Loads all pickable values.\n   */\n  loadValues: PickableValueFieldLoadValuesFn<T>;\n  /**\n   * Used for building a display value given the input.\n   */\n  displayForValue: PickableValueFieldDisplayFn<T>;\n  /**\n   * Used for hashing display values and omitting repeat values.\n   *\n   * If hashForValue is not provided, the value's value will be used as is.\n   */\n  hashForValue?: PickableValueFieldHashFn<T>;\n  /**\n   * Used for filtering values via the search text.\n   */\n  filterValues?: PickableValueFieldFilterFn<T>;\n  /**\n   * Used for sorting the items before they are displayed.\n   * \n   * Should only be used to sort values.\n   */\n  sortItems?: PickableItemFieldItemSortFn<T>;\n  /**\n   * Whether or not to allow multiple items to be selected.\n   */\n  multiSelect?: boolean;\n  /**\n   * Whether or not to set/get values as an array or a single value. If set false, multiSelect is ignored.\n   */\n  asArrayValue?: boolean;\n  /**\n   * Whether or not to show the text filter. True by default if filterValues is provided.\n   */\n  showTextFilter?: boolean;\n  /**\n   * Whether or not to skip the filter function when the input is empty.\n   * \n   * True by default.\n   */\n  skipFilterFnOnEmpty?: boolean;\n  /**\n   * Filter Label\n   */\n  filterLabel?: string;\n  /**\n   * The maximum number of values that can be picked\n   */\n  maxPicks?: number;\n  /**\n   * Optional description/hint to display.\n   */\n  description?: string;\n  /**\n   * Footer Display\n   */\n  footerConfig?: DbxInjectedComponentConfig;\n}\n\nexport interface PickableValueFieldsFormlyFieldConfig<T> extends PickableValueFieldsFieldConfig<T>, FormlyFieldConfig { }\n\n/**\n * Displayed value with the computed hash.\n */\nexport interface PickableValueFieldDisplayValueWithHash<T, M = any> extends PickableValueFieldDisplayValue<T, M> {\n  _hash: any;\n}\n\n/**\n * Used for picking pre-set values using items as the presentation.\n */\n@Directive()\nexport class AbstractDbxPickableItemFieldDirective<T> extends FieldType<PickableValueFieldsFormlyFieldConfig<T>> implements OnInit, OnDestroy {\n\n  @ViewChild('filterMatInput', { static: true })\n  filterMatInput!: MatInput;\n\n  readonly inputCtrl = new FormControl('');\n\n  private _formControlObs = new BehaviorSubject<Maybe<AbstractControl>>(undefined);\n  readonly formControl$ = this._formControlObs.pipe(filterMaybe());\n\n  private _displayHashMap = new BehaviorSubject<Map<any, PickableValueFieldDisplayValue<T>>>(new Map());\n\n  readonly filterInputValue$: Observable<string> = this.inputCtrl.valueChanges.pipe(startWith(undefined as any));\n  readonly filterInputValueString$: Observable<string> = this.filterInputValue$.pipe(\n    debounceTime(200),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly loadResultsDisplayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>> = this.formControl$.pipe(\n    first(),\n    switchMap(() => this.loadValuesFn().pipe(\n      switchMap((x) => this.loadDisplayValuesForFieldValues(x)),\n      startWith(beginLoading<PickableValueFieldDisplayValueWithHash<T>[]>())\n    )),\n    shareReplay(1)\n  );\n\n  readonly _formControlValue: Observable<T | T[]> = this.formControl$.pipe(\n    switchMap(control => control.valueChanges.pipe(\n      startWith(control.value),\n      shareReplay(1)\n    ))\n  );\n\n  readonly loadResultsDisplayValues$: Observable<PickableValueFieldDisplayValueWithHash<T>[]> = this.loadResultsDisplayValuesState$.pipe(\n    map(x => x?.value ?? [])\n  );\n\n  /**\n   * Current values in the form control.\n   */\n  readonly values$: Observable<T[]> = this._formControlValue.pipe(\n    map(convertMaybeToArray),\n    shareReplay(1)\n  );\n\n  /**\n   * Current values with their display value.\n   */\n  readonly displayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>> =\n    combineLatest([this.loadResultsDisplayValues$, this.values$]).pipe(\n      switchMap(([displayValues, currentValues]) => {\n        const displayValuesMap = makeValuesGroupMap(displayValues, (x) => this.hashForValue(x.value));\n        const valuesNotInDisplayMap: T[] = [];\n\n        currentValues.forEach((x) => {\n          const key = this.hashForValue(x);\n          let displayValue: Maybe<PickableValueFieldDisplayValueWithHash<T>> = displayValuesMap.get(key)?.[0];\n\n          if (!displayValue) {\n            valuesNotInDisplayMap.push(x);\n          }\n        });\n\n        if (valuesNotInDisplayMap.length) {\n          return this.loadDisplayValuesForValues(valuesNotInDisplayMap).pipe(\n            map(x => mapLoadingStateResults(x, {\n              mapValue: (loadedValues: PickableValueFieldDisplayValueWithHash<T>[]) => {\n                loadedValues.forEach(x => x.isUnknown = x.isUnknown ?? true); // Assign unknown flag.\n                return ([...displayValues, ...loadedValues]);\n              }\n            }))\n          );\n        } else {\n          return of(successResult(displayValues));\n        }\n      })\n    );\n\n  /**\n   * Results to be displayed if filtered.\n   */\n  readonly filteredSearchResultsState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>> = this.loadResultsDisplayValues$.pipe(\n    switchMap((values) => this.filterInputValueString$.pipe(\n      switchMap(text => combineLatest([this._filterValues(text, values), this.displayValuesState$]).pipe(\n        map(([values, displayState]) => mapLoadingStateResults(displayState, {\n          mapValue: (displayValues: PickableValueFieldDisplayValueWithHash<T>[]) => {\n            const valueHashSet = new Set(values.map(x => this.hashForValue(x)));\n            return displayValues.filter(x => !x.isUnknown && valueHashSet.has(x._hash));\n          }\n        })))\n      )\n    )),\n    shareReplay(1)\n  );\n\n  readonly filteredSearchResults$: Observable<PickableValueFieldDisplayValueWithHash<T>[]> = this.filteredSearchResultsState$.pipe(\n    map(x => x?.value),\n    filterMaybe(),\n    shareReplay(1)\n  );\n\n  readonly items$: Observable<PickableItemFieldItem<T>[]> = combineLatest([this.filteredSearchResults$, this.values$]).pipe(\n    map(([displayValues, values]) => {\n      const selectedHashValuesSet = new Set(values.map(x => this.hashForValue(x)));\n      let items: PickableItemFieldItem<T>[] = displayValues.map((x) => ({ display: x, selected: selectedHashValuesSet.has(x._hash) }));\n\n      if (this.sortItems) {\n        items = this.sortItems(items);\n      }\n\n      return items;\n    }),\n    shareReplay(1)\n  );\n\n  readonly itemsLoadingState$: Observable<LoadingState> = this.loadResultsDisplayValues$.pipe(\n    switchMap(x => this.items$.pipe(\n      first(),\n      map(x => successResult(x)),\n      startWith(beginLoading()),\n      shareReplay(1)\n    ))\n  );\n\n  /**\n   * Context used for managing the loading of items, or when the current results change.\n   */\n  readonly context = new LoadingStateContextInstance({ obs: this.itemsLoadingState$, showLoadingOnNoValue: false });\n\n  readonly filterItemsLoadingState$: Observable<LoadingState> = this.items$.pipe(\n    map(x => successResult(x)),\n    startWith(beginLoading()),\n    shareReplay(1)\n  );\n\n  /**\n   * Context used for searching/filtering.\n   */\n  readonly filterResultsContext = new LoadingStateContextInstance({ obs: this.loadResultsDisplayValuesState$, showLoadingOnNoValue: true });\n\n  get multiSelect(): boolean {\n    return this.field.multiSelect ?? true;\n  }\n\n  get asArrayValue(): boolean {\n    return this.field.asArrayValue ?? true;\n  }\n\n  get filterLabel(): Maybe<string> {\n    return this.field.filterLabel;\n  }\n\n  get readonly(): Maybe<boolean> {\n    return this.field.templateOptions?.readonly;\n  }\n\n  get required(): Maybe<boolean> {\n    return this.field.templateOptions?.required;\n  }\n\n  get placeholder(): string {\n    return this.field.templateOptions?.placeholder ?? '';\n  }\n\n  get description(): Maybe<string> {\n    return this.field.templateOptions?.description;\n  }\n\n  get sortItems(): Maybe<PickableItemFieldItemSortFn<T>> {\n    return this.field.sortItems;\n  }\n\n  get hashForValue(): PickableValueFieldHashFn<T> {\n    return this.field.hashForValue ?? ((x) => x as any);\n  }\n\n  get displayForValue(): PickableValueFieldDisplayFn<T> {\n    return this.field.displayForValue;\n  }\n\n  get showFilterInput(): boolean {\n    return Boolean(this.field.filterValues);\n  }\n\n  get filterValuesFn(): PickableValueFieldFilterFn<T> {\n    return this.field.filterValues ?? ((_, x) => of(x.map(y => y.value)));\n  }\n\n  get skipFilterFnOnEmpty(): boolean {\n    return this.field.skipFilterFnOnEmpty ?? true;\n  }\n\n  get _filterValues(): PickableValueFieldFilterFn<T> {\n    let fn: PickableValueFieldFilterFn<T>;\n\n    if (this.skipFilterFnOnEmpty) {\n      fn = (filterText: Maybe<string>, values: PickableValueFieldDisplayValue<T>[]): Observable<T[]> => {\n        let result: Observable<T[]>;\n\n        if (filterText) {\n          result = this.filterValuesFn(filterText, values);\n        } else {\n          result = of(values.map(x => x.value));\n        }\n\n        return result;\n      };\n    } else {\n      fn = this.filterValuesFn;\n    }\n\n    return fn;\n  }\n\n  get showTextFilter(): boolean {\n    return this.field.showTextFilter ?? Boolean(this.field.filterValues);\n  }\n\n  get loadValuesFn(): PickableValueFieldLoadValuesFn<T> {\n    return this.field.loadValues;\n  }\n\n  get values(): T[] {\n    return this._getValueOnFormControl(this.formControl.value) ?? [];\n  }\n\n  get footerConfig(): Maybe<DbxInjectedComponentConfig> {\n    return this.field.footerConfig;\n  }\n\n  loadDisplayValuesForValues(values: T[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>> {\n    return this.loadDisplayValuesForFieldValues(values.map((value) => ({ value })));\n  }\n\n  loadDisplayValuesForFieldValues(values: PickableValueFieldValue<T>[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>> {\n    return this.getDisplayValuesForFieldValues(values).pipe(\n      map((displayValues: PickableValueFieldDisplayValueWithHash<T>[]) => ({ loading: false, model: displayValues })),\n      startWith({ loading: true }),\n      shareReplay(1)\n    );\n  }\n\n  getDisplayValuesForFieldValues(values: PickableValueFieldValue<T>[]): Observable<PickableValueFieldDisplayValueWithHash<T>[]> {\n    return this._displayHashMap.pipe(\n      mergeMap((displayMap) => {\n        const mappingResult = values\n          .map(x => [x, this.hashForValue(x.value)])\n          .map(([x, hash], i) => [i, hash, x, displayMap.get(hash)] as [number, any, PickableValueFieldValue<T>, PickableValueFieldDisplayValueWithHash<T>]);\n\n        const hasDisplay = mappingResult.filter(x => Boolean(x[3]));\n        const needsDisplay = mappingResult.filter(x => !x[3]);\n\n        if (needsDisplay.length > 0) {\n\n          // Go get the display value.\n          const displayValuesObs = this.displayForValue(needsDisplay.map(x => x[2]));\n\n          return displayValuesObs.pipe(\n            first(),\n            map((displayResults) => {\n\n              const displayResultsWithHash: PickableValueFieldDisplayValueWithHash<T>[] = displayResults.map((x) => {\n                (x as PickableValueFieldDisplayValueWithHash<T>)._hash = this.hashForValue(x.value);\n                return (x as PickableValueFieldDisplayValueWithHash<T>);\n              });\n\n              // Create a map to re-join values later.\n              const displayResultsMapping: [PickableValueFieldDisplayValueWithHash<T>, any][] = displayResultsWithHash.map(x => [x, x._hash]);\n              const valueIndexHashMap = new Map(displayResultsMapping.map(([x, hash]) => [hash, x]));\n\n              // Update displayMap. No need to push an update notification.\n              displayResultsMapping.forEach(([x, hash]) => displayMap.set(hash, x));\n\n              // Zip values back together.\n              const newDisplayValues = mappingResult.map(x => x[3] ?? valueIndexHashMap.get(x[1]));\n\n              // Return display values.\n              return newDisplayValues;\n            })\n          );\n        } else {\n\n          // If all display values are hashed return that.\n          return of(hasDisplay.map(x => x[3])) as Observable<PickableValueFieldDisplayValueWithHash<T>[]>;\n        }\n      })\n    );\n  }\n\n  ngOnInit(): void {\n    this._formControlObs.next(this.formControl);\n\n    // Focus after finished loading for the first time.\n    this.context.loading$.pipe(\n      delay(10),\n      filter(x => x),\n      first(),\n    ).subscribe(() => {\n      this.filterMatInput?.focus();\n    })\n  }\n\n  ngOnDestroy(): void {\n    this._displayHashMap.complete();\n    this._formControlObs.complete();\n    this.filterResultsContext.destroy();\n  }\n\n  protected _getValueOnFormControl(valueOnFormControl: any): T[] {\n    const value = (valueOnFormControl != null) ? [].concat(valueOnFormControl) : [];  // Always return an array.\n    return value as T[];\n  }\n\n  addValue(value: T): void {\n    this.setValues([...this.values, value]);\n  }\n\n  removeValue(value: T): void {\n    const hashToFilter = this.hashForValue(value);\n    const values = this.values.filter(x => this.hashForValue(x) !== hashToFilter);\n    this.setValues(values);\n  }\n\n  setValues(values: T[]): void {\n\n    // Use to filter non-unique values.\n    if (this.hashForValue) {\n      values = findUnique(values, this.hashForValue);\n    }\n\n    if (!this.multiSelect) {\n      values = [values[0]].filter(x => x != null);\n    }\n\n    this._setValueOnFormControl(values);\n  }\n\n  // MARK: Internal\n  protected _setValueOnFormControl(values: T[]): void {\n    let newValue: T | T[] = values;\n\n    if (!this.asArrayValue) {\n      newValue = [values[0]].filter(x => x != null)[0];\n    }\n\n    this.formControl.setValue(newValue);\n    this.formControl.markAsTouched();\n    this.formControl.markAsDirty();\n  }\n\n}\n"]}

package/esm2020/lib/formly/field/selection/pickable/pickable.field.module.mjs

@@ -0,0 +1,96 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatListModule } from '@angular/material/list';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { FormlyModule } from '@ngx-formly/core';
+import { MatButtonModule } from '@angular/material/button';
+import { DbxPickableChipFieldComponent } from './pickable.chip.field.component';
+import { DbxPickableListFieldComponent } from './pickable.list.field.component';
+import { DbxDatePipeModule, DbxInjectedComponentModule } from '@dereekb/dbx-core';
+import { DbxAnchorModule, DbxTextModule, DbxLoadingModule, DbxButtonModule } from '@dereekb/dbx-web';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+export class DbxFormFormlyPickableFieldModule {
+}
+DbxFormFormlyPickableFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlyPickableFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormFormlyPickableFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlyPickableFieldModule, declarations: [DbxPickableChipFieldComponent,
+        DbxPickableListFieldComponent], imports: [CommonModule,
+        DbxTextModule,
+        DbxLoadingModule,
+        DbxButtonModule,
+        FormsModule,
+        MatButtonModule,
+        MatInputModule,
+        MatFormFieldModule,
+        ReactiveFormsModule,
+        MatAutocompleteModule,
+        MatListModule,
+        DbxDatePipeModule,
+        DbxAnchorModule,
+        MatChipsModule,
+        MatIconModule,
+        DbxInjectedComponentModule, i1.FormlyModule] });
+DbxFormFormlyPickableFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlyPickableFieldModule, imports: [[
+            CommonModule,
+            DbxTextModule,
+            DbxLoadingModule,
+            DbxButtonModule,
+            FormsModule,
+            MatButtonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatListModule,
+            DbxDatePipeModule,
+            DbxAnchorModule,
+            MatChipsModule,
+            MatIconModule,
+            DbxInjectedComponentModule,
+            FormlyModule.forChild({
+                types: [
+                    { name: 'pickablechipfield', component: DbxPickableChipFieldComponent },
+                    { name: 'pickablelistfield', component: DbxPickableListFieldComponent },
+                ]
+            })
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlyPickableFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        DbxTextModule,
+                        DbxLoadingModule,
+                        DbxButtonModule,
+                        FormsModule,
+                        MatButtonModule,
+                        MatInputModule,
+                        MatFormFieldModule,
+                        ReactiveFormsModule,
+                        MatAutocompleteModule,
+                        MatListModule,
+                        DbxDatePipeModule,
+                        DbxAnchorModule,
+                        MatChipsModule,
+                        MatIconModule,
+                        DbxInjectedComponentModule,
+                        FormlyModule.forChild({
+                            types: [
+                                { name: 'pickablechipfield', component: DbxPickableChipFieldComponent },
+                                { name: 'pickablelistfield', component: DbxPickableListFieldComponent },
+                            ]
+                        })
+                    ],
+                    declarations: [
+                        DbxPickableChipFieldComponent,
+                        DbxPickableListFieldComponent
+                    ],
+                    exports: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/selection/pickable/pickable.list.field.component.mjs

@@ -0,0 +1,30 @@
+import { Component } from "@angular/core";
+import { AbstractDbxPickableItemFieldDirective } from "./pickable.field.directive";
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-web";
+import * as i2 from "@angular/material/list";
+import * as i3 from "@dereekb/dbx-core";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/input";
+import * as i7 from "@angular/forms";
+/**
+ * Used for picking pre-set values using a selection list as the presentation.
+ */
+export class DbxPickableListFieldComponent extends AbstractDbxPickableItemFieldDirective {
+    matSelectionChanged(selection) {
+        const options = selection.source.selectedOptions.selected;
+        const items = options.map(x => {
+            const { value, selected, disabled } = x;
+            return ({ item: value, selected, disabled });
+        });
+        this.setValues(items.map(x => x.item.display.value));
+    }
+}
+DbxPickableListFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxPickableListFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxPickableListFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxPickableListFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <div class=\"dbx-model-list dbx-pickable-item-field-list\">\n      <mat-selection-list [multiple]=\"multiSelect\" (selectionChange)=\"matSelectionChanged($event)\">\n        <mat-list-option *ngFor=\"let item of items$ | async\" [selected]=\"item.selected\" [value]=\"item\">\n          <p>{{ item.display.label }}</p>\n        </mat-list-option>\n      </mat-selection-list>\n      <dbx-injected-content [config]=\"footerConfig\"></dbx-injected-content>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <mat-form-field class=\"dbx-pickable-item-field-filter-field\" appearance=\"fill\">\n      <mat-label>{{ filterLabel }}</mat-label>\n      <input name=\"filter items\" #filterMatInput=\"matInput\" matInput [placeholder]=\"placeholder\"\n        [formControl]=\"inputCtrl\">\n    </mat-form-field>\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    </div>\n  </div>\n</ng-template>\n", components: [{ type: i1.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "context", "loading", "error"] }, { type: i2.MatSelectionList, selector: "mat-selection-list", inputs: ["disableRipple", "tabIndex", "color", "compareWith", "disabled", "multiple"], outputs: ["selectionChange"], exportAs: ["matSelectionList"] }, { type: i2.MatListOption, selector: "mat-list-option", inputs: ["disableRipple", "checkboxPosition", "color", "value", "disabled", "selected"], outputs: ["selectedChange"], exportAs: ["matListOption"] }, { type: i3.DbxInjectedComponent, selector: "dbx-injected-content, [dbx-injected-content]", inputs: ["config", "template"] }, { type: i4.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.MatLabel, selector: "mat-label" }, { type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i7.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i7.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "async": i5.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxPickableListFieldComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <div class=\"dbx-model-list dbx-pickable-item-field-list\">\n      <mat-selection-list [multiple]=\"multiSelect\" (selectionChange)=\"matSelectionChanged($event)\">\n        <mat-list-option *ngFor=\"let item of items$ | async\" [selected]=\"item.selected\" [value]=\"item\">\n          <p>{{ item.display.label }}</p>\n        </mat-list-option>\n      </mat-selection-list>\n      <dbx-injected-content [config]=\"footerConfig\"></dbx-injected-content>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <mat-form-field class=\"dbx-pickable-item-field-filter-field\" appearance=\"fill\">\n      <mat-label>{{ filterLabel }}</mat-label>\n      <input name=\"filter items\" #filterMatInput=\"matInput\" matInput [placeholder]=\"placeholder\"\n        [formControl]=\"inputCtrl\">\n    </mat-form-field>\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    </div>\n  </div>\n</ng-template>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/selection/pickable/pickable.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/selection/searchable/index.mjs

@@ -0,0 +1,9 @@
+export * from './searchable.chip.field.component';
+export * from './searchable.field.autocomplete.item.component';
+export * from './searchable.field.directive';
+export * from './searchable.field';
+export * from './searchable.field.module';
+export * from './searchable.text.field.component';
+export * from './searchable';
+export * from './text.chip.field';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC9zZWxlY3Rpb24vc2VhcmNoYWJsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsZ0RBQWdELENBQUM7QUFDL0QsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zZWFyY2hhYmxlLmNoaXAuZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoYWJsZS5maWVsZC5hdXRvY29tcGxldGUuaXRlbS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2hhYmxlLmZpZWxkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaGFibGUuZmllbGQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2hhYmxlLmZpZWxkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlYXJjaGFibGUudGV4dC5maWVsZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2hhYmxlJztcbmV4cG9ydCAqIGZyb20gJy4vdGV4dC5jaGlwLmZpZWxkJztcbiJdfQ==

package/esm2020/lib/formly/field/selection/searchable/searchable.chip.field.component.mjs

@@ -0,0 +1,45 @@
+import { Component } from '@angular/core';
+import { AbstractDbxSearchableValueFieldDirective } from './searchable.field.directive';
+import { COMMA, ENTER } from '@angular/cdk/keycodes';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/autocomplete";
+import * as i2 from "@angular/material/core";
+import * as i3 from "./searchable.field.autocomplete.item.component";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/chips";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@dereekb/dbx-web";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+export class DbxSearchableChipFieldComponent extends AbstractDbxSearchableValueFieldDirective {
+    constructor() {
+        super(...arguments);
+        this.separatorKeysCodes = [ENTER, COMMA];
+    }
+    selected(event) {
+        this.addWithDisplayValue(event.option.value);
+    }
+    tabPressedOnInput(event) {
+        if (event?.key?.toLowerCase() === 'tab') {
+            const value = this.inputCtrl.value;
+            if ((value || '').trim()) {
+                this._addWithTextValue(value);
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                return false;
+            }
+        }
+        return true;
+    }
+    addChip(event) {
+        const text = event.value ?? this.inputCtrl.value;
+        return this._addWithTextValue(text);
+    }
+}
+DbxSearchableChipFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableChipFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxSearchableChipFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxSearchableChipFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-searchable-field\">\n  <!-- Autocomplete -->\n  <mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"selected($event)\">\n    <mat-option *ngFor=\"let displayValue of (searchResults$ | async)\" [value]=\"displayValue\">\n      <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\">\n      </dbx-searchable-field-autocomplete-item>\n    </mat-option>\n  </mat-autocomplete>\n  <!-- Template -->\n  <ng-template #content>\n    <mat-form-field class=\"dbx-searchable-field-form-field\">\n      <mat-label>{{ label }}</mat-label>\n      <!-- TODO: Add back aria-label  [attr.aria-label]=\"'email ' + emailParticipantsType\" -->\n      <mat-chip-list [required]=\"required\" [disabled]=\"readonly\" #chipList>\n        <mat-chip *ngFor=\"let displayValue of displayValues$ | async\" [removable]=\"true\"\n          (removed)=\"removeWithDisplayValue(displayValue)\">\n          <span class=\"s-chip-label\">{{ displayValue.label }}</span>\n          <span class=\"s-chip-sublabel\" *ngIf=\"displayValue.sublabel\">({{ displayValue.sublabel }})</span>\n          <mat-icon *ngIf=\"!readonly\" matChipRemove>cancel</mat-icon>\n        </mat-chip>\n        <input #textInput [name]=\"name\" [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\"\n          autocomplete=\"{{ autocomplete }}\" [matChipInputFor]=\"chipList\" (keydown)=\"tabPressedOnInput($event)\"\n          [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" (matChipInputTokenEnd)=\"addChip($event)\">\n      </mat-chip-list>\n      <mat-hint *ngIf=\"description\">{{ description }}</mat-hint>\n    </mat-form-field>\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </ng-template>\n  <!-- View -->\n  <ng-container *ngTemplateOutlet=\"content\"></ng-container>\n</div>\n", components: [{ type: i1.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i2.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i3.DbxSearchableFieldAutocompleteItemComponent, selector: "dbx-searchable-field-autocomplete-item", inputs: ["displayValue"] }, { type: i4.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { type: i5.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i7.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "context", "loading", "error"] }], directives: [{ type: i8.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.MatLabel, selector: "mat-label" }, { type: i5.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i8.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.MatChipRemove, selector: "[matChipRemove]" }, { type: i9.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i1.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i5.MatChipInput, selector: "input[matChipInputFor]", inputs: ["matChipInputFor", "matChipInputAddOnBlur", "matChipInputSeparatorKeyCodes", "placeholder", "id", "disabled"], outputs: ["matChipInputTokenEnd"], exportAs: ["matChipInput", "matChipInputFor"] }, { type: i9.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i9.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i4.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { type: i8.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "async": i8.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableChipFieldComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<div class=\"dbx-searchable-field\">\n  <!-- Autocomplete -->\n  <mat-autocomplete #auto=\"matAutocomplete\" (optionSelected)=\"selected($event)\">\n    <mat-option *ngFor=\"let displayValue of (searchResults$ | async)\" [value]=\"displayValue\">\n      <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\">\n      </dbx-searchable-field-autocomplete-item>\n    </mat-option>\n  </mat-autocomplete>\n  <!-- Template -->\n  <ng-template #content>\n    <mat-form-field class=\"dbx-searchable-field-form-field\">\n      <mat-label>{{ label }}</mat-label>\n      <!-- TODO: Add back aria-label  [attr.aria-label]=\"'email ' + emailParticipantsType\" -->\n      <mat-chip-list [required]=\"required\" [disabled]=\"readonly\" #chipList>\n        <mat-chip *ngFor=\"let displayValue of displayValues$ | async\" [removable]=\"true\"\n          (removed)=\"removeWithDisplayValue(displayValue)\">\n          <span class=\"s-chip-label\">{{ displayValue.label }}</span>\n          <span class=\"s-chip-sublabel\" *ngIf=\"displayValue.sublabel\">({{ displayValue.sublabel }})</span>\n          <mat-icon *ngIf=\"!readonly\" matChipRemove>cancel</mat-icon>\n        </mat-chip>\n        <input #textInput [name]=\"name\" [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\"\n          autocomplete=\"{{ autocomplete }}\" [matChipInputFor]=\"chipList\" (keydown)=\"tabPressedOnInput($event)\"\n          [matChipInputSeparatorKeyCodes]=\"separatorKeysCodes\" (matChipInputTokenEnd)=\"addChip($event)\">\n      </mat-chip-list>\n      <mat-hint *ngIf=\"description\">{{ description }}</mat-hint>\n    </mat-form-field>\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </ng-template>\n  <!-- View -->\n  <ng-container *ngTemplateOutlet=\"content\"></ng-container>\n</div>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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