@bizdoc/core 1.13.12 → 1.13.16

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

@@ -0,0 +1,237 @@
+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 { MatSelect } from '@angular/material/select';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+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/select";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/common";
+import * as i8 from "../pipes/translate.pipe";
+export class TypeSelect {
+    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-select-${TypeSelect.nextId++}`;
+        this.selectionChange = new EventEmitter();
+        this.focused = false;
+        this.textChange = new EventEmitter();
+        this.errorState = false;
+        this.controlType = 'bizdoc-type-select';
+        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();
+        });
+    }
+    focus() {
+        this.inputElement.focus();
+    }
+    set multiple(val) { this._multiple = coerceBooleanProperty(val); }
+    get multiple() { return this._multiple; }
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(plh) {
+        this._placeholder = plh;
+        this.stateChanges.next();
+    }
+    get empty() { return !this._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(val) {
+        this._disabled = coerceBooleanProperty(val);
+        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.focus();
+    }
+    writeValue(val) {
+        this._value = val;
+        this._setValue(val, false);
+    }
+    _setValue(val, emitEvent) {
+        this._control.setValue(val ? this.multiple ? val.map(key => ({ key })) : { key: val } : null, { emitEvent });
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(val) {
+        this._value = val;
+        this._setValue(val, true);
+        this.stateChanges.next();
+    }
+    _onFocus() {
+        this.focused = true;
+        this._onTouched && this._onTouched();
+    }
+    _onBlur() {
+        this.focused = false;
+    }
+    ngDoCheck() {
+        if (this.ngControl) {
+            this.errorState = this.ngControl.invalid && this.ngControl.touched;
+            this.stateChanges.next();
+        }
+    }
+    _compareWithKey(option1, option2) {
+        return option2 && option1.key === option2.key;
+    }
+    ngOnInit() {
+        this._configuration = this._session.profile.types.find(t => t.name === this.type);
+        if (!this._configuration)
+            throw `${this.type} is not a known type.`;
+        if (this._configuration.columns)
+            this._column = this._configuration.columns.find(c => !c.key);
+        this._items$ = this._service.all(this.type);
+        this._control.statusChanges.pipe(takeUntil(this._destroy)).subscribe(() => this.errorState = this._control.errors != null);
+        this._control.valueChanges.pipe(takeUntil(this._destroy)).subscribe(v => {
+            if (this._multiple) {
+                const items = v || [], key = items.map(i => i.key);
+                this._value = key;
+                this._onChange && this._onChange(key);
+                this.selectionChange.emit({
+                    values: items.map(i => i.key),
+                    items: items.map(i => i.value)
+                });
+            }
+            else {
+                const { value, key } = v || {};
+                this._value = key;
+                this._onChange && this._onChange(key);
+                const text = this._column ? value[this._column.name] : value;
+                this.textChange.emit(text);
+                this.selectionChange.emit({
+                    value: key,
+                    item: value,
+                    text
+                });
+            }
+            this.stateChanges.next();
+        });
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+        this._fm.stopMonitoring(this._elRef.nativeElement);
+        this.selectionChange.complete();
+        this.stateChanges.complete();
+    }
+}
+TypeSelect.nextId = 0;
+TypeSelect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TypeSelect, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: i2.FocusMonitor }, { token: i0.ElementRef }, { token: i3.SessionService }, { token: i4.DatasourceService }], target: i0.ɵɵFactoryTarget.Component });
+TypeSelect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: TypeSelect, selector: "bizdoc-select", inputs: { type: "type", scope: "scope", multiple: "multiple", placeholder: "placeholder", required: "required", disabled: "disabled", text: "text", value: "value" }, outputs: { selectionChange: "selectionChange", textChange: "textChange" }, host: { properties: { "class.floating": "this.shouldLabelFloat", "attr.aria-describedby": "this.describedBy", "id": "this.id" } }, providers: [{ provide: MatFormFieldControl, useExisting: TypeSelect }], viewQueries: [{ propertyName: "inputElement", first: true, predicate: MatSelect, descendants: true, static: true }], ngImport: i0, template: `<mat-select [placeholder]="placeholder" [formControl]="_control" [multiple]='multiple'
+    (focus)="_onFocus()" (blur)="_onBlur()" [compareWith]='_compareWithKey' [required]="required">
+      <mat-option *ngIf="!required && !multiple" [value]="null">
+        {{ 'None' | translate }}
+      </mat-option>
+      <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-select>`, isInline: true, components: [{ type: i5.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }], directives: [{ 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: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i8.TranslatePipe, "async": i7.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TypeSelect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-select',
+                    providers: [{ provide: MatFormFieldControl, useExisting: TypeSelect }],
+                    template: `<mat-select [placeholder]="placeholder" [formControl]="_control" [multiple]='multiple'
+    (focus)="_onFocus()" (blur)="_onBlur()" [compareWith]='_compareWithKey' [required]="required">
+      <mat-option *ngIf="!required && !multiple" [value]="null">
+        {{ 'None' | translate }}
+      </mat-option>
+      <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-select>`,
+                    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 }, { type: i3.SessionService }, { type: i4.DatasourceService }]; }, propDecorators: { inputElement: [{
+                type: ViewChild,
+                args: [MatSelect, { static: true }]
+            }], id: [{
+                type: HostBinding
+            }], type: [{
+                type: Input
+            }], scope: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], multiple: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], shouldLabelFloat: [{
+                type: HostBinding,
+                args: ['class.floating']
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], textChange: [{
+                type: Output
+            }], describedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.input.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/controls/select.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 { MatSelect } from '@angular/material/select';\r\nimport { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { Subject, Observable } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { Type, FieldInfo } from '../models';\r\nimport { SessionService } from '../session.service';\r\nimport { DatasourceService } from '../datasource.service';\r\nimport { ScopeType } from '../configuration';\r\n@Component({\r\n  selector: 'bizdoc-select',\r\n  providers: [{ provide: MatFormFieldControl, useExisting: TypeSelect }],\r\n  template: `<mat-select [placeholder]=\"placeholder\" [formControl]=\"_control\" [multiple]='multiple'\r\n    (focus)=\"_onFocus()\" (blur)=\"_onBlur()\" [compareWith]='_compareWithKey' [required]=\"required\">\r\n      <mat-option *ngIf=\"!required && !multiple\" [value]=\"null\">\r\n        {{ 'None' | translate }}\r\n      </mat-option>\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-select>`,\r\n  host: {\r\n    '[class.floating]': 'shouldLabelFloat',\r\n    '[attr.aria-describedby]': 'describedBy'\r\n  }\r\n})\r\nexport\r\n  class TypeSelect implements MatFormFieldControl<string | string[]>, ControlValueAccessor, OnInit, DoCheck, OnDestroy {\r\n  focus() {\r\n    this.inputElement.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 | string[];\r\n  private _onChange: any;\r\n  private _onTouched: any;\r\n  private _multiple: boolean;\r\n  readonly _control = new FormControl();\r\n  _items$: Observable<KeyValue[]>;\r\n  _column: FieldInfo;\r\n  private _configuration: Type;\r\n  readonly stateChanges = new Subject<void>();\r\n  @ViewChild(MatSelect, { static: true }) inputElement: MatSelect;\r\n  @HostBinding() id = `type-select-${TypeSelect.nextId++}`;\r\n  @Input() type: string;\r\n  @Input() scope: ScopeType;\r\n  @Output() readonly selectionChange = new EventEmitter<SelectEvent>();\r\n  @Input() set multiple(val: boolean) { this._multiple = coerceBooleanProperty(val); }\r\n  get multiple(): boolean { return this._multiple }\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._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(val: boolean) {\r\n    this._disabled = coerceBooleanProperty(val);\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  @Input() text: string;\r\n  @Output() readonly textChange = new EventEmitter<string>();\r\n  errorState = false;\r\n  controlType?: string = 'bizdoc-type-select';\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.focus();\r\n  }\r\n  writeValue(val: any): void {\r\n    this._value = val;\r\n    this._setValue(val, false);\r\n  }\r\n  private _setValue(val: any, emitEvent: boolean) {\r\n    this._control.setValue(val ? this.multiple ? val.map(key => ({ key })) : { key: val } : null, { emitEvent });\r\n  }\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 | string[] {\r\n    return this._value;\r\n  }\r\n  set value(val: string | string[]) {\r\n    this._value = val;\r\n    this._setValue(val, true);\r\n    this.stateChanges.next();\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  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  _compareWithKey(option1: KeyValue, option2: KeyValue) {\r\n    return option2 && option1.key === option2.key;\r\n  }\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(@Optional() @Self() public ngControl: NgControl,\r\n    private _fm: FocusMonitor,\r\n    private _elRef: ElementRef<HTMLElement>, private _session: SessionService,\r\n    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    if (this._configuration.columns) this._column = this._configuration.columns.find(c => !c.key);\r\n    this._items$ = this._service.all(this.type);\r\n    this._control.statusChanges.pipe(takeUntil(this._destroy)).subscribe(() =>\r\n      this.errorState = this._control.errors != null\r\n    );\r\n    this._control.valueChanges.pipe(takeUntil(this._destroy)).subscribe(v => {\r\n      if (this._multiple) {\r\n        const items = v as KeyValue[] || [],\r\n          key = items.map(i => i.key);\r\n        this._value = key;\r\n        this._onChange && this._onChange(key);\r\n        this.selectionChange.emit({\r\n          values: items.map(i => i.key),\r\n          items: items.map(i => i.value)\r\n        });\r\n      }\r\n      else {\r\n        const { value, key } = v as KeyValue || {};\r\n        this._value = key;\r\n        this._onChange && this._onChange(key);\r\n        const text = this._column ? value[this._column.name] : value;\r\n        this.textChange.emit(text);\r\n        this.selectionChange.emit({\r\n          value: key,\r\n          item: value,\r\n          text\r\n        });\r\n      }\r\n      this.stateChanges.next();\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.selectionChange.complete();\r\n    this.stateChanges.complete();\r\n  }\r\n}\r\n\r\ninterface KeyValue { key: any; value: any }\r\n\r\nexport interface SelectEvent {\r\n  readonly value?: any;\r\n  readonly text?: string;\r\n  readonly item?: any;\r\n  readonly values?: any[];\r\n  readonly items?: any[];\r\n}\r\n"]}

package/esm2020/lib/core/controls/time-picker.mjs

@@ -0,0 +1,196 @@
+import { Component, Input, Optional, Self } from "@angular/core";
+import { FormControl } from "@angular/forms";
+import { MatFormFieldControl } from "@angular/material/form-field";
+import { coerceBooleanProperty } from "@angular/cdk/coercion";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+import { isDate } from "../../core/functions";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "@angular/forms";
+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 TIME_FORMAT = /\d{1,2}:\d{1,2}/, DATE_FORMAT = /\d{4}-\d\d-\d\dT\d\d:\d{2}/;
+function generateValues() {
+    const times = [];
+    let h = 0;
+    while (h < 24) {
+        let m = 0;
+        while (m < 60) {
+            times.push(`${h}:${m}`);
+            m += 15;
+        }
+        h++;
+    }
+    return times;
+}
+export class TimePicker {
+    constructor(_focusMonitor, _elementRef, ngControl) {
+        this._focusMonitor = _focusMonitor;
+        this._elementRef = _elementRef;
+        this.ngControl = ngControl;
+        this.controlType = 'time-picker';
+        this.id = `time-picker-${TimePicker.nextId++}`;
+        this.focused = false;
+        this.errorState = false;
+        this.describedBy = '';
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
+        this._required = false;
+        this._disabled = false;
+        this.control = new FormControl({});
+        this.stateChanges = new Subject();
+        this.options = generateValues();
+        this._destroy = new Subject();
+        _focusMonitor.monitor(_elementRef, true).subscribe(origin => {
+            if (this.focused && !origin) {
+                this.onTouched();
+            }
+            this.focused = !!origin;
+            this.stateChanges.next();
+        });
+        if (this.ngControl != null) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    get empty() {
+        const value = this.control.value;
+        return !value;
+    }
+    get shouldLabelFloat() { return this.focused || !this.empty; }
+    get placeholder() { return this._placeholder; }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    get required() { return this._required; }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+        this.stateChanges.next();
+    }
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._disabled ? this.control.disable() : this.control.enable();
+        this.stateChanges.next();
+    }
+    get value() {
+        const value = this.control.value;
+        return value;
+    }
+    set value(val) {
+        this._setValue(val, true);
+        this.stateChanges.next();
+    }
+    _setValue(val, emitEvent) {
+        if (val) {
+            if (isDate(val) || DATE_FORMAT.test(val)) {
+                val = new Date(val);
+                this.control.setValue(val.getHours() + ':' + val.getMinutes(), { emitEvent });
+            }
+            else
+                this.control.setValue(TIME_FORMAT.exec(val)[0], { emitEvent });
+        }
+        else
+            this.control.reset();
+    }
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(' ');
+    }
+    onContainerClick(event) {
+        if (event.target.tagName !== 'INPUT')
+            this._elementRef.nativeElement.querySelector('input').focus();
+    }
+    writeValue(val) {
+        this._setValue(val, false);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    ngOnInit() {
+        this.control.valueChanges.pipe(takeUntil(this._destroy)).
+            subscribe(v => {
+            this.errorState = !this._validate(v);
+            if (v && !this.errorState && this.dateControlName) {
+                const date = this._dateControl.value;
+                date && this._appendTime(date);
+            }
+            this.onChange(this.value);
+        });
+        if (this.dateControlName) {
+            this._dateControl = this.ngControl.control.parent.controls[this.dateControlName];
+            if (!this._dateControl)
+                throw `${this.controlType} dateControlName ${this.dateControlName}`;
+            this._dateControl.valueChanges.pipe(takeUntil(this._destroy)).
+                subscribe((v) => {
+                v && this.value && this._appendTime(v);
+            });
+        }
+    }
+    _appendTime(val) {
+        if (!isDate(val))
+            val = new Date(val);
+        const parts = this.value.split(':');
+        val.setHours(parseInt(parts[0]), parseInt(parts[1]));
+        this._dateControl.setValue(val.toISOString(), { emitEvent: false });
+    }
+    _validate(val) {
+        if (!val)
+            return !this._required;
+        const parts = val.split(':');
+        if (parts.length > 2)
+            return false;
+        for (let i = 0; i < parts.length; i++) {
+            if (!/\d{1,2}/.test(parts[i]))
+                return false;
+            const part = parseInt(parts[i]);
+            if (isNaN(part))
+                return false;
+            else if (i === 0 && (part < 0 || part > 23))
+                return false;
+            else if (i === 1 && (part < 0 || part > 59))
+                return false;
+        }
+        return true;
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+        this._focusMonitor.stopMonitoring(this._elementRef);
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+TimePicker.nextId = 0;
+TimePicker.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TimePicker, deps: [{ token: i1.FocusMonitor }, { token: i0.ElementRef }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component });
+TimePicker.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: TimePicker, selector: "mat-time-picker", inputs: { dateControlName: "dateControlName", placeholder: "placeholder", required: "required", disabled: "disabled", value: "value" }, host: { properties: { "class.floating": "shouldLabelFloat", "id": "id", "attr.aria-describedby": "describedBy" } }, providers: [{ provide: MatFormFieldControl, useExisting: TimePicker }], ngImport: i0, template: "<input matInput type=\"text\" [matAutocomplete]=\"auto\" [formControl]=\"control\" [placeholder]=\"placeholder\">\r\n<mat-autocomplete #auto>\r\n  <mat-option *ngFor=\"let o of options\" [value]=\"o\">{{o}}</mat-option>\r\n</mat-autocomplete>\r\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: i2.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: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TimePicker, decorators: [{
+            type: Component,
+            args: [{ selector: 'mat-time-picker', providers: [{ provide: MatFormFieldControl, useExisting: TimePicker }], host: {
+                        '[class.floating]': 'shouldLabelFloat',
+                        '[id]': 'id',
+                        '[attr.aria-describedby]': 'describedBy'
+                    }, template: "<input matInput type=\"text\" [matAutocomplete]=\"auto\" [formControl]=\"control\" [placeholder]=\"placeholder\">\r\n<mat-autocomplete #auto>\r\n  <mat-option *ngFor=\"let o of options\" [value]=\"o\">{{o}}</mat-option>\r\n</mat-autocomplete>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.FocusMonitor }, { type: i0.ElementRef }, { type: i2.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; }, propDecorators: { dateControlName: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-picker.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/controls/time-picker.ts","../../../../../../libraries/core/src/lib/core/controls/time-picker.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, Input, Optional, Self, ElementRef } from \"@angular/core\";\r\nimport { FormControl, ControlValueAccessor, NgControl } from \"@angular/forms\";\r\nimport { MatFormFieldControl } from \"@angular/material/form-field\";\r\nimport { FocusMonitor } from \"@angular/cdk/a11y\";\r\nimport { coerceBooleanProperty } from \"@angular/cdk/coercion\";\r\nimport { Subject } from \"rxjs\";\r\nimport { takeUntil } from \"rxjs/operators\";\r\nimport { isDate } from \"../../core/functions\";\r\n\r\nconst TIME_FORMAT = /\\d{1,2}:\\d{1,2}/, DATE_FORMAT = /\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d{2}/;\r\n\r\nfunction generateValues(): string[] {\r\n  const times = [];\r\n  let h = 0;\r\n  while (h < 24) {\r\n    let m = 0;\r\n    while (m < 60) {\r\n      times.push(`${h}:${m}`);\r\n      m += 15;\r\n    }\r\n    h++;\r\n  }\r\n  return times;\r\n}\r\n\r\n@Component({\r\n  selector: 'mat-time-picker',\r\n  templateUrl: 'time-picker.html',\r\n  providers: [{ provide: MatFormFieldControl, useExisting: TimePicker }],\r\n  host: {\r\n    '[class.floating]': 'shouldLabelFloat',\r\n    '[id]': 'id',\r\n    '[attr.aria-describedby]': 'describedBy'\r\n  }\r\n})\r\nexport class TimePicker implements ControlValueAccessor, MatFormFieldControl<string>, OnInit, OnDestroy {\r\n  private static nextId = 0;\r\n  readonly controlType = 'time-picker';\r\n  readonly id = `time-picker-${TimePicker.nextId++}`;\r\n  focused = false;\r\n  errorState = false;\r\n  describedBy = '';\r\n  onChange = (_: any) => { };\r\n  onTouched = () => { };\r\n  private _dateControl: FormControl;\r\n\r\n  get empty() {\r\n    const value = this.control.value;\r\n\r\n    return !value;\r\n  }\r\n\r\n  get shouldLabelFloat() { return this.focused || !this.empty; }\r\n\r\n  @Input()\r\n  dateControlName: string;\r\n  @Input()\r\n  get placeholder(): string { return this._placeholder; }\r\n  set placeholder(value: string) {\r\n    this._placeholder = value;\r\n    this.stateChanges.next();\r\n  }\r\n  private _placeholder: string;\r\n\r\n  @Input()\r\n  get required(): boolean { return this._required; }\r\n  set required(value: boolean) {\r\n    this._required = coerceBooleanProperty(value);\r\n    this.stateChanges.next();\r\n  }\r\n  private _required = false;\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    this._disabled ? this.control.disable() : this.control.enable();\r\n    this.stateChanges.next();\r\n  }\r\n  private _disabled = false;\r\n  readonly control = new FormControl({});\r\n  readonly stateChanges = new Subject<void>();\r\n  readonly options = generateValues();\r\n  @Input()\r\n  get value(): string | null {\r\n    const value = this.control.value;\r\n    return value;\r\n  }\r\n  set value(val: string | null) {\r\n    this._setValue(val, true);\r\n    this.stateChanges.next();\r\n  }\r\n  private _setValue(val: Date | string, emitEvent: boolean) {\r\n    if (val) {\r\n      if (isDate(val) || DATE_FORMAT.test(val as string)) {\r\n        val = new Date(val);\r\n        this.control.setValue(val.getHours() + ':' + val.getMinutes(), { emitEvent });\r\n      }\r\n      else\r\n        this.control.setValue(TIME_FORMAT.exec(val as string)[0], { emitEvent });\r\n    } else\r\n      this.control.reset();\r\n  }\r\n\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(\r\n    private _focusMonitor: FocusMonitor,\r\n    private _elementRef: ElementRef<HTMLElement>,\r\n    @Optional() @Self() public ngControl: NgControl) {\r\n\r\n    _focusMonitor.monitor(_elementRef, true).subscribe(origin => {\r\n      if (this.focused && !origin) {\r\n        this.onTouched();\r\n      }\r\n      this.focused = !!origin;\r\n      this.stateChanges.next();\r\n    });\r\n\r\n    if (this.ngControl != null) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n  }\r\n\r\n  setDescribedByIds(ids: string[]) {\r\n    this.describedBy = ids.join(' ');\r\n  }\r\n\r\n  onContainerClick(event: MouseEvent) {\r\n    if ((event.target as Element).tagName !== 'INPUT')\r\n      this._elementRef.nativeElement.querySelector('input').focus();\r\n  }\r\n\r\n  writeValue(val: string | null): void {\r\n    this._setValue(val, false);\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.control.valueChanges.pipe(takeUntil(this._destroy)).\r\n      subscribe(v => {\r\n        this.errorState = !this._validate(v);\r\n        if (v && !this.errorState && this.dateControlName) {\r\n          const date = this._dateControl.value;\r\n          date && this._appendTime(date);\r\n        }\r\n        this.onChange(this.value);\r\n      });\r\n    if (this.dateControlName) {\r\n      this._dateControl = this.ngControl.control.parent.controls[this.dateControlName];\r\n      if (!this._dateControl) throw `${this.controlType} dateControlName ${this.dateControlName}`;\r\n\r\n      this._dateControl.valueChanges.pipe(takeUntil(this._destroy)).\r\n        subscribe((v: Date) => {\r\n          v && this.value && this._appendTime(v);\r\n        });\r\n    }\r\n  }\r\n  private _appendTime(val: Date) {\r\n    if (!isDate(val)) val = new Date(val);\r\n    const parts = this.value.split(':');\r\n    val.setHours(parseInt(parts[0]), parseInt(parts[1]));\r\n    this._dateControl.setValue(val.toISOString(), { emitEvent: false });\r\n  }\r\n  private _validate(val: string): boolean {\r\n    if (!val) return !this._required;\r\n    const parts = val.split(':');\r\n    if (parts.length > 2)\r\n      return false;\r\n    for (let i = 0; i < parts.length; i++) {\r\n      if (!/\\d{1,2}/.test(parts[i]))\r\n        return false;\r\n      const part = parseInt(parts[i]);\r\n      if (isNaN(part))\r\n        return false;\r\n      else if (i === 0 && (part < 0 || part > 23))\r\n        return false;\r\n      else if (i === 1 && (part < 0 || part > 59)) return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.stateChanges.complete();\r\n    this._focusMonitor.stopMonitoring(this._elementRef);\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\n","<input matInput type=\"text\" [matAutocomplete]=\"auto\" [formControl]=\"control\" [placeholder]=\"placeholder\">\r\n<mat-autocomplete #auto>\r\n  <mat-option *ngFor=\"let o of options\" [value]=\"o\">{{o}}</mat-option>\r\n</mat-autocomplete>\r\n"]}