@bizdoc/core 1.13.12 → 1.13.16

package/esm2020/lib/core/controls/address.input.mjs

@@ -0,0 +1,193 @@
+import { Component, Input, HostBinding, Optional, Self, EventEmitter, Output, ViewChild } from '@angular/core';
+import { FormControl, Validators } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import { isObject } from '../functions';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "@angular/material/autocomplete";
+import * as i4 from "@angular/material/core";
+import * as i5 from "@angular/material/input";
+import * as i6 from "@angular/common";
+const DEBOUNCE_TIME = 250;
+export class AddressInput {
+    constructor(ngControl, _fm, _elRef) {
+        this.ngControl = ngControl;
+        this._fm = _fm;
+        this._elRef = _elRef;
+        this._required = false;
+        this._disabled = false;
+        this.control = new FormControl();
+        this.stateChanges = new Subject();
+        this.id = `address-input-${AddressInput.nextId++}`;
+        this.optionSelected = new EventEmitter();
+        this.debounce = DEBOUNCE_TIME;
+        this.focused = false;
+        this.errorState = false;
+        this.controlType = 'bizdoc-address-input';
+        this.describedBy = '';
+        this._destroy = new Subject();
+        if (this.ngControl != null) {
+            this.ngControl.valueAccessor = this;
+        }
+        _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {
+            this.focused = !!origin;
+            this.stateChanges.next();
+        });
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(plh) {
+        this._placeholder = plh;
+        this.stateChanges.next();
+    }
+    get empty() { return !this.control.value; }
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    get required() {
+        return this._required;
+    }
+    set required(req) {
+        this._required = req;
+        if (req)
+            this.control.setValidators(Validators.required);
+        else
+            this.control.clearValidators();
+        this.stateChanges.next();
+    }
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        if (this.control.disabled !== this._disabled) {
+            if (value)
+                this.control.disable();
+            else
+                this.control.enable();
+        }
+        this.stateChanges.next();
+    }
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(' ');
+    }
+    onContainerClick() {
+        this.inputElement.nativeElement.focus();
+    }
+    writeValue(val) {
+        this._setValue(val, false);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(val) {
+        this._setValue(val, true);
+        this.stateChanges.next();
+    }
+    _setValue(val, emitEvent) {
+        this._value = val;
+        this.control.setValue(val ? { description: val } : null, { emitEvent });
+    }
+    onFocus() {
+        this.focused = true;
+        this._onTouched && this._onTouched();
+    }
+    onBlur() {
+        this.focused = false;
+    }
+    displayFn(address) {
+        return isObject(address) ? address.description : address;
+    }
+    selected(e) {
+        const address = e.option.value;
+        this._onChange(address.description);
+        this.optionSelected.emit({ address: address.description, placeId: address.place_id });
+    }
+    focus() {
+        this.inputElement.nativeElement.focus();
+    }
+    ngOnInit() {
+        const service = new google.maps.places.AutocompleteService();
+        this.control.valueChanges.pipe(debounceTime(this.debounce), takeUntil(this._destroy)).subscribe(input => {
+            service.getQueryPredictions({ input }, (r, s) => {
+                if (s === google.maps.places.PlacesServiceStatus.OK)
+                    this._addresses = r;
+                else
+                    console.log(`address google api error code: ${s}`);
+            });
+        });
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        this._fm.stopMonitoring(this._elRef.nativeElement);
+        this.stateChanges.complete();
+    }
+}
+AddressInput.nextId = 0;
+AddressInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: AddressInput, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: i2.FocusMonitor }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+AddressInput.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: AddressInput, selector: "bizdoc-address", inputs: { debounce: "debounce", placeholder: "placeholder", required: "required", disabled: "disabled", value: "value" }, outputs: { optionSelected: "optionSelected" }, host: { properties: { "class.floating": "shouldLabelFloat", "attr.aria-describedby": "this.describedBy", "id": "this.id" } }, providers: [{ provide: MatFormFieldControl, useExisting: AddressInput }], viewQueries: [{ propertyName: "inputElement", first: true, predicate: ["input"], descendants: true, static: true }], ngImport: i0, template: `<div class="address-container">
+    <input matInput [matAutocomplete]="address" [formControl]="control" [placeholder]="placeholder" #input
+      (focus)="onFocus()" (blur)="onBlur()"/>
+    <mat-autocomplete #address (optionSelected)="selected($event)" [displayWith]="displayFn">
+      <mat-option *ngFor="let a of _addresses" [value]="a">
+        <span matLine>{{a.description}}</span>
+      </mat-option>
+    </mat-autocomplete></div>`, isInline: true, styles: [".address-container{display:flex}\n"], components: [{ type: i3.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i4.MatOption, selector: "mat-option", exportAs: ["matOption"] }], directives: [{ type: i5.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: i3.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i1.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.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.MatLine, selector: "[mat-line], [matLine]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: AddressInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-address',
+                    providers: [{ provide: MatFormFieldControl, useExisting: AddressInput }],
+                    template: `<div class="address-container">
+    <input matInput [matAutocomplete]="address" [formControl]="control" [placeholder]="placeholder" #input
+      (focus)="onFocus()" (blur)="onBlur()"/>
+    <mat-autocomplete #address (optionSelected)="selected($event)" [displayWith]="displayFn">
+      <mat-option *ngFor="let a of _addresses" [value]="a">
+        <span matLine>{{a.description}}</span>
+      </mat-option>
+    </mat-autocomplete></div>`,
+                    styles: ['.address-container {display: flex}'],
+                    host: {
+                        '[class.floating]': 'shouldLabelFloat',
+                        '[attr.aria-describedby]': 'describedBy'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i2.FocusMonitor }, { type: i0.ElementRef }]; }, propDecorators: { id: [{
+                type: HostBinding
+            }], inputElement: [{
+                type: ViewChild,
+                args: ['input', { static: true }]
+            }], optionSelected: [{
+                type: Output
+            }], debounce: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], describedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"address.input.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/controls/address.input.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, HostBinding, Optional, Self, OnInit, ElementRef, EventEmitter, Output, ViewChild } from '@angular/core';\r\nimport { NgControl, ControlValueAccessor, FormControl, Validators } from '@angular/forms';\r\nimport { Subject } from 'rxjs';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';\r\nimport { debounceTime, takeUntil } from 'rxjs/operators';\r\nimport { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { isObject } from '../functions';\r\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nconst DEBOUNCE_TIME = 250;\r\n@Component({\r\n  selector: 'bizdoc-address',\r\n  providers: [{ provide: MatFormFieldControl, useExisting: AddressInput }],\r\n  template: `<div class=\"address-container\">\r\n    <input matInput [matAutocomplete]=\"address\" [formControl]=\"control\" [placeholder]=\"placeholder\" #input\r\n      (focus)=\"onFocus()\" (blur)=\"onBlur()\"/>\r\n    <mat-autocomplete #address (optionSelected)=\"selected($event)\" [displayWith]=\"displayFn\">\r\n      <mat-option *ngFor=\"let a of _addresses\" [value]=\"a\">\r\n        <span matLine>{{a.description}}</span>\r\n      </mat-option>\r\n    </mat-autocomplete></div>`,\r\n  styles: ['.address-container {display: flex}'],\r\n  host: {\r\n    '[class.floating]': 'shouldLabelFloat',\r\n    '[attr.aria-describedby]': 'describedBy'\r\n  }\r\n})\r\nexport\r\n  class AddressInput implements MatFormFieldControl<string>, ControlValueAccessor, OnDestroy, OnInit {\r\n  private static nextId = 0;\r\n  private _placeholder: string;\r\n  private _required = false;\r\n  private _disabled = false;\r\n  private _value?: string;\r\n  private _onChange: any;\r\n  private _onTouched: any;\r\n  _addresses: google.maps.places.QueryAutocompletePrediction[];\r\n  readonly control = new FormControl();\r\n  readonly stateChanges = new Subject<void>();\r\n  @HostBinding() readonly id = `address-input-${AddressInput.nextId++}`;\r\n  @ViewChild('input', { static: true }) inputElement: ElementRef;\r\n  @Output() readonly optionSelected = new EventEmitter<AddressChangeEvent>();\r\n  @Input() debounce = DEBOUNCE_TIME;\r\n  @Input() get placeholder() {\r\n    return this._placeholder;\r\n  }\r\n  set placeholder(plh) {\r\n    this._placeholder = plh;\r\n    this.stateChanges.next();\r\n  }\r\n  focused = false;\r\n  get empty(): boolean { return !this.control.value; }\r\n  get shouldLabelFloat() {\r\n    return this.focused || !this.empty;\r\n  }\r\n  @Input()\r\n  get required() {\r\n    return this._required;\r\n  }\r\n  set required(req) {\r\n    this._required = req;\r\n    if (req)\r\n      this.control.setValidators(Validators.required);\r\n    else\r\n      this.control.clearValidators();\r\n    this.stateChanges.next();\r\n  }\r\n  @Input()\r\n  get disabled(): boolean { return this._disabled; }\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n    if (this.control.disabled !== this._disabled) {\r\n      if (value)\r\n        this.control.disable();\r\n      else\r\n        this.control.enable();\r\n    }\r\n    this.stateChanges.next();\r\n  }\r\n  errorState = false;\r\n  controlType?: string = 'bizdoc-address-input';\r\n  @HostBinding('attr.aria-describedby') describedBy = '';\r\n\r\n  setDescribedByIds(ids: string[]) {\r\n    this.describedBy = ids.join(' ');\r\n  }\r\n  onContainerClick(): void {\r\n    this.inputElement.nativeElement.focus();\r\n  }\r\n  writeValue(val: any): void {\r\n    this._setValue(val, false);\r\n  }\r\n  registerOnChange(fn: any): void {\r\n    this._onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this._onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n  }\r\n  @Input() get value(): string {\r\n    return this._value;\r\n  }\r\n  set value(val: string) {\r\n      this._setValue(val, true);\r\n      this.stateChanges.next();\r\n  }\r\n  private _setValue(val: string, emitEvent: boolean) {\r\n    this._value = val;\r\n    this.control.setValue(val ? { description: val } : null, {emitEvent});\r\n    }\r\n\r\n  onFocus() {\r\n    this.focused = true;\r\n    this._onTouched && this._onTouched();\r\n  }\r\n  onBlur() {\r\n    this.focused = false;\r\n  }\r\n  displayFn(address: google.maps.places.QueryAutocompletePrediction | string) {\r\n    return isObject(address) ? (address as google.maps.places.QueryAutocompletePrediction).description : address as string;\r\n  }\r\n  selected(e: MatAutocompleteSelectedEvent) {\r\n    const address = e.option.value as google.maps.places.QueryAutocompletePrediction;\r\n    this._onChange(address.description);\r\n    this.optionSelected.emit({ address: address.description, placeId: address.place_id });\r\n  }\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(@Optional() @Self() public ngControl: NgControl, private _fm: FocusMonitor, private _elRef: ElementRef<HTMLElement>) {\r\n    if (this.ngControl != null) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n    _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {\r\n      this.focused = !!origin;\r\n      this.stateChanges.next();\r\n    });\r\n  }\r\n  public focus() {\r\n    this.inputElement.nativeElement.focus();\r\n  }\r\n  ngOnInit(): void {\r\n    const service = new google.maps.places.AutocompleteService();\r\n    this.control.valueChanges.pipe(debounceTime(this.debounce), takeUntil(this._destroy)).subscribe(input => {\r\n      service.getQueryPredictions({ input }, (r, s) => {\r\n        if (s === google.maps.places.PlacesServiceStatus.OK)\r\n          this._addresses = r;\r\n        else\r\n          console.log(`address google api error code: ${s}`)\r\n      });\r\n    });\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n    this._fm.stopMonitoring(this._elRef.nativeElement);\r\n    this.stateChanges.complete();\r\n  }\r\n}\r\nexport interface AddressChangeEvent {\r\n  address: string;\r\n  placeId: string;\r\n}\r\n"]}

package/esm2020/lib/core/controls/auto-complete.input.mjs

@@ -0,0 +1,256 @@
+import { Component, Input, HostBinding, Optional, Self, Output, EventEmitter, ViewChild } from '@angular/core';
+import { FormControl, Validators } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { MatAutocompleteTrigger } from '@angular/material/autocomplete';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Subject } from 'rxjs';
+import { debounceTime, takeUntil, switchMap, filter } from 'rxjs/operators';
+import { isObject, isString } from '../functions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "../session.service";
+import * as i4 from "../datasource.service";
+import * as i5 from "@angular/material/autocomplete";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/icon";
+import * as i9 from "@angular/material/input";
+import * as i10 from "@angular/common";
+import * as i11 from "@angular/material/form-field";
+export class TypeAutocomplete {
+    constructor(ngControl, _fm, _elRef, _session, _service) {
+        this.ngControl = ngControl;
+        this._fm = _fm;
+        this._elRef = _elRef;
+        this._session = _session;
+        this._service = _service;
+        this._required = false;
+        this._disabled = false;
+        this._control = new FormControl();
+        this.stateChanges = new Subject();
+        this.id = `type-auto-complete-${TypeAutocomplete.nextId++}`;
+        this.textChange = new EventEmitter();
+        this.optionSelected = new EventEmitter();
+        this.displayFn = (item) => {
+            if (!item)
+                return undefined;
+            if (!isObject(item.value))
+                return item.value;
+            else {
+                let name = Object.keys(item.value)[0];
+                return item.value[name];
+            }
+        };
+        this.focused = false;
+        this.errorState = false;
+        this.controlType = 'bizdoc-type-auto-complete';
+        this.describedBy = '';
+        this._minimumChars = 1;
+        this._destroy = new Subject();
+        if (this.ngControl != null) {
+            this.ngControl.valueAccessor = this;
+        }
+        _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {
+            this.focused = !!origin;
+            this.stateChanges.next();
+        });
+    }
+    focus() {
+        this.inputElement.nativeElement.focus();
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(plh) {
+        this._placeholder = plh;
+        this.stateChanges.next();
+    }
+    _optionSelected(e) {
+        const { value, key } = e.option.value || {};
+        const text = this._column ? value[this._column.name] : value;
+        this._value = key;
+        this._textFormControl && this._textFormControl.setValue(text, { emitEvent: false });
+        this.textChange.emit(text);
+        this.optionSelected.emit({ value: key, text });
+        this._onChange && this._onChange(key);
+    }
+    get empty() { return !this._control.value || this._control.value === ''; }
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    get required() {
+        return this._required;
+    }
+    set required(req) {
+        this._required = coerceBooleanProperty(req);
+        if (this._required)
+            this._control.setValidators(Validators.required);
+        else
+            this._control.clearValidators();
+        this.stateChanges.next();
+    }
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        if (this._control.disabled !== this._disabled) {
+            if (this._disabled)
+                this._control.disable();
+            else
+                this._control.enable();
+        }
+        this.stateChanges.next();
+    }
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(' ');
+    }
+    onContainerClick() {
+        this.inputElement.nativeElement.focus();
+        this.trigger.openPanel();
+    }
+    clear() {
+        this._setValue(null, true);
+        this._onChange && this._onChange(null);
+    }
+    writeValue(obj) {
+        this._setValue(obj, false);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(val) {
+        this._setValue(val, true);
+        this.stateChanges.next();
+    }
+    set minimumChars(val) { this._minimumChars = val; }
+    _setValue(val, emitEvent) {
+        this._value = val;
+        //if (val)
+        //this.service.get(this.source, val).subscribe(v => {
+        //});
+        this._control.setValue(val ? { key: val, value: this.text || val } : val, { emitEvent });
+    }
+    ngDoCheck() {
+        if (this.ngControl) {
+            this.errorState = this.ngControl.invalid && this.ngControl.touched;
+            this.stateChanges.next();
+        }
+    }
+    _onFocus() {
+        this.focused = true;
+        this._onTouched && this._onTouched();
+    }
+    _onBlur() {
+        this.focused = false;
+    }
+    set textFormControlName(val) {
+        this._textFormControl = (this.ngControl.control.parent).controls[val];
+    }
+    set textFormControl(val) {
+        this._textFormControl = val;
+    }
+    ngOnInit() {
+        this._configuration = this._session.profile.types.find(t => t.name === this._type);
+        if (!this._configuration)
+            throw `${this._type} is not a known type.`;
+        this._column = this._configuration.columns ? this._configuration.columns.find(c => !c.key) : null;
+        this._items$ = this._control.valueChanges.pipe(takeUntil(this._destroy), debounceTime(250), filter(v => isString(v) && v.length > this._minimumChars), switchMap(v => this._service.all(this._type, v)));
+        this._control.statusChanges.pipe(takeUntil(this._destroy)).subscribe(() => {
+            this.errorState = this._control.errors != null;
+        });
+        const val = this.value;
+        if (val)
+            this._service.get(this._type, val).subscribe(v => this._control.setValue({ key: val, value: v || val }, { emitEvent: false }));
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        this._fm.stopMonitoring(this._elRef.nativeElement);
+        this.stateChanges.complete();
+        this.textChange.complete();
+        this.optionSelected.complete();
+    }
+}
+TypeAutocomplete.nextId = 0;
+TypeAutocomplete.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TypeAutocomplete, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: i2.FocusMonitor }, { token: i0.ElementRef }, { token: i3.SessionService }, { token: i4.DatasourceService }], target: i0.ɵɵFactoryTarget.Component });
+TypeAutocomplete.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: TypeAutocomplete, selector: "bizdoc-autocomplete", inputs: { _type: ["type", "_type"], placeholder: "placeholder", text: "text", required: "required", disabled: "disabled", value: "value", minimumChars: "minimumChars", textFormControlName: "textFormControlName", textFormControl: "textFormControl" }, outputs: { textChange: "textChange", optionSelected: "optionSelected" }, host: { properties: { "class.floating": "this.shouldLabelFloat", "attr.aria-describedby": "this.describedBy", "id": "this.id" } }, providers: [{ provide: MatFormFieldControl, useExisting: TypeAutocomplete }], viewQueries: [{ propertyName: "inputElement", first: true, predicate: ["input"], descendants: true, static: true }, { propertyName: "trigger", first: true, predicate: ["input"], descendants: true, read: MatAutocompleteTrigger, static: true }], ngImport: i0, template: `<input matInput [matAutocomplete]="auto" [placeholder]="placeholder" [formControl]="_control" #input
+    (focus)="_onFocus()" (blur)="_onBlur()" [required]="required"/>
+    <mat-autocomplete #auto (optionSelected)="_optionSelected($event)" [displayWith]='displayFn'>
+      <mat-option *ngFor="let v of _items$ | async" [value]="v">
+        <span *ngIf="!_column">{{v.value}}</span>
+        <span *ngIf="_column">{{v.value[_column.name]}}</span>
+      </mat-option>
+    </mat-autocomplete>
+    <button mat-icon-button matSuffix (click)="clear()" *ngIf="_control.value"><mat-icon>close</mat-icon></button>`, isInline: true, styles: ["[matsuffix].mat-icon-button{opacity:.54}\n"], components: [{ type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["disableRipple"], exportAs: ["matAutocomplete"] }, { type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }, { type: i7.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i9.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: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", exportAs: ["matAutocompleteTrigger"] }, { type: i1.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.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i10.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i10.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i11.MatSuffix, selector: "[matSuffix]" }], pipes: { "async": i10.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TypeAutocomplete, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-autocomplete',
+                    providers: [{ provide: MatFormFieldControl, useExisting: TypeAutocomplete }],
+                    template: `<input matInput [matAutocomplete]="auto" [placeholder]="placeholder" [formControl]="_control" #input
+    (focus)="_onFocus()" (blur)="_onBlur()" [required]="required"/>
+    <mat-autocomplete #auto (optionSelected)="_optionSelected($event)" [displayWith]='displayFn'>
+      <mat-option *ngFor="let v of _items$ | async" [value]="v">
+        <span *ngIf="!_column">{{v.value}}</span>
+        <span *ngIf="_column">{{v.value[_column.name]}}</span>
+      </mat-option>
+    </mat-autocomplete>
+    <button mat-icon-button matSuffix (click)="clear()" *ngIf="_control.value"><mat-icon>close</mat-icon></button>`,
+                    host: {
+                        '[class.floating]': 'shouldLabelFloat',
+                        '[attr.aria-describedby]': 'describedBy'
+                    },
+                    styles: ['[matsuffix].mat-icon-button { opacity: .54 }']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i2.FocusMonitor }, { type: i0.ElementRef }, { type: i3.SessionService }, { type: i4.DatasourceService }]; }, propDecorators: { inputElement: [{
+                type: ViewChild,
+                args: ['input', { static: true }]
+            }], trigger: [{
+                type: ViewChild,
+                args: ['input', { static: true, read: MatAutocompleteTrigger }]
+            }], id: [{
+                type: HostBinding
+            }], _type: [{
+                type: Input,
+                args: ['type']
+            }], placeholder: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], textChange: [{
+                type: Output
+            }], optionSelected: [{
+                type: Output
+            }], shouldLabelFloat: [{
+                type: HostBinding,
+                args: ['class.floating']
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], describedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }], value: [{
+                type: Input
+            }], minimumChars: [{
+                type: Input
+            }], textFormControlName: [{
+                type: Input
+            }], textFormControl: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-complete.input.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/controls/auto-complete.input.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, HostBinding, Optional, Self, OnInit, ElementRef, Output, EventEmitter, ViewChild, DoCheck } from '@angular/core';\r\nimport { NgControl, ControlValueAccessor, FormControl, Validators } from '@angular/forms';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { MatAutocompleteSelectedEvent, MatAutocompleteTrigger } from '@angular/material/autocomplete';\r\nimport { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { Subject, Observable } from 'rxjs';\r\nimport { debounceTime, takeUntil, switchMap, filter } from 'rxjs/operators';\r\nimport { SessionService } from '../session.service';\r\nimport { DatasourceService } from '../datasource.service';\r\nimport { Type, FieldInfo } from '../models';\r\nimport { isObject, isString } from '../functions';\r\n@Component({\r\n  selector: 'bizdoc-autocomplete',\r\n  providers: [{ provide: MatFormFieldControl, useExisting: TypeAutocomplete }],\r\n  template: `<input matInput [matAutocomplete]=\"auto\" [placeholder]=\"placeholder\" [formControl]=\"_control\" #input\r\n    (focus)=\"_onFocus()\" (blur)=\"_onBlur()\" [required]=\"required\"/>\r\n    <mat-autocomplete #auto (optionSelected)=\"_optionSelected($event)\" [displayWith]='displayFn'>\r\n      <mat-option *ngFor=\"let v of _items$ | async\" [value]=\"v\">\r\n        <span *ngIf=\"!_column\">{{v.value}}</span>\r\n        <span *ngIf=\"_column\">{{v.value[_column.name]}}</span>\r\n      </mat-option>\r\n    </mat-autocomplete>\r\n    <button mat-icon-button matSuffix (click)=\"clear()\" *ngIf=\"_control.value\"><mat-icon>close</mat-icon></button>`,\r\n  host: {\r\n    '[class.floating]': 'shouldLabelFloat',\r\n    '[attr.aria-describedby]': 'describedBy'\r\n  },\r\n  styles: ['[matsuffix].mat-icon-button { opacity: .54 }']\r\n})\r\nexport\r\n  class TypeAutocomplete implements MatFormFieldControl<string>, DoCheck, ControlValueAccessor, OnDestroy, OnInit {\r\n  focus() {\r\n    this.inputElement.nativeElement.focus();\r\n  }\r\n  private static nextId = 0;\r\n  private _placeholder: string;\r\n  private _required = false;\r\n  private _disabled = false;\r\n  private _value?: string;\r\n  private _onChange: any;\r\n  private _onTouched: any;\r\n  readonly _control = new FormControl();\r\n  readonly stateChanges = new Subject<void>();\r\n  _items$: Observable<KeyValue[]>;\r\n  _column: FieldInfo;\r\n  private _configuration: Type;\r\n  @ViewChild('input', { static: true }) inputElement: ElementRef;\r\n  @ViewChild('input', { static: true, read: MatAutocompleteTrigger }) trigger: MatAutocompleteTrigger;\r\n  @HostBinding() readonly id = `type-auto-complete-${TypeAutocomplete.nextId++}`;\r\n  @Input('type') _type!: string;\r\n  private _textFormControl: FormControl;\r\n  @Input() get placeholder(): string {\r\n    return this._placeholder;\r\n  }\r\n  set placeholder(plh: string) {\r\n    this._placeholder = plh;\r\n    this.stateChanges.next();\r\n  }\r\n  @Input() text: string;\r\n  @Output() readonly textChange = new EventEmitter<string>();\r\n  @Output() readonly optionSelected = new EventEmitter<AutocompleteSelectedEvent>();\r\n  displayFn = (item: { value: any }) => {\r\n    if (!item)\r\n      return undefined;\r\n    if (!isObject(item.value))\r\n      return item.value;\r\n    else {\r\n      let name = Object.keys(item.value)[0];\r\n      return item.value[name];\r\n    }\r\n  }\r\n  _optionSelected(e: MatAutocompleteSelectedEvent) {\r\n    const { value, key } = e.option.value as KeyValue || {};\r\n    const text = this._column ? value[this._column.name] : value;\r\n    this._value = key;\r\n    this._textFormControl && this._textFormControl.setValue(text, { emitEvent: false });\r\n    this.textChange.emit(text);\r\n    this.optionSelected.emit({ value: key, text });\r\n    this._onChange && this._onChange(key);\r\n  }\r\n  focused = false;\r\n  get empty(): boolean { return !this._control.value || this._control.value === ''; }\r\n  @HostBinding('class.floating')\r\n  get shouldLabelFloat() {\r\n    return this.focused || !this.empty;\r\n  }\r\n  @Input()\r\n  get required(): boolean {\r\n    return this._required;\r\n  }\r\n  set required(req: boolean) {\r\n    this._required = coerceBooleanProperty(req);\r\n    if (this._required)\r\n      this._control.setValidators(Validators.required);\r\n    else\r\n      this._control.clearValidators();\r\n    this.stateChanges.next();\r\n  }\r\n  @Input()\r\n  get disabled(): boolean { return this._disabled; }\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n    if (this._control.disabled !== this._disabled) {\r\n      if (this._disabled)\r\n        this._control.disable();\r\n      else\r\n        this._control.enable();\r\n    }\r\n    this.stateChanges.next();\r\n  }\r\n  errorState = false;\r\n  controlType?: string = 'bizdoc-type-auto-complete';\r\n  @HostBinding('attr.aria-describedby') describedBy = '';\r\n\r\n  setDescribedByIds(ids: string[]) {\r\n    this.describedBy = ids.join(' ');\r\n  }\r\n  onContainerClick(): void {\r\n    this.inputElement.nativeElement.focus();\r\n    this.trigger.openPanel();\r\n  }\r\n  clear() {\r\n    this._setValue(null, true);\r\n    this._onChange && this._onChange(null);\r\n  }\r\n  writeValue(obj: any): void {\r\n    this._setValue(obj, false);\r\n  }\r\n  registerOnChange(fn: any): void {\r\n    this._onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this._onTouched = fn;\r\n  }\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n  }\r\n  @Input() get value(): string {\r\n    return this._value;\r\n  }\r\n  set value(val: string) {\r\n    this._setValue(val, true);\r\n    this.stateChanges.next();\r\n  }\r\n  private _minimumChars = 1;\r\n  @Input() set minimumChars(val: number) { this._minimumChars = val; }\r\n  private _setValue(val: string, emitEvent: boolean) {\r\n    this._value = val;\r\n    //if (val)\r\n    //this.service.get(this.source, val).subscribe(v => {\r\n    //});\r\n    this._control.setValue(val ? { key: val, value: this.text || val } : val, { emitEvent });\r\n  }\r\n  ngDoCheck(): void {\r\n    if (this.ngControl) {\r\n      this.errorState = this.ngControl.invalid && this.ngControl.touched;\r\n      this.stateChanges.next();\r\n    }\r\n  }\r\n\r\n  _onFocus() {\r\n    this.focused = true;\r\n    this._onTouched && this._onTouched();\r\n  }\r\n  _onBlur() {\r\n    this.focused = false;\r\n  }\r\n  @Input() set textFormControlName(val: string) {\r\n    this._textFormControl = ((this.ngControl.control as FormControl).parent).controls[val] as FormControl;\r\n  }\r\n  @Input() set textFormControl(val: FormControl) {\r\n    this._textFormControl = val;\r\n  }\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(@Optional() @Self() public ngControl: NgControl, private _fm: FocusMonitor, private _elRef: ElementRef<HTMLElement>, private _session: SessionService, private _service: DatasourceService) {\r\n    if (this.ngControl != null) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n    _fm.monitor(_elRef.nativeElement, true).subscribe(origin => {\r\n      this.focused = !!origin;\r\n      this.stateChanges.next();\r\n    });\r\n  }\r\n  ngOnInit(): void {\r\n    this._configuration = this._session.profile.types.find(t => t.name === this._type);\r\n    if (!this._configuration)\r\n      throw `${this._type} is not a known type.`;\r\n    this._column = this._configuration.columns ? this._configuration.columns.find(c => !c.key) : null;\r\n    this._items$ = this._control.valueChanges.pipe(\r\n      takeUntil(this._destroy),\r\n      debounceTime(250),\r\n      filter(v => isString(v) && v.length > this._minimumChars),\r\n      switchMap(v =>\r\n        this._service.all(this._type, v)));\r\n    this._control.statusChanges.pipe(takeUntil(this._destroy)).subscribe(() => {\r\n      this.errorState = this._control.errors != null;\r\n    });\r\n    const val = this.value;\r\n    if (val)\r\n      this._service.get(this._type, val).subscribe(v =>\r\n        this._control.setValue({ key: val, value: v || val }, { emitEvent: false }));\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n    this._fm.stopMonitoring(this._elRef.nativeElement);\r\n    this.stateChanges.complete();\r\n    this.textChange.complete();\r\n    this.optionSelected.complete();\r\n  }\r\n}\r\ninterface KeyValue { key: any, value: any }\r\n\r\nexport interface AutocompleteSelectedEvent {\r\n  readonly text: string;\r\n  readonly value: any;\r\n}\r\n"]}