@dereekb/dbx-form 9.25.15 → 10.0.0

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

@@ -0,0 +1,278 @@
+import { convertMaybeToArray, lastValue, separateValues, asArray, filterUniqueValues } from '@dereekb/util';
+import { mergeDbxInjectionComponentConfigs } from '@dereekb/dbx-core';
+import { filterMaybe, SubscriptionObject, LoadingStateContextInstance, successResult, startWithBeginLoading } from '@dereekb/rxjs';
+import { ChangeDetectorRef, Directive, ElementRef, ViewChild } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { FieldType } from '@ngx-formly/material';
+import { debounceTime, distinctUntilChanged, first, map, mergeMap, shareReplay, startWith, switchMap, BehaviorSubject, of } from 'rxjs';
+import { DbxDefaultSearchableFieldDisplayComponent } from './searchable.field.autocomplete.item.component';
+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 {
+    get name() {
+        return this.field.name ?? camelCase(this.label ?? this.key);
+    }
+    get label() {
+        return this.props.label;
+    }
+    get readonly() {
+        return this.props.readonly;
+    }
+    get isReadonlyOrDisabled() {
+        return this.readonly || this.disabled;
+    }
+    get searchableField() {
+        return this.props;
+    }
+    get asArrayValue() {
+        return this.searchableField.asArrayValue ?? true;
+    }
+    get pickOnlyOne() {
+        return this.asArrayValue === false || this.multiSelect === false;
+    }
+    get searchOnEmptyText() {
+        return this.searchableField.searchOnEmptyText ?? false;
+    }
+    get autocomplete() {
+        return (this.props.attributes?.['autocomplete'] ?? this.key);
+    }
+    get hashForValue() {
+        return this.searchableField.hashForValue ?? ((x) => x);
+    }
+    get displayForValue() {
+        return this.searchableField.displayForValue;
+    }
+    get useAnchor() {
+        return this.searchableField.useAnchor;
+    }
+    get anchorForValue() {
+        return this.searchableField.anchorForValue;
+    }
+    get display() {
+        return this.searchableField.display;
+    }
+    get search() {
+        return this.searchableField.search;
+    }
+    get values() {
+        return this._getValueOnFormControl(this.formControl.value) ?? [];
+    }
+    get allowStringValues() {
+        return this.searchableField.allowStringValues ?? Boolean(this.convertStringValue);
+    }
+    get convertStringValue() {
+        return this.searchableField.convertStringValue;
+    }
+    get showClearValue() {
+        return this.searchableField.showClearValue ?? true;
+    }
+    get searchLabel() {
+        return this.searchableField.searchLabel ?? 'Search';
+    }
+    get refreshDisplayValues$() {
+        return this.searchableField.refreshDisplayValues$;
+    }
+    loadDisplayValuesForValues(values) {
+        return this.loadDisplayValuesForFieldValues(values.map((value) => ({ value })));
+    }
+    loadDisplayValuesForFieldValues(values) {
+        return this.getDisplayValuesForFieldValues(values).pipe(map((displayValues) => successResult(displayValues)), startWithBeginLoading(), 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 { 
+            //
+            included: hasDisplay, excluded: needsDisplay } = separateValues(mappingResult, (x) => Boolean(x[3]));
+            let obs;
+            if (needsDisplay.length > 0) {
+                // Go get the display value.
+                const displayValuesObs = this.displayForValue(needsDisplay.map((x) => x[2]));
+                const defaultDisplay = mergeDbxInjectionComponentConfigs([this.defaultDisplay, this.display]);
+                const anchorForValue = this.useAnchor && this.anchorForValue;
+                obs = displayValuesObs.pipe(first(), map((displayResults) => {
+                    // Assign the default component classes to complete configuration.
+                    displayResults.forEach((x) => {
+                        if (!x.display) {
+                            x.display = defaultDisplay;
+                        }
+                        else {
+                            x.display = mergeDbxInjectionComponentConfigs([defaultDisplay, x.display]);
+                        }
+                        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.
+                obs = of(hasDisplay.map((x) => x[3]));
+            }
+            return obs;
+        }));
+    }
+    constructor(cdRef) {
+        super();
+        this.cdRef = cdRef;
+        /**
+         * Whether or not to allow syncing to
+         */
+        this.allowSyncValueToInput = false;
+        this.inputCtrl = new FormControl('');
+        this._formControlObs = new BehaviorSubject(undefined);
+        this.formControl$ = this._formControlObs.pipe(filterMaybe());
+        this._clearDisplayHashMapSub = new SubscriptionObject();
+        this._displayHashMap = new BehaviorSubject(new Map());
+        this.inputValue$ = this.inputCtrl.valueChanges.pipe(startWith(this.inputCtrl.value), map((x) => x || ''));
+        this.inputValueString$ = this.inputValue$.pipe(debounceTime(200), distinctUntilChanged());
+        this.searchResultsState$ = this.inputValueString$.pipe(switchMap((text) => (text || this.searchOnEmptyText ? this.search(text ?? '') : of([])).pipe(switchMap((x) => this.loadDisplayValuesForFieldValues(x)), 
+        // Return begin loading to setup the loading state.
+        startWithBeginLoading())), shareReplay(1));
+        this._singleValueSyncSubscription = new SubscriptionObject();
+        this.searchContext = new LoadingStateContextInstance({ obs: this.searchResultsState$, showLoadingOnNoValue: false });
+        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 ?? []));
+    }
+    ngOnInit() {
+        this._formControlObs.next(this.formControl);
+        if (this.refreshDisplayValues$ != null) {
+            this._clearDisplayHashMapSub.subscription = this.refreshDisplayValues$.subscribe(() => this._displayHashMap.next(new Map()));
+        }
+        if (this.searchableField.textInputValidator) {
+            this.inputCtrl.setValidators(this.searchableField.textInputValidator);
+        }
+        if (!this.defaultDisplay?.componentClass) {
+            this.defaultDisplay = {
+                ...this.defaultDisplay,
+                componentClass: DbxDefaultSearchableFieldDisplayComponent
+            };
+        }
+        if (this.allowSyncValueToInput && this.multiSelect === false) {
+            this._singleValueSyncSubscription.subscription = this.displayValues$.subscribe((x) => {
+                if (x[0]) {
+                    this._syncSingleValue(x[0]);
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._clearDisplayHashMapSub.destroy();
+        this._displayHashMap.complete();
+        this._singleValueSyncSubscription.destroy();
+        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.searchableField.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);
+    }
+    _tryAddCurrentInputValue() {
+        let addedValue = false;
+        if (this.allowStringValues) {
+            const value = this.inputCtrl.value || '';
+            if ((value || '').trim()) {
+                this._addWithTextValue(value);
+                addedValue = true;
+            }
+        }
+        return addedValue;
+    }
+    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);
+    }
+    clearValues() {
+        this.setValues([]);
+    }
+    setValues(values) {
+        // Use to filter non-unique values.
+        if (this.hashForValue) {
+            values = filterUniqueValues(values, this.hashForValue);
+        }
+        if (this.pickOnlyOne) {
+            values = [lastValue(values)].filter((x) => x != null);
+        }
+        this._setValueOnFormControl(values);
+    }
+    // MARK: Internal
+    _getValueOnFormControl(valueOnFormControl) {
+        const value = valueOnFormControl != null ? asArray(valueOnFormControl) : []; // Always return an array.
+        return value;
+    }
+    _setValueOnFormControl(values) {
+        let newValue = values;
+        if (!this.asArrayValue) {
+            newValue = [values[0]].filter((x) => x != null)[0];
+        }
+        this.formControl.setValue(newValue);
+        this.formControl.markAsDirty();
+        this.formControl.markAsTouched();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AbstractDbxSearchableValueFieldDirective, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AbstractDbxSearchableValueFieldDirective, viewQueries: [{ propertyName: "textInput", first: true, predicate: ["textInput"], descendants: true }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AbstractDbxSearchableValueFieldDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, 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 { ArrayOrValue, Maybe, convertMaybeToArray, lastValue, PrimativeKey, separateValues, asArray, filterUniqueValues } from '@dereekb/util';\nimport { DbxInjectionComponentConfig, mergeDbxInjectionComponentConfigs } from '@dereekb/dbx-core';\nimport { filterMaybe, SubscriptionObject, LoadingState, LoadingStateContextInstance, successResult, startWithBeginLoading } from '@dereekb/rxjs';\nimport { ChangeDetectorRef, Directive, ElementRef, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { AbstractControl, FormControl, ValidatorFn } from '@angular/forms';\nimport { FieldTypeConfig, FormlyFieldProps } from '@ngx-formly/core';\nimport { FieldType } from '@ngx-formly/material';\nimport { debounceTime, distinctUntilChanged, first, map, mergeMap, shareReplay, startWith, switchMap, BehaviorSubject, of, Observable } from 'rxjs';\nimport { SearchableValueFieldHashFn, SearchableValueFieldStringSearchFn, SearchableValueFieldDisplayFn, SearchableValueFieldDisplayValue, SearchableValueFieldValue, SearchableValueFieldAnchorFn, ConfiguredSearchableValueFieldDisplayValue } from './searchable';\nimport { DbxDefaultSearchableFieldDisplayComponent } from './searchable.field.autocomplete.item.component';\nimport { camelCase } from 'change-case';\n\nexport interface StringValueFieldsFieldProps extends FormlyFieldProps {\n  /**\n   * Custom input validators.\n   */\n  textInputValidator?: ValidatorFn | ValidatorFn[];\n}\n\nexport interface SearchableValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends FormlyFieldProps, StringValueFieldsFieldProps {\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   * 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   * 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, H>;\n  /**\n   * Performs a search.\n   */\n  search: SearchableValueFieldStringSearchFn<T, M>;\n  /**\n   * Whether or not to allow searches on empty text. Is false by default.\n   */\n  searchOnEmptyText?: boolean;\n  /**\n   * Default injected config to use for display values.\n   */\n  display?: Partial<DbxInjectionComponentConfig>;\n  /**\n   * Used for building a display value given the input.\n   */\n  displayForValue: SearchableValueFieldDisplayFn<T, M>;\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, M>;\n  /**\n   * Whether or not to show \"Clear\" in the autcomplete list.\n   */\n  showClearValue?: boolean;\n  /**\n   * Label for the search input.\n   *\n   * Defaults to \"Search\"\n   */\n  searchLabel?: string;\n  /**\n   * (Optional) observable that will trigger the clearing of all cached display values.\n   */\n  refreshDisplayValues$?: Observable<unknown>;\n}\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, M = unknown, H extends PrimativeKey = PrimativeKey, C extends SearchableValueFieldsFieldProps<T, M, H> = SearchableValueFieldsFieldProps<T, M, H>> extends FieldType<FieldTypeConfig<C>> implements OnInit, OnDestroy {\n  /**\n   * Whether or not to allow syncing to\n   */\n  allowSyncValueToInput = false;\n\n  /**\n   * Whether or not to set/get values as an array.\n   */\n  abstract get multiSelect(): boolean;\n\n  /**\n   * Optional override set by the parent class for picking a default display for this directive.\n   */\n  defaultDisplay?: DbxInjectionComponentConfig;\n\n  @ViewChild('textInput')\n  textInput!: ElementRef<HTMLInputElement>;\n\n  readonly inputCtrl = new FormControl<string>('');\n\n  private readonly _formControlObs = new BehaviorSubject<Maybe<AbstractControl>>(undefined);\n  readonly formControl$ = this._formControlObs.pipe(filterMaybe());\n\n  private readonly _clearDisplayHashMapSub = new SubscriptionObject();\n  private readonly _displayHashMap = new BehaviorSubject<Map<H, ConfiguredSearchableValueFieldDisplayValue<T, M>>>(new Map());\n\n  readonly inputValue$: Observable<string> = this.inputCtrl.valueChanges.pipe(\n    startWith(this.inputCtrl.value),\n    map((x) => x || '')\n  );\n  readonly inputValueString$: Observable<string> = this.inputValue$.pipe(debounceTime(200), distinctUntilChanged());\n\n  readonly searchResultsState$: Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>> = this.inputValueString$.pipe(\n    switchMap((text) =>\n      (text || this.searchOnEmptyText ? this.search(text ?? '') : of([])).pipe(\n        switchMap((x) => this.loadDisplayValuesForFieldValues(x)),\n        // Return begin loading to setup the loading state.\n        startWithBeginLoading()\n      )\n    ),\n    shareReplay(1)\n  );\n\n  private readonly _singleValueSyncSubscription = new SubscriptionObject();\n\n  readonly searchContext = new LoadingStateContextInstance({ obs: this.searchResultsState$, showLoadingOnNoValue: false });\n\n  readonly searchResults$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]> = this.searchResultsState$.pipe(map((x) => x?.value ?? []));\n\n  readonly _formControlValue$: Observable<T | T[]> = this.formControl$.pipe(switchMap((control) => control.valueChanges.pipe(startWith(control.value), shareReplay(1))));\n\n  readonly values$: Observable<T[]> = this._formControlValue$.pipe(map(convertMaybeToArray), shareReplay(1));\n\n  readonly displayValuesState$: Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>> = this.values$.pipe(\n    distinctUntilChanged(),\n    switchMap((values: T[]) => this.loadDisplayValuesForValues(values)),\n    shareReplay(1)\n  );\n\n  readonly displayValues$: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]> = this.displayValuesState$.pipe(map((x) => x?.value ?? []));\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.props.label;\n  }\n\n  get readonly(): Maybe<boolean> {\n    return this.props.readonly;\n  }\n\n  get isReadonlyOrDisabled() {\n    return this.readonly || this.disabled;\n  }\n\n  get searchableField(): SearchableValueFieldsFieldProps<T, M, H> {\n    return this.props;\n  }\n\n  get asArrayValue(): boolean {\n    return this.searchableField.asArrayValue ?? true;\n  }\n\n  get pickOnlyOne(): boolean {\n    return this.asArrayValue === false || this.multiSelect === false;\n  }\n\n  get searchOnEmptyText(): boolean {\n    return this.searchableField.searchOnEmptyText ?? false;\n  }\n\n  get autocomplete(): string {\n    return (this.props.attributes?.['autocomplete'] ?? this.key) as string;\n  }\n\n  get hashForValue(): SearchableValueFieldHashFn<T, H> {\n    return this.searchableField.hashForValue ?? ((x) => x as unknown as H);\n  }\n\n  get displayForValue(): SearchableValueFieldDisplayFn<T, M> {\n    return this.searchableField.displayForValue;\n  }\n\n  get useAnchor(): Maybe<boolean> {\n    return this.searchableField.useAnchor;\n  }\n\n  get anchorForValue(): Maybe<SearchableValueFieldAnchorFn<T, M>> {\n    return this.searchableField.anchorForValue;\n  }\n\n  get display(): Maybe<Partial<DbxInjectionComponentConfig>> {\n    return this.searchableField.display;\n  }\n\n  get search(): SearchableValueFieldStringSearchFn<T, M> {\n    return this.searchableField.search;\n  }\n\n  get values(): T[] {\n    return this._getValueOnFormControl(this.formControl.value) ?? [];\n  }\n\n  get allowStringValues(): boolean {\n    return this.searchableField.allowStringValues ?? Boolean(this.convertStringValue);\n  }\n\n  get convertStringValue(): Maybe<(text: string) => T> {\n    return this.searchableField.convertStringValue;\n  }\n\n  get showClearValue(): boolean {\n    return this.searchableField.showClearValue ?? true;\n  }\n\n  get searchLabel() {\n    return this.searchableField.searchLabel ?? 'Search';\n  }\n\n  get refreshDisplayValues$() {\n    return this.searchableField.refreshDisplayValues$;\n  }\n\n  loadDisplayValuesForValues(values: T[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>> {\n    return this.loadDisplayValuesForFieldValues(values.map((value) => ({ value })));\n  }\n\n  loadDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<LoadingState<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>> {\n    return this.getDisplayValuesForFieldValues(values).pipe(\n      map((displayValues: ConfiguredSearchableValueFieldDisplayValue<T, M>[]) => successResult(displayValues)),\n      startWithBeginLoading(),\n      shareReplay(1)\n    );\n  }\n\n  getDisplayValuesForFieldValues(values: SearchableValueFieldValue<T, M>[]): Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]> {\n    return this._displayHashMap.pipe(\n      mergeMap((displayMap) => {\n        const mappingResult = values.map((x) => [x, this.hashForValue(x.value)] as [SearchableValueFieldValue<T, M>, H]).map(([x, hash], i) => [i, hash, x, displayMap.get(hash)] as [number, H, SearchableValueFieldValue<T, M>, ConfiguredSearchableValueFieldDisplayValue<T, M>]);\n\n        const {\n          //\n          included: hasDisplay,\n          excluded: needsDisplay\n        } = separateValues(mappingResult, (x) => Boolean(x[3]));\n\n        let obs: Observable<ConfiguredSearchableValueFieldDisplayValue<T, M>[]>;\n\n        if (needsDisplay.length > 0) {\n          // Go get the display value.\n          const displayValuesObs = this.displayForValue(needsDisplay.map((x) => x[2]));\n          const defaultDisplay = mergeDbxInjectionComponentConfigs([this.defaultDisplay, this.display]);\n          const anchorForValue = this.useAnchor && this.anchorForValue;\n\n          obs = displayValuesObs.pipe(\n            first(),\n            map((displayResults) => {\n              // Assign the default component classes to complete configuration.\n              displayResults.forEach((x) => {\n                if (!x.display) {\n                  x.display = defaultDisplay;\n                } else {\n                  x.display = mergeDbxInjectionComponentConfigs([defaultDisplay, x.display]);\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: [ConfiguredSearchableValueFieldDisplayValue<T, M>, H][] = (displayResults as ConfiguredSearchableValueFieldDisplayValue<T, M>[]).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          // If all display values are hashed return that.\n          obs = of(hasDisplay.map((x) => x[3]));\n        }\n\n        return obs;\n      })\n    );\n  }\n\n  constructor(readonly cdRef: ChangeDetectorRef) {\n    super();\n  }\n\n  ngOnInit(): void {\n    this._formControlObs.next(this.formControl);\n\n    if (this.refreshDisplayValues$ != null) {\n      this._clearDisplayHashMapSub.subscription = this.refreshDisplayValues$.subscribe(() => this._displayHashMap.next(new Map()));\n    }\n\n    if (this.searchableField.textInputValidator) {\n      this.inputCtrl.setValidators(this.searchableField.textInputValidator);\n    }\n\n    if (!this.defaultDisplay?.componentClass) {\n      this.defaultDisplay = {\n        ...this.defaultDisplay,\n        componentClass: DbxDefaultSearchableFieldDisplayComponent\n      };\n    }\n\n    if (this.allowSyncValueToInput && 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  override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this._clearDisplayHashMapSub.destroy();\n    this._displayHashMap.complete();\n    this._singleValueSyncSubscription.destroy();\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.searchableField.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 unknown 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  _tryAddCurrentInputValue(): boolean {\n    let addedValue = false;\n\n    if (this.allowStringValues) {\n      const value = this.inputCtrl.value || '';\n\n      if ((value || '').trim()) {\n        this._addWithTextValue(value);\n        addedValue = true;\n      }\n    }\n\n    return addedValue;\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  clearValues(): void {\n    this.setValues([]);\n  }\n\n  setValues(values: T[]): void {\n    // Use to filter non-unique values.\n    if (this.hashForValue) {\n      values = filterUniqueValues(values, this.hashForValue);\n    }\n\n    if (this.pickOnlyOne) {\n      values = [lastValue(values)].filter((x) => x != null);\n    }\n\n    this._setValueOnFormControl(values);\n  }\n\n  // MARK: Internal\n  protected _getValueOnFormControl(valueOnFormControl: ArrayOrValue<T>): T[] {\n    const value: T[] = valueOnFormControl != null ? asArray(valueOnFormControl) : []; // Always return an array.\n    return value;\n  }\n\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.markAsDirty();\n    this.formControl.markAsTouched();\n  }\n}\n"]}

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

@@ -0,0 +1,91 @@
+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 { DbxDefaultSearchableFieldDisplayComponent, DbxSearchableFieldAutocompleteItemComponent } from './searchable.field.autocomplete.item.component';
+import { DbxSearchableTextFieldComponent } from './searchable.text.field.component';
+import { DbxDatePipeModule, DbxInjectionComponentModule } from '@dereekb/dbx-core';
+import { DbxRouterAnchorModule, DbxTextModule, DbxLoadingModule, DbxButtonModule } from '@dereekb/dbx-web';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+export class DbxFormFormlySearchableFieldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DbxFormFormlySearchableFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: DbxFormFormlySearchableFieldModule, declarations: [DbxSearchableChipFieldComponent, DbxSearchableTextFieldComponent, DbxSearchableFieldAutocompleteItemComponent, DbxDefaultSearchableFieldDisplayComponent], imports: [CommonModule,
+            DbxTextModule,
+            DbxLoadingModule,
+            DbxButtonModule,
+            FormsModule,
+            MatButtonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatListModule,
+            DbxDatePipeModule,
+            DbxRouterAnchorModule,
+            MatChipsModule,
+            MatIconModule,
+            DbxInjectionComponentModule, i1.FormlyModule], exports: [DbxSearchableChipFieldComponent, DbxSearchableTextFieldComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DbxFormFormlySearchableFieldModule, imports: [CommonModule,
+            DbxTextModule,
+            DbxLoadingModule,
+            DbxButtonModule,
+            FormsModule,
+            MatButtonModule,
+            MatInputModule,
+            MatFormFieldModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule,
+            MatListModule,
+            DbxDatePipeModule,
+            DbxRouterAnchorModule,
+            MatChipsModule,
+            MatIconModule,
+            DbxInjectionComponentModule,
+            FormlyModule.forChild({
+                types: [
+                    { name: 'searchablechipfield', component: DbxSearchableChipFieldComponent, wrappers: ['form-field'] },
+                    { name: 'searchabletextfield', component: DbxSearchableTextFieldComponent, wrappers: ['form-field'] }
+                ]
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DbxFormFormlySearchableFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        DbxTextModule,
+                        DbxLoadingModule,
+                        DbxButtonModule,
+                        FormsModule,
+                        MatButtonModule,
+                        MatInputModule,
+                        MatFormFieldModule,
+                        ReactiveFormsModule,
+                        MatAutocompleteModule,
+                        MatListModule,
+                        DbxDatePipeModule,
+                        DbxRouterAnchorModule,
+                        MatChipsModule,
+                        MatIconModule,
+                        DbxInjectionComponentModule,
+                        FormlyModule.forChild({
+                            types: [
+                                { name: 'searchablechipfield', component: DbxSearchableChipFieldComponent, wrappers: ['form-field'] },
+                                { name: 'searchabletextfield', component: DbxSearchableTextFieldComponent, wrappers: ['form-field'] }
+                            ]
+                        })
+                    ],
+                    declarations: [DbxSearchableChipFieldComponent, DbxSearchableTextFieldComponent, DbxSearchableFieldAutocompleteItemComponent, DbxDefaultSearchableFieldDisplayComponent],
+                    exports: [DbxSearchableChipFieldComponent, DbxSearchableTextFieldComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/formly/field/selection/searchable/searchable.text.field.component.mjs

@@ -47,11 +47,11 @@ export class DbxSearchableTextFieldComponent extends AbstractDbxSearchableValueF
     selected(event) {
         this.addWithDisplayValue(event.option.value);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DbxSearchableTextFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: DbxSearchableTextFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-searchable-text-field\" [ngClass]=\"{ 'dbx-searchable-text-field-has-value': (hasValue$ | async), 'dbx-searchable-text-field-show-value': showSelectedValue }\">\n  <!-- Result View -->\n  <div class=\"dbx-searchable-text-field-value mat-option mat-option-text\" *ngIf=\"showSelectedDisplayValue$ | async\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"(selectedDisplayValue$ | async)!\"></dbx-searchable-field-autocomplete-item>\n  </div>\n  <div class=\"dbx-searchable-text-field-input\">\n    <div *ngIf=\"searchLabel\" class=\"dbx-label\">{{ searchLabel }}</div>\n    <!-- View -->\n    <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\" [matAutocompleteDisabled]=\"readonly\" autocomplete=\"{{ autocomplete }}\" />\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </div>\n</div>\n\n<!-- Autocomplete -->\n<mat-autocomplete class=\"dbx-searchable-text-field-autocomplete\" #auto (optionSelected)=\"selected($event)\">\n  <mat-option *ngFor=\"let displayValue of searchResults$ | async\" [value]=\"displayValue\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\"></dbx-searchable-field-autocomplete-item>\n  </mat-option>\n  <!-- Add/Pick String Value -->\n  <mat-option *ngIf=\"allowStringValues && (inputValue$ | async)\" [value]=\"{ value: (inputValue$ | async) }\">\n    <p class=\"dbx-clear-hint text-center\">\"{{ inputValue$ | async }}\"</p>\n  </mat-option>\n  <!-- Show clear value -->\n  <mat-option *ngIf=\"showClearValue && (hasValue$ | async)\" value=\"\">\n    <p class=\"dbx-clear-hint text-center\">Clear</p>\n  </mat-option>\n</mat-autocomplete>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "padding", "context", "loading", "error"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.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"] }, { kind: "directive", type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple", "hideSingleSelectionIndicator"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "directive", type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i7.DbxSearchableFieldAutocompleteItemComponent, selector: "dbx-searchable-field-autocomplete-item", inputs: ["displayValue"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }] }); }
 }
-DbxSearchableTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxSearchableTextFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-DbxSearchableTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxSearchableTextFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-searchable-text-field\" [ngClass]=\"{ 'dbx-searchable-text-field-has-value': (hasValue$ | async), 'dbx-searchable-text-field-show-value': showSelectedValue }\">\n  <!-- Result View -->\n  <div class=\"dbx-searchable-text-field-value mat-option mat-option-text\" *ngIf=\"showSelectedDisplayValue$ | async\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"(selectedDisplayValue$ | async)!\"></dbx-searchable-field-autocomplete-item>\n  </div>\n  <div class=\"dbx-searchable-text-field-input\">\n    <div *ngIf=\"searchLabel\" class=\"dbx-label\">{{ searchLabel }}</div>\n    <!-- View -->\n    <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\" [matAutocompleteDisabled]=\"readonly\" autocomplete=\"{{ autocomplete }}\" />\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </div>\n</div>\n\n<!-- Autocomplete -->\n<mat-autocomplete class=\"dbx-searchable-text-field-autocomplete\" #auto (optionSelected)=\"selected($event)\">\n  <mat-option *ngFor=\"let displayValue of searchResults$ | async\" [value]=\"displayValue\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\"></dbx-searchable-field-autocomplete-item>\n  </mat-option>\n  <!-- Add/Pick String Value -->\n  <mat-option *ngIf=\"allowStringValues && (inputValue$ | async)\" [value]=\"{ value: (inputValue$ | async) }\">\n    <p class=\"dbx-clear-hint text-center\">\"{{ inputValue$ | async }}\"</p>\n  </mat-option>\n  <!-- Show clear value -->\n  <mat-option *ngIf=\"showClearValue && (hasValue$ | async)\" value=\"\">\n    <p class=\"dbx-clear-hint text-center\">Clear</p>\n  </mat-option>\n</mat-autocomplete>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "padding", "context", "loading", "error"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.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"] }, { kind: "directive", type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { kind: "directive", type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "component", type: i7.DbxSearchableFieldAutocompleteItemComponent, selector: "dbx-searchable-field-autocomplete-item", inputs: ["displayValue"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxSearchableTextFieldComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DbxSearchableTextFieldComponent, decorators: [{
             type: Component,
             args: [{ template: "<div class=\"dbx-searchable-text-field\" [ngClass]=\"{ 'dbx-searchable-text-field-has-value': (hasValue$ | async), 'dbx-searchable-text-field-show-value': showSelectedValue }\">\n  <!-- Result View -->\n  <div class=\"dbx-searchable-text-field-value mat-option mat-option-text\" *ngIf=\"showSelectedDisplayValue$ | async\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"(selectedDisplayValue$ | async)!\"></dbx-searchable-field-autocomplete-item>\n  </div>\n  <div class=\"dbx-searchable-text-field-input\">\n    <div *ngIf=\"searchLabel\" class=\"dbx-label\">{{ searchLabel }}</div>\n    <!-- View -->\n    <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\" [matAutocompleteDisabled]=\"readonly\" autocomplete=\"{{ autocomplete }}\" />\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </div>\n</div>\n\n<!-- Autocomplete -->\n<mat-autocomplete class=\"dbx-searchable-text-field-autocomplete\" #auto (optionSelected)=\"selected($event)\">\n  <mat-option *ngFor=\"let displayValue of searchResults$ | async\" [value]=\"displayValue\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\"></dbx-searchable-field-autocomplete-item>\n  </mat-option>\n  <!-- Add/Pick String Value -->\n  <mat-option *ngIf=\"allowStringValues && (inputValue$ | async)\" [value]=\"{ value: (inputValue$ | async) }\">\n    <p class=\"dbx-clear-hint text-center\">\"{{ inputValue$ | async }}\"</p>\n  </mat-option>\n  <!-- Show clear value -->\n  <mat-option *ngIf=\"showClearValue && (hasValue$ | async)\" value=\"\">\n    <p class=\"dbx-clear-hint text-center\">Clear</p>\n  </mat-option>\n</mat-autocomplete>\n" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchable.text.field.component.js","sourceRoot":"","sources":["../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/searchable/searchable.text.field.component.ts","../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/searchable/searchable.text.field.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,SAAS,EAAqB,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,wCAAwC,EAAmC,MAAM,8BAA8B,CAAC;AACzH,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;;;;;;;;;AAOrD;;GAEG;AAIH,MAAM,OAAO,+BAAuF,SAAQ,wCAA+F;IAH3M;;QAIW,0BAAqB,GAAG,IAAI,CAAC;QAE7B,0BAAqB,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CACvD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAChB,WAAW,CAAC,CAAC,CAAC,EACd,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAC7B,CAAC;QAEO,cAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,8BAAyB,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAClE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,EAChD,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,EACd,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAC7B,CAAC;QAcM,mBAAc,GAAG,IAAI,kBAAkB,EAAE,CAAC;KAoBnD;IAhCC,IAAa,eAAe;QAC1B,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,6DAA6D;IACzI,CAAC;IAED,IAAI,WAAW;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IAIQ,QAAQ;QACf,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,IAAI,CAAC,cAAc,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7F,IAAI,CAAC,CAAC,EAAE;gBACN,sBAAsB;aACvB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,WAAW;QAClB,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAED,QAAQ,CAAC,KAAmC;QAC1C,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;;6HAhDU,+BAA+B;iHAA/B,+BAA+B,2EClB5C,6xDA6BA;4FDXa,+BAA+B;kBAH3C,SAAS","sourcesContent":["import { SubscriptionObject } from '@dereekb/rxjs';\nimport { Component, OnDestroy, OnInit } from '@angular/core';\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\nimport { AbstractDbxSearchableValueFieldDirective, SearchableValueFieldsFieldProps } from './searchable.field.directive';\nimport { map, shareReplay, skipWhile, distinctUntilChanged } from 'rxjs';\nimport { tapDetectChanges } from '@dereekb/dbx-core';\nimport { PrimativeKey } from '@dereekb/util';\n\nexport interface SearchableTextValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends SearchableValueFieldsFieldProps<T, M, H> {\n  showSelectedValue?: boolean;\n}\n\n/**\n * Display component for selecting a single item/value.\n */\n@Component({\n  templateUrl: 'searchable.text.field.component.html'\n})\nexport class DbxSearchableTextFieldComponent<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractDbxSearchableValueFieldDirective<T, M, H, SearchableTextValueFieldsFieldProps<T, M, H>> implements OnInit, OnDestroy {\n  override allowSyncValueToInput = true;\n\n  readonly selectedDisplayValue$ = this.displayValues$.pipe(\n    map((x) => x[0]),\n    shareReplay(1),\n    tapDetectChanges(this.cdRef)\n  );\n\n  readonly hasValue$ = this.selectedDisplayValue$.pipe(map((x) => Boolean(x)));\n  readonly showSelectedDisplayValue$ = this.selectedDisplayValue$.pipe(\n    map((x) => this.showSelectedValue && Boolean(x)),\n    distinctUntilChanged(),\n    shareReplay(1),\n    tapDetectChanges(this.cdRef)\n  );\n\n  override get searchableField(): SearchableTextValueFieldsFieldProps<T, M, H> {\n    return this.props;\n  }\n\n  get showSelectedValue() {\n    return this.searchableField.showSelectedValue ?? !this.allowStringValues; // Show the selected value only if string values are allowed.\n  }\n\n  get multiSelect() {\n    return false;\n  }\n\n  private _clearInputSub = new SubscriptionObject();\n\n  override ngOnInit(): void {\n    super.ngOnInit();\n\n    this._clearInputSub.subscription = this.inputValue$.pipe(skipWhile((x) => !x)).subscribe((x) => {\n      if (!x) {\n        // this.clearValues();\n      }\n    });\n  }\n\n  override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this._clearInputSub.destroy();\n  }\n\n  selected(event: MatAutocompleteSelectedEvent): void {\n    this.addWithDisplayValue(event.option.value);\n  }\n}\n","<div class=\"dbx-searchable-text-field\" [ngClass]=\"{ 'dbx-searchable-text-field-has-value': (hasValue$ | async), 'dbx-searchable-text-field-show-value': showSelectedValue }\">\n  <!-- Result View -->\n  <div class=\"dbx-searchable-text-field-value mat-option mat-option-text\" *ngIf=\"showSelectedDisplayValue$ | async\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"(selectedDisplayValue$ | async)!\"></dbx-searchable-field-autocomplete-item>\n  </div>\n  <div class=\"dbx-searchable-text-field-input\">\n    <div *ngIf=\"searchLabel\" class=\"dbx-label\">{{ searchLabel }}</div>\n    <!-- View -->\n    <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\" [matAutocompleteDisabled]=\"readonly\" autocomplete=\"{{ autocomplete }}\" />\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </div>\n</div>\n\n<!-- Autocomplete -->\n<mat-autocomplete class=\"dbx-searchable-text-field-autocomplete\" #auto (optionSelected)=\"selected($event)\">\n  <mat-option *ngFor=\"let displayValue of searchResults$ | async\" [value]=\"displayValue\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\"></dbx-searchable-field-autocomplete-item>\n  </mat-option>\n  <!-- Add/Pick String Value -->\n  <mat-option *ngIf=\"allowStringValues && (inputValue$ | async)\" [value]=\"{ value: (inputValue$ | async) }\">\n    <p class=\"dbx-clear-hint text-center\">\"{{ inputValue$ | async }}\"</p>\n  </mat-option>\n  <!-- Show clear value -->\n  <mat-option *ngIf=\"showClearValue && (hasValue$ | async)\" value=\"\">\n    <p class=\"dbx-clear-hint text-center\">Clear</p>\n  </mat-option>\n</mat-autocomplete>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchable.text.field.component.js","sourceRoot":"","sources":["../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/searchable/searchable.text.field.component.ts","../../../../../../../../../packages/dbx-form/src/lib/formly/field/selection/searchable/searchable.text.field.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,SAAS,EAAqB,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,wCAAwC,EAAmC,MAAM,8BAA8B,CAAC;AACzH,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;;;;;;;;;AAOrD;;GAEG;AAIH,MAAM,OAAO,+BAAuF,SAAQ,wCAA+F;IAH3M;;QAIW,0BAAqB,GAAG,IAAI,CAAC;QAE7B,0BAAqB,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CACvD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAChB,WAAW,CAAC,CAAC,CAAC,EACd,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAC7B,CAAC;QAEO,cAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,8BAAyB,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAClE,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,EAChD,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,EACd,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAC7B,CAAC;QAcM,mBAAc,GAAG,IAAI,kBAAkB,EAAE,CAAC;KAoBnD;IAhCC,IAAa,eAAe;QAC1B,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,6DAA6D;IACzI,CAAC;IAED,IAAI,WAAW;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IAIQ,QAAQ;QACf,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,IAAI,CAAC,cAAc,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YAC7F,IAAI,CAAC,CAAC,EAAE;gBACN,sBAAsB;aACvB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,WAAW;QAClB,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAED,QAAQ,CAAC,KAAmC;QAC1C,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;+GAhDU,+BAA+B;mGAA/B,+BAA+B,2EClB5C,6xDA6BA;;4FDXa,+BAA+B;kBAH3C,SAAS","sourcesContent":["import { SubscriptionObject } from '@dereekb/rxjs';\nimport { Component, OnDestroy, OnInit } from '@angular/core';\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\nimport { AbstractDbxSearchableValueFieldDirective, SearchableValueFieldsFieldProps } from './searchable.field.directive';\nimport { map, shareReplay, skipWhile, distinctUntilChanged } from 'rxjs';\nimport { tapDetectChanges } from '@dereekb/dbx-core';\nimport { PrimativeKey } from '@dereekb/util';\n\nexport interface SearchableTextValueFieldsFieldProps<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends SearchableValueFieldsFieldProps<T, M, H> {\n  showSelectedValue?: boolean;\n}\n\n/**\n * Display component for selecting a single item/value.\n */\n@Component({\n  templateUrl: 'searchable.text.field.component.html'\n})\nexport class DbxSearchableTextFieldComponent<T, M = unknown, H extends PrimativeKey = PrimativeKey> extends AbstractDbxSearchableValueFieldDirective<T, M, H, SearchableTextValueFieldsFieldProps<T, M, H>> implements OnInit, OnDestroy {\n  override allowSyncValueToInput = true;\n\n  readonly selectedDisplayValue$ = this.displayValues$.pipe(\n    map((x) => x[0]),\n    shareReplay(1),\n    tapDetectChanges(this.cdRef)\n  );\n\n  readonly hasValue$ = this.selectedDisplayValue$.pipe(map((x) => Boolean(x)));\n  readonly showSelectedDisplayValue$ = this.selectedDisplayValue$.pipe(\n    map((x) => this.showSelectedValue && Boolean(x)),\n    distinctUntilChanged(),\n    shareReplay(1),\n    tapDetectChanges(this.cdRef)\n  );\n\n  override get searchableField(): SearchableTextValueFieldsFieldProps<T, M, H> {\n    return this.props;\n  }\n\n  get showSelectedValue() {\n    return this.searchableField.showSelectedValue ?? !this.allowStringValues; // Show the selected value only if string values are allowed.\n  }\n\n  get multiSelect() {\n    return false;\n  }\n\n  private _clearInputSub = new SubscriptionObject();\n\n  override ngOnInit(): void {\n    super.ngOnInit();\n\n    this._clearInputSub.subscription = this.inputValue$.pipe(skipWhile((x) => !x)).subscribe((x) => {\n      if (!x) {\n        // this.clearValues();\n      }\n    });\n  }\n\n  override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this._clearInputSub.destroy();\n  }\n\n  selected(event: MatAutocompleteSelectedEvent): void {\n    this.addWithDisplayValue(event.option.value);\n  }\n}\n","<div class=\"dbx-searchable-text-field\" [ngClass]=\"{ 'dbx-searchable-text-field-has-value': (hasValue$ | async), 'dbx-searchable-text-field-show-value': showSelectedValue }\">\n  <!-- Result View -->\n  <div class=\"dbx-searchable-text-field-value mat-option mat-option-text\" *ngIf=\"showSelectedDisplayValue$ | async\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"(selectedDisplayValue$ | async)!\"></dbx-searchable-field-autocomplete-item>\n  </div>\n  <div class=\"dbx-searchable-text-field-input\">\n    <div *ngIf=\"searchLabel\" class=\"dbx-label\">{{ searchLabel }}</div>\n    <!-- View -->\n    <input type=\"search\" [name]=\"name\" matInput #textInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" [matAutocomplete]=\"auto\" [matAutocompleteDisabled]=\"readonly\" autocomplete=\"{{ autocomplete }}\" />\n    <div class=\"searchable-field-form-loading\">\n      <dbx-loading [linear]=\"true\" [context]=\"searchContext\"></dbx-loading>\n    </div>\n  </div>\n</div>\n\n<!-- Autocomplete -->\n<mat-autocomplete class=\"dbx-searchable-text-field-autocomplete\" #auto (optionSelected)=\"selected($event)\">\n  <mat-option *ngFor=\"let displayValue of searchResults$ | async\" [value]=\"displayValue\">\n    <dbx-searchable-field-autocomplete-item [displayValue]=\"displayValue\"></dbx-searchable-field-autocomplete-item>\n  </mat-option>\n  <!-- Add/Pick String Value -->\n  <mat-option *ngIf=\"allowStringValues && (inputValue$ | async)\" [value]=\"{ value: (inputValue$ | async) }\">\n    <p class=\"dbx-clear-hint text-center\">\"{{ inputValue$ | async }}\"</p>\n  </mat-option>\n  <!-- Show clear value -->\n  <mat-option *ngIf=\"showClearValue && (hasValue$ | async)\" value=\"\">\n    <p class=\"dbx-clear-hint text-center\">Clear</p>\n  </mat-option>\n</mat-autocomplete>\n"]}

package/esm2022/lib/formly/field/selection/selection.field.mjs

@@ -0,0 +1,39 @@
+import { asObservable } from '@dereekb/rxjs';
+import { convertMaybeToArray, firstValue } from '@dereekb/util';
+import { map } from 'rxjs';
+import { formlyField, propsAndConfigForFieldConfig } from '../field';
+export function valueSelectionField(config) {
+    const { key, native = false, addClearOption = false, selectAllOption: inputSelectAllOption, options: inputOptions, materialFormField } = config;
+    let selectAllOptionConfig;
+    if (inputSelectAllOption) {
+        selectAllOptionConfig = {
+            selectAllOption: typeof inputSelectAllOption === 'boolean' ? 'Select All' : inputSelectAllOption
+        };
+    }
+    const options = addClearOption ? asObservable(inputOptions).pipe(map(addValueSelectionOptionFunction(typeof addClearOption === 'string' ? addClearOption : undefined))) : inputOptions;
+    let parsers = undefined;
+    parsers = config.multiple !== true ? [firstValue] : [convertMaybeToArray];
+    return formlyField({
+        key,
+        type: native ? 'native-select' : 'select',
+        ...propsAndConfigForFieldConfig(config, {
+            ...materialFormField,
+            options,
+            multiple: config.multiple,
+            ...selectAllOptionConfig
+        }),
+        parsers
+    });
+}
+export function addValueSelectionOptionFunction(label) {
+    return (options) => {
+        const hasClear = options.findIndex((x) => x.clear) !== -1;
+        if (hasClear) {
+            return options;
+        }
+        else {
+            return [{ label, clear: true }, ...options];
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/formly/field/selection/selection.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vc3JjL2xpYi9mb3JtbHkvZmllbGQvc2VsZWN0aW9uL3NlbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJpbWF0aXZlS2V5LCBNYXliZSwgTWFwRnVuY3Rpb24sIExhYmVsUmVmIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VsZWN0aW9uVmFsdWU8VCwgTSA9IHVua25vd24+IHtcbiAgLyoqXG4gICAqIFZhbHVlIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGZpZWxkLlxuICAgKi9cbiAgdmFsdWU6IFQ7XG4gIC8qKlxuICAgKiBPcHRpb25hbCBtZXRhZGF0YSBvbiB0aGUgZmllbGQuXG4gICAqL1xuICBtZXRhPzogTWF5YmU8TT47XG59XG5cbi8qKlxuICogRGlzcGxheWVkIHZhbHVlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNlbGVjdGlvbkRpc3BsYXlWYWx1ZTxULCBNID0gdW5rbm93bj4gZXh0ZW5kcyBTZWxlY3Rpb25WYWx1ZTxULCBNPiwgTGFiZWxSZWYge1xuICBzdWJsYWJlbD86IHN0cmluZztcbiAgaWNvbj86IHN0cmluZztcbiAgLyoqXG4gICAqIFdoZXRoZXIgb3Igbm90IHRoZSB2YWx1ZSBpcyBrbm93bi5cbiAgICovXG4gIGlzVW5rbm93bj86IE1heWJlPGJvb2xlYW4+O1xufVxuXG4vKipcbiAqIFVzZWQgdG8gaGFzaCB0aGUgdmFsdWUgZnJvbSB0aGUgaW5wdXQgcGlja2FibGUgdmFsdWUuXG4gKi9cbmV4cG9ydCB0eXBlIFNlbGVjdGlvblZhbHVlSGFzaEZ1bmN0aW9uPFQsIEggZXh0ZW5kcyBQcmltYXRpdmVLZXkgPSBQcmltYXRpdmVLZXk+ID0gTWFwRnVuY3Rpb248VCwgSD47XG5cbi8vIE1BUks6IENvbXBhdFxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2UgU2VsZWN0aW9uVmFsdWVIYXNoRnVuY3Rpb25cbiAqL1xuZXhwb3J0IHR5cGUgU2VsZWN0aW9uVmFsdWVIYXNoRm48VCwgSCBleHRlbmRzIFByaW1hdGl2ZUtleSA9IFByaW1hdGl2ZUtleT4gPSBTZWxlY3Rpb25WYWx1ZUhhc2hGdW5jdGlvbjxULCBIPjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vc3JjL2xpYi9mb3JtbHkvZmllbGQvc2VsZWN0aW9uL3NlbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJpbWF0aXZlS2V5LCBNYXliZSwgTWFwRnVuY3Rpb24sIExhYmVsUmVmIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VsZWN0aW9uVmFsdWU8VCwgTSA9IHVua25vd24+IHtcbiAgLyoqXG4gICAqIFZhbHVlIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGZpZWxkLlxuICAgKi9cbiAgdmFsdWU6IFQ7XG4gIC8qKlxuICAgKiBPcHRpb25hbCBtZXRhZGF0YSBvbiB0aGUgZmllbGQuXG4gICAqL1xuICBtZXRhPzogTWF5YmU8TT47XG59XG5cbi8qKlxuICogRGlzcGxheWVkIHZhbHVlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNlbGVjdGlvbkRpc3BsYXlWYWx1ZTxULCBNID0gdW5rbm93bj4gZXh0ZW5kcyBTZWxlY3Rpb25WYWx1ZTxULCBNPiwgTGFiZWxSZWYge1xuICBzdWJsYWJlbD86IHN0cmluZztcbiAgaWNvbj86IHN0cmluZztcbiAgLyoqXG4gICAqIFdoZXRoZXIgb3Igbm90IHRoZSB2YWx1ZSBpcyBrbm93bi5cbiAgICovXG4gIGlzVW5rbm93bj86IE1heWJlPGJvb2xlYW4+O1xufVxuXG4vKipcbiAqIFVzZWQgdG8gaGFzaCB0aGUgdmFsdWUgZnJvbSB0aGUgaW5wdXQgcGlja2FibGUgdmFsdWUuXG4gKi9cbmV4cG9ydCB0eXBlIFNlbGVjdGlvblZhbHVlSGFzaEZ1bmN0aW9uPFQsIEggZXh0ZW5kcyBQcmltYXRpdmVLZXkgPSBQcmltYXRpdmVLZXk+ID0gTWFwRnVuY3Rpb248VCwgSD47XG4iXX0=