@dereekb/dbx-form 0.0.1

package/esm2020/lib/formly/field/selection/searchable/searchable.field.autocomplete.item.component.mjs

@@ -0,0 +1,73 @@
+import { Component, Input, ViewChild, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@dereekb/dbx-web";
+export class DbxSearchableFieldAutocompleteItemComponent {
+    ngOnInit() {
+        this.content.clear();
+        const componentClass = this.displayValue?.componentClass;
+        if (componentClass) {
+            const componentRef = this.content.createComponent(componentClass);
+            componentRef.instance.displayValue = this.displayValue;
+        }
+    }
+}
+DbxSearchableFieldAutocompleteItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableFieldAutocompleteItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DbxSearchableFieldAutocompleteItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxSearchableFieldAutocompleteItemComponent, selector: "dbx-searchable-field-autocomplete-item", inputs: { displayValue: "displayValue" }, viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: `
+    <ng-template #content></ng-template>
+  `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableFieldAutocompleteItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-searchable-field-autocomplete-item',
+                    template: `
+    <ng-template #content></ng-template>
+  `
+                }]
+        }], propDecorators: { content: [{
+                type: ViewChild,
+                args: ['content', { static: true, read: ViewContainerRef }]
+            }], displayValue: [{
+                type: Input
+            }] } });
+// MARK: Default
+export class DbxDefaultSearchableFieldDisplayComponent {
+}
+DbxDefaultSearchableFieldDisplayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxDefaultSearchableFieldDisplayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DbxDefaultSearchableFieldDisplayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxDefaultSearchableFieldDisplayComponent, selector: "dbx-default-searchable-field-display", inputs: { displayValue: "displayValue" }, ngImport: i0, template: `
+    <span class="s-chip-label">{{ displayValue.label }}</span>
+    <span class="s-chip-sublabel" *ngIf="displayValue.sublabel">({{ displayValue.sublabel }})</span>
+  `, isInline: true, directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxDefaultSearchableFieldDisplayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-default-searchable-field-display',
+                    template: `
+    <span class="s-chip-label">{{ displayValue.label }}</span>
+    <span class="s-chip-sublabel" *ngIf="displayValue.sublabel">({{ displayValue.sublabel }})</span>
+  `
+                }]
+        }], propDecorators: { displayValue: [{
+                type: Input
+            }] } });
+export class DbxDefaultSearchableAnchorFieldDisplayComponent {
+}
+DbxDefaultSearchableAnchorFieldDisplayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxDefaultSearchableAnchorFieldDisplayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DbxDefaultSearchableAnchorFieldDisplayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxDefaultSearchableAnchorFieldDisplayComponent, selector: "ng-component", inputs: { displayValue: "displayValue" }, ngImport: i0, template: `
+    <dbx-anchor [block]="true" [anchor]="displayValue?.anchor">
+      <dbx-default-searchable-field-display [displayValue]="displayValue"></dbx-default-searchable-field-display>
+    </dbx-anchor>
+  `, isInline: true, components: [{ type: i2.DbxAnchorComponent, selector: "dbx-anchor, [dbx-anchor]", inputs: ["block"] }, { type: DbxDefaultSearchableFieldDisplayComponent, selector: "dbx-default-searchable-field-display", inputs: ["displayValue"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxDefaultSearchableAnchorFieldDisplayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-anchor [block]="true" [anchor]="displayValue?.anchor">
+      <dbx-default-searchable-field-display [displayValue]="displayValue"></dbx-default-searchable-field-display>
+    </dbx-anchor>
+  `
+                }]
+        }], propDecorators: { displayValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,237 @@
+import { filterMaybe, SubscriptionObject, beginLoading, LoadingStateContextInstance } from '@dereekb/rxjs';
+import { Directive, ElementRef, ViewChild } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { FieldType } from '@ngx-formly/core';
+import { debounceTime, distinctUntilChanged, filter, first, map, mergeMap, shareReplay, startWith, switchMap, BehaviorSubject, of } from 'rxjs';
+import { DbxDefaultSearchableAnchorFieldDisplayComponent, DbxDefaultSearchableFieldDisplayComponent } from './searchable.field.autocomplete.item.component';
+import { convertMaybeToArray, findUnique } from '@dereekb/util';
+import { camelCase } from 'change-case';
+import * as i0 from "@angular/core";
+/**
+ * Abstract searchable field that provides a feature for searching for values, and for displaying values using Observables.
+ *
+ * Display values are cached for performance.
+ */
+export class AbstractDbxSearchableValueFieldDirective extends FieldType {
+    constructor() {
+        super(...arguments);
+        /**
+         * Whether or not to set/get values as an array.
+         */
+        this.multiSelect = true;
+        this.inputCtrl = new FormControl('');
+        this._formControlObs = new BehaviorSubject(undefined);
+        this.formControl$ = this._formControlObs.pipe(filterMaybe());
+        this._displayHashMap = new BehaviorSubject(new Map());
+        this.inputValue$ = this.inputCtrl.valueChanges.pipe();
+        this.inputValueString$ = this.inputValue$.pipe(debounceTime(200), distinctUntilChanged());
+        this.searchResultsState$ = this.inputValueString$.pipe(filter((text) => Boolean(text || this.searchOnEmptyText) && Boolean(this.search)), 
+        // TODO: Consider caching search text/results.
+        switchMap((text) => this.search(text).pipe(switchMap((x) => this.loadDisplayValuesForFieldValues(x)), 
+        // Return begin loading to setup the loading state.
+        startWith(beginLoading()))), shareReplay(1));
+        this.singleValueSyncSubscription = new SubscriptionObject();
+        this.searchContext = new LoadingStateContextInstance({ obs: this.searchResultsState$, showLoadingOnNoValue: true });
+        this.searchResults$ = this.searchResultsState$.pipe(map(x => x?.value ?? []));
+        this._formControlValue = this.formControl$.pipe(switchMap(control => control.valueChanges.pipe(startWith(control.value), shareReplay(1))));
+        this.values$ = this._formControlValue.pipe(map(convertMaybeToArray), shareReplay(1));
+        this.displayValuesState$ = this.values$.pipe(distinctUntilChanged(), switchMap((values) => this.loadDisplayValuesForValues(values)), shareReplay(1));
+        this.displayValues$ = this.displayValuesState$.pipe(map(x => x?.value ?? []));
+    }
+    get name() {
+        return this.field.name ?? (camelCase(this.label ?? this.key));
+    }
+    get label() {
+        return this.field.templateOptions?.label;
+    }
+    get readonly() {
+        return this.field.templateOptions?.readonly;
+    }
+    get searchOnEmptyText() {
+        return this.field.searchOnEmptyText ?? false;
+    }
+    get required() {
+        return this.field.templateOptions?.required;
+    }
+    get autocomplete() {
+        return this.field.templateOptions?.attributes?.['autocomplete'] ?? this.key;
+    }
+    get placeholder() {
+        return this.field.templateOptions?.placeholder ?? '';
+    }
+    get description() {
+        return this.field.description ?? this.field.templateOptions?.description;
+    }
+    get hashForValue() {
+        return this.field.hashForValue ?? ((x) => x);
+    }
+    get displayForValue() {
+        return this.field.displayForValue;
+    }
+    get useAnchor() {
+        return this.field.useAnchor;
+    }
+    get anchorForValue() {
+        return this.field.anchorForValue;
+    }
+    get componentClass() {
+        return this.field.componentClass;
+    }
+    get search() {
+        return this.field.search;
+    }
+    get values() {
+        return this._getValueOnFormControl(this.formControl.value) ?? [];
+    }
+    get allowStringValues() {
+        return this.allowStringValues ?? Boolean(this.convertStringValue);
+    }
+    get convertStringValue() {
+        return this.field.convertStringValue;
+    }
+    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]));
+                const componentClass = this.componentClass ?? this.defaultComponentClass;
+                const anchorForValue = this.useAnchor && this.anchorForValue;
+                return displayValuesObs.pipe(first(), map((displayResults) => {
+                    // Assign the default component classes.
+                    displayResults.forEach(x => {
+                        if (!x.componentClass) {
+                            x.componentClass = componentClass;
+                        }
+                        if (!x.anchor && anchorForValue) {
+                            x.anchor = anchorForValue(x);
+                        }
+                    });
+                    // Create a map to re-join values later.
+                    const displayResultsMapping = displayResults.map(x => [x, this.hashForValue(x.value)]);
+                    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);
+        if (this.field.textInputValidator) {
+            this.inputCtrl.setValidators(this.field.textInputValidator);
+        }
+        if (!this.defaultComponentClass) {
+            if (this.useAnchor) {
+                this.defaultComponentClass = DbxDefaultSearchableAnchorFieldDisplayComponent;
+            }
+            else {
+                this.defaultComponentClass = DbxDefaultSearchableFieldDisplayComponent;
+            }
+        }
+        if (this.multiSelect === false) {
+            this.singleValueSyncSubscription.subscription = this.displayValues$.subscribe((x) => {
+                if (x[0]) {
+                    this._syncSingleValue(x[0]);
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._displayHashMap.complete();
+        this._formControlObs.complete();
+        this.searchContext.destroy();
+    }
+    /**
+     * Used to sync the input control with the selected value.
+     *
+     * Only used when multiSelect is false.
+     */
+    _syncSingleValue(value) {
+        this.inputCtrl.setValue(value.label);
+    }
+    _addWithTextValue(text) {
+        if (!this.field.allowStringValues) {
+            return;
+        }
+        if (text) {
+            text = (text || '').trim();
+            this.inputCtrl.setValue(text.trim());
+        }
+        // console.log('Add: ', text, this.inputCtrl.valid);
+        if (!this.inputCtrl.valid) {
+            return;
+        }
+        if (text) {
+            const value = (this.convertStringValue) ? this.convertStringValue(text) : text;
+            this.addValue(value);
+        }
+    }
+    addWithDisplayValue(displayValue) {
+        this.addValue(displayValue.value);
+    }
+    removeWithDisplayValue(displayValue) {
+        this.removeValue(displayValue.value);
+    }
+    addValue(value) {
+        this.textInput.nativeElement.value = '';
+        this.inputCtrl.setValue(null);
+        this.setValues([...this.values, value]);
+    }
+    removeValue(value) {
+        let values;
+        if (this.hashForValue) {
+            const hashToFilter = this.hashForValue(value);
+            values = this.values.filter(x => this.hashForValue(x) !== hashToFilter);
+        }
+        else {
+            values = this.values.filter(x => x !== value);
+        }
+        this.setValues(values);
+    }
+    setValues(values) {
+        // Use to filter non-unique values.
+        if (this.hashForValue) {
+            values = findUnique(values, this.hashForValue);
+        }
+        this._setValueOnFormControl(values);
+    }
+    // MARK: Internal
+    _getValueOnFormControl(valueOnFormControl) {
+        const value = (valueOnFormControl != null) ? [].concat(valueOnFormControl) : []; // Always return an array.
+        return value;
+    }
+    _setValueOnFormControl(values) {
+        const value = (this.multiSelect) ? values : values?.[0];
+        this.formControl.setValue(value);
+        this.formControl.markAsDirty();
+        this.formControl.markAsTouched();
+    }
+}
+AbstractDbxSearchableValueFieldDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbxSearchableValueFieldDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbxSearchableValueFieldDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractDbxSearchableValueFieldDirective, viewQueries: [{ propertyName: "textInput", first: true, predicate: ["textInput"], descendants: true }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbxSearchableValueFieldDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { textInput: [{
+                type: ViewChild,
+                args: ['textInput']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchable.field.directive.js","sourceRoot":"","sources":["../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/searchable/searchable.field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { filterMaybe, SubscriptionObject, beginLoading, LoadingState, LoadingStateContextInstance } from '@dereekb/rxjs';\nimport { Directive, ElementRef, OnDestroy, OnInit, Type, ViewChild } from '@angular/core';\nimport { AbstractControl, FormControl, ValidatorFn } from '@angular/forms';\nimport { FieldType, FormlyFieldConfig } from '@ngx-formly/core';\nimport { debounceTime, distinctUntilChanged, filter, first, map, mergeMap, shareReplay, startWith, switchMap, BehaviorSubject, of, Observable } from 'rxjs';\nimport {\n  SearchableValueFieldHashFn, SearchableValueFieldStringSearchFn,\n  SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldValue, SearchableFieldDisplayComponent, SearchableValueFieldAnchorFn\n} from './searchable';\nimport { DbxDefaultSearchableAnchorFieldDisplayComponent, DbxDefaultSearchableFieldDisplayComponent } from './searchable.field.autocomplete.item.component';\nimport { Maybe, convertMaybeToArray, findUnique } from '@dereekb/util';\nimport { camelCase } from 'change-case';\n\nexport interface StringValueFieldsFieldConfig {\n  /**\n   * Custom input validators.\n   */\n  textInputValidator?: ValidatorFn | ValidatorFn[];\n  /**\n   * Optional description/hint to display.\n   */\n  description?: string;\n}\n\nexport interface StringValueFieldsFormlyFieldConfig extends StringValueFieldsFieldConfig, FormlyFieldConfig { }\n\nexport interface SearchableValueFieldsFieldConfig<T> extends StringValueFieldsFieldConfig {\n  /**\n   * Whether or not to allow string values to be used directly, or if values can only be chosen from searching.\n   */\n  allowStringValues?: boolean;\n  /**\n   * Optional conversion function. If provided, allowStringValues is considered true.\n   */\n  convertStringValue?: (text: string) => 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?: SearchableValueFieldHashFn<T>;\n  /**\n   * Performs a search.\n   */\n  search: SearchableValueFieldStringSearchFn<T>;\n  /**\n   * Whether or not to allow searches on empty text. Is false by default.\n   */\n  searchOnEmptyText?: boolean;\n  /**\n   * Custom component class to use by default.\n   */\n  componentClass?: Type<SearchableFieldDisplayComponent<T>>;\n  /**\n   * Used for building a display value given the input.\n   */\n  displayForValue: SearchableValueFieldDisplayFn<T>;\n  /**\n   * Whether or not to use the anchor field on value elements.\n   *\n   * This has no default effect if a component class is provided.\n   */\n  useAnchor?: boolean;\n  /**\n   * Used for retrieving an anchor value for values that have no anchor value set.\n   *\n   * Only used when useAnchor is true.\n   */\n  anchorForValue?: SearchableValueFieldAnchorFn<T>;\n}\n\nexport interface SearchableValueFieldsFormlyFieldConfig<T> extends SearchableValueFieldsFieldConfig<T>, FormlyFieldConfig { }\n\n/**\n * Abstract searchable field that provides a feature for searching for values, and for displaying values using Observables.\n *\n * Display values are cached for performance.\n */\n@Directive()\nexport abstract class AbstractDbxSearchableValueFieldDirective<T, C extends SearchableValueFieldsFormlyFieldConfig<T>>\n  extends FieldType<C> implements OnInit, OnDestroy {\n\n  /**\n   * Whether or not to set/get values as an array.\n   */\n  multiSelect = true;\n\n  defaultComponentClass?: Type<SearchableFieldDisplayComponent<T>>;\n\n  @ViewChild('textInput')\n  textInput!: ElementRef<HTMLInputElement>;\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, SearchableValueFieldDisplayValue<T>>>(new Map());\n\n  readonly inputValue$: Observable<string> = this.inputCtrl.valueChanges.pipe();\n  readonly inputValueString$: Observable<string> = this.inputValue$.pipe(\n    debounceTime(200),\n    distinctUntilChanged()\n  );\n\n  readonly searchResultsState$ = this.inputValueString$.pipe(\n    filter((text) => Boolean(text || this.searchOnEmptyText) && Boolean(this.search)),\n    // TODO: Consider caching search text/results.\n    switchMap((text) => this.search(text).pipe(\n      switchMap((x) => this.loadDisplayValuesForFieldValues(x)),\n      // Return begin loading to setup the loading state.\n      startWith(beginLoading())\n    )),\n    shareReplay(1)\n  );\n\n  readonly singleValueSyncSubscription = new SubscriptionObject();\n\n  readonly searchContext = new LoadingStateContextInstance({ obs: this.searchResultsState$, showLoadingOnNoValue: true });\n\n  readonly searchResults$: Observable<SearchableValueFieldDisplayValue<T>[]> = this.searchResultsState$.pipe(\n    map(x => x?.value ?? [])\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 values$: Observable<T[]> = this._formControlValue.pipe(\n    map(convertMaybeToArray),\n    shareReplay(1)\n  );\n\n  readonly displayValuesState$: Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>> = this.values$.pipe(\n    distinctUntilChanged(),\n    switchMap((values: T[]) => this.loadDisplayValuesForValues(values)),\n    shareReplay(1)\n  );\n\n  readonly displayValues$: Observable<SearchableValueFieldDisplayValue<T>[]> = this.displayValuesState$.pipe(\n    map(x => x?.value ?? [])\n  );\n\n  get name(): string {\n    return this.field.name ?? (camelCase(this.label ?? this.key as string));\n  }\n\n  get label(): Maybe<string> {\n    return this.field.templateOptions?.label;\n  }\n\n  get readonly(): Maybe<boolean> {\n    return this.field.templateOptions?.readonly;\n  }\n\n  get searchOnEmptyText(): boolean {\n    return this.field.searchOnEmptyText ?? false;\n  }\n\n  get required(): Maybe<boolean> {\n    return this.field.templateOptions?.required;\n  }\n\n  get autocomplete(): string {\n    return (this.field.templateOptions?.attributes?.['autocomplete'] as any) ?? this.key as string;\n  }\n\n  get placeholder(): string {\n    return this.field.templateOptions?.placeholder ?? '';\n  }\n\n  get description(): Maybe<string> {\n    return this.field.description ?? this.field.templateOptions?.description;\n  }\n\n  get hashForValue(): SearchableValueFieldHashFn<T> {\n    return this.field.hashForValue ?? ((x) => x as any);\n  }\n\n  get displayForValue(): SearchableValueFieldDisplayFn<T> {\n    return this.field.displayForValue;\n  }\n\n  get useAnchor(): Maybe<boolean> {\n    return this.field.useAnchor;\n  }\n\n  get anchorForValue(): Maybe<SearchableValueFieldAnchorFn<T>> {\n    return this.field.anchorForValue;\n  }\n\n  get componentClass(): Maybe<Type<SearchableFieldDisplayComponent<T>>> {\n    return this.field.componentClass;\n  }\n\n  get search(): SearchableValueFieldStringSearchFn<T> {\n    return this.field.search;\n  }\n\n  get values(): T[] {\n    return this._getValueOnFormControl(this.formControl.value) ?? [];\n  }\n\n  get allowStringValues(): boolean {\n    return this.allowStringValues ?? Boolean(this.convertStringValue);\n  }\n\n  get convertStringValue(): Maybe<(text: string) => T> {\n    return this.field.convertStringValue;\n  }\n\n  loadDisplayValuesForValues(values: T[]): Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>> {\n    return this.loadDisplayValuesForFieldValues(values.map((value) => ({ value })));\n  }\n\n  loadDisplayValuesForFieldValues(values: SearchableValueFieldValue<T>[]): Observable<LoadingState<SearchableValueFieldDisplayValue<T>[]>> {\n    return this.getDisplayValuesForFieldValues(values).pipe(\n      map((displayValues: SearchableValueFieldDisplayValue<T>[]) => ({ loading: false, model: displayValues })),\n      startWith({ loading: true }),\n      shareReplay(1)\n    );\n  }\n\n  getDisplayValuesForFieldValues(values: SearchableValueFieldValue<T>[]): Observable<SearchableValueFieldDisplayValue<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, SearchableValueFieldValue<T>, SearchableValueFieldDisplayValue<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          const componentClass = this.componentClass ?? this.defaultComponentClass;\n          const anchorForValue = this.useAnchor && this.anchorForValue;\n\n          return displayValuesObs.pipe(\n            first(),\n            map((displayResults) => {\n\n              // Assign the default component classes.\n              displayResults.forEach(x => {\n                if (!x.componentClass) {\n                  x.componentClass = componentClass;\n                }\n\n                if (!x.anchor && anchorForValue) {\n                  x.anchor = anchorForValue(x);\n                }\n              });\n\n              // Create a map to re-join values later.\n              const displayResultsMapping: [SearchableValueFieldDisplayValue<T>, any][] = displayResults.map(x => [x, this.hashForValue(x.value)]);\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<SearchableValueFieldDisplayValue<T>[]>;\n        }\n      })\n    );\n  }\n\n  ngOnInit(): void {\n    this._formControlObs.next(this.formControl);\n\n    if (this.field.textInputValidator) {\n      this.inputCtrl.setValidators(this.field.textInputValidator);\n    }\n\n    if (!this.defaultComponentClass) {\n      if (this.useAnchor) {\n        this.defaultComponentClass = DbxDefaultSearchableAnchorFieldDisplayComponent;\n      } else {\n        this.defaultComponentClass = DbxDefaultSearchableFieldDisplayComponent;\n      }\n    }\n\n    if (this.multiSelect === false) {\n      this.singleValueSyncSubscription.subscription = this.displayValues$.subscribe((x) => {\n        if (x[0]) {\n          this._syncSingleValue(x[0]);\n        }\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._displayHashMap.complete();\n    this._formControlObs.complete();\n    this.searchContext.destroy();\n  }\n\n  /**\n   * Used to sync the input control with the selected value.\n   *\n   * Only used when multiSelect is false.\n   */\n  protected _syncSingleValue(value: SearchableValueFieldDisplayValue<T>): void {\n    this.inputCtrl.setValue(value.label);\n  }\n\n  protected _addWithTextValue(text: string): void {\n    if (!this.field.allowStringValues) {\n      return;\n    }\n\n    if (text) {\n      text = (text || '').trim();\n      this.inputCtrl.setValue(text.trim());\n    }\n\n    // console.log('Add: ', text, this.inputCtrl.valid);\n\n    if (!this.inputCtrl.valid) {\n      return;\n    }\n\n    if (text) {\n      const value = (this.convertStringValue) ? this.convertStringValue(text) : text as any as T;\n      this.addValue(value);\n    }\n  }\n\n  addWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void {\n    this.addValue(displayValue.value);\n  }\n\n  removeWithDisplayValue(displayValue: SearchableValueFieldDisplayValue<T>): void {\n    this.removeValue(displayValue.value);\n  }\n\n  addValue(value: T): void {\n    this.textInput.nativeElement.value = '';\n    this.inputCtrl.setValue(null);\n    this.setValues([...this.values, value]);\n  }\n\n  removeValue(value: T): void {\n    let values;\n\n    if (this.hashForValue) {\n      const hashToFilter = this.hashForValue(value);\n      values = this.values.filter(x => this.hashForValue(x) !== hashToFilter);\n    } else {\n      values = this.values.filter(x => x !== value);\n    }\n\n    this.setValues(values);\n  }\n\n  setValues(values: T[]): void {\n    // Use to filter non-unique values.\n    if (this.hashForValue) {\n      values = findUnique(values, this.hashForValue);\n    }\n\n    this._setValueOnFormControl(values);\n  }\n\n  // MARK: Internal\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  protected _setValueOnFormControl(values: T[]): void {\n    const value = (this.multiSelect) ? values : values?.[0];\n    this.formControl.setValue(value);\n    this.formControl.markAsDirty();\n    this.formControl.markAsTouched();\n  }\n\n}\n"]}

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

@@ -0,0 +1,45 @@
+import { arrayToMap, separateValues } from '@dereekb/util';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { formlyField } from '../../field';
+export function makeMetaFilterSearchableFieldValueDisplayFn(loadMetaForValues, makeDisplayForValues) {
+    return (values) => {
+        const { included: loaded, excluded: needLoading } = separateValues(values, (x) => Boolean(x.meta));
+        let allValues;
+        if (needLoading.length > 0) {
+            const loadingResult = loadMetaForValues(needLoading);
+            allValues = loadingResult.pipe(map((result) => {
+                const resultMap = arrayToMap(result, (x) => x.value);
+                const mergedWithLoad = needLoading.map((x) => {
+                    const id = x.value;
+                    const loadedItem = resultMap.get(id);
+                    const anchor = x.anchor ?? loadedItem?.anchor;
+                    const meta = loadedItem?.meta;
+                    return {
+                        ...x,
+                        anchor,
+                        meta
+                    };
+                }).filter(x => !x.meta);
+                return mergedWithLoad;
+            }), map((result) => [...loaded, ...result]));
+        }
+        else {
+            allValues = of(loaded);
+        }
+        return allValues.pipe(map((x) => makeDisplayForValues(x)));
+    };
+}
+export function searchableChipField(config) {
+    return formlyField({
+        type: 'searchablechipfield',
+        ...config
+    });
+}
+export function searchableTextField(config) {
+    return formlyField({
+        type: 'searchabletextfield',
+        ...config
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,107 @@
+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 { DbxSearchableChipFieldComponent } from './searchable.chip.field.component';
+import { MatButtonModule } from '@angular/material/button';
+import { DbxDefaultSearchableAnchorFieldDisplayComponent, DbxDefaultSearchableFieldDisplayComponent, DbxSearchableFieldAutocompleteItemComponent } from './searchable.field.autocomplete.item.component';
+import { DbxSearchableTextFieldComponent } from './searchable.text.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 DbxFormFormlySearchableFieldModule {
+}
+DbxFormFormlySearchableFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlySearchableFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormFormlySearchableFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlySearchableFieldModule, declarations: [DbxSearchableChipFieldComponent,
+        DbxSearchableTextFieldComponent,
+        DbxSearchableFieldAutocompleteItemComponent,
+        DbxDefaultSearchableFieldDisplayComponent,
+        DbxDefaultSearchableAnchorFieldDisplayComponent], imports: [CommonModule,
+        DbxTextModule,
+        DbxLoadingModule,
+        DbxButtonModule,
+        FormsModule,
+        MatButtonModule,
+        MatInputModule,
+        MatFormFieldModule,
+        ReactiveFormsModule,
+        MatAutocompleteModule,
+        MatListModule,
+        DbxDatePipeModule,
+        DbxAnchorModule,
+        MatChipsModule,
+        MatIconModule,
+        DbxInjectedComponentModule, i1.FormlyModule], exports: [DbxSearchableChipFieldComponent,
+        DbxSearchableTextFieldComponent] });
+DbxFormFormlySearchableFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlySearchableFieldModule, imports: [[
+            CommonModule,
+            DbxTextModule,
+            DbxLoadingModule,
+            DbxButtonModule,
+            FormsModule,
+            MatButtonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatListModule,
+            DbxDatePipeModule,
+            DbxAnchorModule,
+            MatChipsModule,
+            MatIconModule,
+            DbxInjectedComponentModule,
+            FormlyModule.forChild({
+                types: [
+                    { name: 'searchablechipfield', component: DbxSearchableChipFieldComponent },
+                    { name: 'searchabletextfield', component: DbxSearchableTextFieldComponent }
+                ]
+            })
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormFormlySearchableFieldModule, 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: 'searchablechipfield', component: DbxSearchableChipFieldComponent },
+                                { name: 'searchabletextfield', component: DbxSearchableTextFieldComponent }
+                            ]
+                        })
+                    ],
+                    declarations: [
+                        DbxSearchableChipFieldComponent,
+                        DbxSearchableTextFieldComponent,
+                        DbxSearchableFieldAutocompleteItemComponent,
+                        DbxDefaultSearchableFieldDisplayComponent,
+                        DbxDefaultSearchableAnchorFieldDisplayComponent
+                    ],
+                    exports: [
+                        DbxSearchableChipFieldComponent,
+                        DbxSearchableTextFieldComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,31 @@
+import { Component } from '@angular/core';
+import { AbstractDbxSearchableValueFieldDirective } from './searchable.field.directive';
+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 "@dereekb/dbx-web";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/forms";
+/**
+ * Display component for selecting a single item/value.
+ */
+export class DbxSearchableTextFieldComponent extends AbstractDbxSearchableValueFieldDirective {
+    constructor() {
+        super(...arguments);
+        this.multiSelect = false;
+    }
+    selected(event) {
+        const e = event;
+        this.addWithDisplayValue(e.option.value);
+    }
+}
+DbxSearchableTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableTextFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxSearchableTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxSearchableTextFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-searchable-text-field\">\n  <!-- Autocomplete -->\n  <mat-autocomplete #auto (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      <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\"\n        autocomplete=\"{{ autocomplete }}\">\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.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "context", "loading", "error"] }], directives: [{ type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.MatLabel, selector: "mat-label" }, { type: i7.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: i8.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: i8.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i8.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { type: i6.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "async": i6.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxSearchableTextFieldComponent, decorators: [{
+            type: Component,
+            args: [{ template: "<div class=\"dbx-searchable-text-field\">\n  <!-- Autocomplete -->\n  <mat-autocomplete #auto (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      <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\"\n        autocomplete=\"{{ autocomplete }}\">\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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