@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-errors.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** @docs-private */
+export function createMissingDateImplError(provider) {
+    return Error(`MatDatepicker: No provider found for ${provider}. You must import one of the following ` +
+        `modules at your application root: MatNativeDateModule, MatMomentDateModule, or provide a ` +
+        `custom implementation.`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXBpY2tlci1lcnJvcnMuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJzaGFyZWQvZ2lwaS1jb21wb25lbnRzL2RhdGVwaWNrZXIvbWF0LWRhdGVwaWNrZXIvZGF0ZXBpY2tlci1lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsb0JBQW9CO0FBQ3BCLE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxRQUFnQjtJQUN2RCxPQUFPLEtBQUssQ0FDUix3Q0FBd0MsUUFBUSx5Q0FBeUM7UUFDekYsMkZBQTJGO1FBQzNGLHdCQUF3QixDQUMzQixDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKiogQGRvY3MtcHJpdmF0ZSAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1pc3NpbmdEYXRlSW1wbEVycm9yKHByb3ZpZGVyOiBzdHJpbmcpIHtcbiAgICByZXR1cm4gRXJyb3IoXG4gICAgICAgIGBNYXREYXRlcGlja2VyOiBObyBwcm92aWRlciBmb3VuZCBmb3IgJHtwcm92aWRlcn0uIFlvdSBtdXN0IGltcG9ydCBvbmUgb2YgdGhlIGZvbGxvd2luZyBgICtcbiAgICAgICAgYG1vZHVsZXMgYXQgeW91ciBhcHBsaWNhdGlvbiByb290OiBNYXROYXRpdmVEYXRlTW9kdWxlLCBNYXRNb21lbnREYXRlTW9kdWxlLCBvciBwcm92aWRlIGEgYCArXG4gICAgICAgIGBjdXN0b20gaW1wbGVtZW50YXRpb24uYFxuICAgICk7XG59XG4iXX0=

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-input-base.js

@@ -0,0 +1,303 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata, __param } from "tslib";
+import { DOWN_ARROW } from '@angular/cdk/keycodes';
+import { ElementRef, EventEmitter, Inject, Input, Optional, Output, } from '@angular/core';
+import { Subject, Subscription } from 'rxjs';
+import { createMissingDateImplError } from './datepicker-errors';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { MAT_DATE_FORMATS } from './shared/adapter/date-formats';
+/**
+ * An event used for datepicker input and change events. We don't always have access to a native
+ * input or change event because the event may have been triggered by the user clicking on the
+ * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.
+ */
+export class MatDatepickerInputEvent {
+    constructor(
+    /** Reference to the datepicker input component that emitted the event. */
+    target, 
+    /** Reference to the native input element associated with the datepicker input. */
+    targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+}
+/** Base class for datepicker inputs. */
+let MatDatepickerInputBase = class MatDatepickerInputBase {
+    constructor(_elementRef, _dateAdapter, _dateFormats) {
+        this._elementRef = _elementRef;
+        this._dateAdapter = _dateAdapter;
+        this._dateFormats = _dateFormats;
+        /** Emits when a `change` event is fired on this `<input>`. */
+        this.dateChange = new EventEmitter();
+        /** Emits when an `input` event is fired on this `<input>`. */
+        this.dateInput = new EventEmitter();
+        /** Emits when the value changes (either due to user input or programmatic change). */
+        this._valueChange = new EventEmitter();
+        /** Emits when the internal state has changed */
+        this.stateChanges = new Subject();
+        this._onTouched = () => { };
+        this._validatorOnChange = () => { };
+        this._cvaOnChange = () => { };
+        this._valueChangesSubscription = Subscription.EMPTY;
+        this._localeSubscription = Subscription.EMPTY;
+        /** The form control validator for whether the input parses. */
+        this._parseValidator = () => {
+            return this._lastValueValid ? null : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };
+        };
+        /** The form control validator for the date filter. */
+        this._filterValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            const dateFilter = this._getDateFilter();
+            return !dateFilter || !controlValue || dateFilter(controlValue) ? null : { 'matDatepickerFilter': true };
+        };
+        /** The form control validator for the min date. */
+        this._minValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            const min = this._getMinDate();
+            return (!min || !controlValue || this._dateAdapter.compareDate(min, controlValue) <= 0) ? null : { 'matDatepickerMin': { 'min': min, 'actual': controlValue } };
+        };
+        /** The form control validator for the max date. */
+        this._maxValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            const max = this._getMaxDate();
+            return (!max || !controlValue || this._dateAdapter.compareDate(max, controlValue) >= 0) ? null : { 'matDatepickerMax': { 'max': max, 'actual': controlValue } };
+        };
+        /** Whether the last value set on the input was valid. */
+        this._lastValueValid = false;
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MAT_DATE_FORMATS');
+        }
+        // Update the displayed date when the locale changes.
+        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {
+            this.value = this.value;
+        });
+    }
+    /** The value of the input. */
+    get value() {
+        return this._model ? this._getValueFromModel(this._model.selection) : this._pendingValue;
+    }
+    set value(value) {
+        value = this._dateAdapter.deserialize(value);
+        this._lastValueValid = this._isValidValue(value);
+        value = this._dateAdapter.getValidDateOrNull(value);
+        const oldDate = this.value;
+        this._assignValue(value);
+        this._formatValue(value);
+        if (!this._dateAdapter.sameDate(oldDate, value)) {
+            this._valueChange.emit(value);
+        }
+    }
+    /** Whether the datepicker-input is disabled. */
+    get disabled() { return !!this._disabled || this._parentDisabled(); }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        const element = this._elementRef.nativeElement;
+        if (this._disabled !== newValue) {
+            this._disabled = newValue;
+            this.stateChanges.next(undefined);
+        }
+        // We need to null check the `blur` method, because it's undefined during SSR.
+        // In Ivy static bindings are invoked earlier, before the element is attached to the DOM.
+        // This can cause an error to be thrown in some browsers (IE/Edge) which assert that the
+        // element has been inserted.
+        if (newValue && this._isInitialized && element.blur) {
+            // Normally, native input elements automatically blur if they turn disabled. This behavior
+            // is problematic, because it would mean that it triggers another change detection cycle,
+            // which then causes a changed after checked error if the input element was focused before.
+            element.blur();
+        }
+    }
+    /** Gets the base validator functions. */
+    _getValidators() {
+        return [this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator];
+    }
+    /** Registers a date selection model with the input. */
+    _registerModel(model) {
+        this._model = model;
+        this._valueChangesSubscription.unsubscribe();
+        if (this._pendingValue) {
+            this._assignValue(this._pendingValue);
+        }
+        this._valueChangesSubscription = this._model.selectionChanged.subscribe(event => {
+            if (event.source !== this) {
+                const value = this._getValueFromModel(event.selection);
+                this._lastValueValid = this._isValidValue(value);
+                this._cvaOnChange(value);
+                this._onTouched();
+                this._formatValue(value);
+                // Note that we can't wrap the entire block with this logic, because for the range inputs
+                // we want to revalidate whenever either one of the inputs changes and we don't have a
+                // good way of distinguishing it at the moment.
+                if (this._canEmitChangeEvent(event)) {
+                    this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
+                    this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
+                }
+                if (this._outsideValueChanged) {
+                    this._outsideValueChanged();
+                }
+            }
+        });
+    }
+    ngAfterViewInit() {
+        this._isInitialized = true;
+    }
+    ngOnChanges(changes) {
+        if (dateInputsHaveChanged(changes, this._dateAdapter)) {
+            this.stateChanges.next(undefined);
+        }
+    }
+    ngOnDestroy() {
+        this._valueChangesSubscription.unsubscribe();
+        this._localeSubscription.unsubscribe();
+        this._valueChange.complete();
+        this.stateChanges.complete();
+    }
+    /** @docs-private */
+    registerOnValidatorChange(fn) {
+        this._validatorOnChange = fn;
+    }
+    /** @docs-private */
+    validate(c) {
+        return this._validator ? this._validator(c) : null;
+    }
+    // Implemented as part of ControlValueAccessor.
+    writeValue(value) {
+        this.value = value;
+    }
+    // Implemented as part of ControlValueAccessor.
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    // Implemented as part of ControlValueAccessor.
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // Implemented as part of ControlValueAccessor.
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    _onKeydown(event) {
+        const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;
+        if (isAltDownArrow && !this._elementRef.nativeElement.readOnly) {
+            this._openPopup();
+            event.preventDefault();
+        }
+    }
+    _onInput(value) {
+        const lastValueWasValid = this._lastValueValid;
+        let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);
+        this._lastValueValid = this._isValidValue(date);
+        date = this._dateAdapter.getValidDateOrNull(date);
+        if (!this._dateAdapter.sameDate(date, this.value)) {
+            this._assignValue(date);
+            this._cvaOnChange(date);
+            this._valueChange.emit(date);
+            this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
+        }
+        else {
+            // Call the CVA change handler for invalid values
+            // since this is what marks the control as dirty.
+            if (value && !this.value) {
+                this._cvaOnChange(date);
+            }
+            if (lastValueWasValid !== this._lastValueValid) {
+                this._validatorOnChange();
+            }
+        }
+    }
+    _onChange() {
+        this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    /** Handles blur events on the input. */
+    _onBlur() {
+        // Reformat the input only if we have a valid value.
+        if (this.value) {
+            this._formatValue(this.value);
+        }
+        this._onTouched();
+    }
+    /** Formats a value and sets it on the input element. */
+    _formatValue(value) {
+        this._elementRef.nativeElement.value =
+            value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';
+    }
+    /** Assigns a value to the model. */
+    _assignValue(value) {
+        // We may get some incoming values before the model was
+        // assigned. Save the value so that we can assign it later.
+        if (this._model) {
+            this._assignValueToModel(value);
+            this._pendingValue = null;
+        }
+        else {
+            this._pendingValue = value;
+        }
+    }
+    /** Whether a value is considered valid. */
+    _isValidValue(value) {
+        return !value || this._dateAdapter.isValid(value);
+    }
+    /**
+     * Checks whether a parent control is disabled. This is in place so that it can be overridden
+     * by inputs extending this one which can be placed inside of a group that can be disabled.
+     */
+    _parentDisabled() {
+        return false;
+    }
+};
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatDatepickerInputBase.prototype, "value", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], MatDatepickerInputBase.prototype, "disabled", null);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerInputBase.prototype, "dateChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerInputBase.prototype, "dateInput", void 0);
+MatDatepickerInputBase = __decorate([
+    __param(1, Optional()),
+    __param(2, Optional()), __param(2, Inject(MAT_DATE_FORMATS)),
+    __metadata("design:paramtypes", [ElementRef,
+        DateAdapter, Object])
+], MatDatepickerInputBase);
+export { MatDatepickerInputBase };
+/**
+ * Checks whether the `SimpleChanges` object from an `ngOnChanges`
+ * callback has any changes, accounting for date objects.
+ */
+export function dateInputsHaveChanged(changes, adapter) {
+    const keys = Object.keys(changes);
+    for (let key of keys) {
+        const { previousValue, currentValue } = changes[key];
+        if (adapter.isDateInstance(previousValue) && adapter.isDateInstance(currentValue)) {
+            if (!adapter.sameDate(previousValue, currentValue)) {
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-input-base.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-input-base.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { DOWN_ARROW } from '@angular/cdk/keycodes';\nimport { AfterViewInit, Directive, ElementRef, EventEmitter, Inject, Input, OnChanges, OnDestroy, Optional, Output, SimpleChanges, } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, ValidationErrors, Validator, ValidatorFn, } from '@angular/forms';\nimport { Subject, Subscription } from 'rxjs';\nimport { DateSelectionModelChange, ExtractDateTypeFromSelection, MatDateSelectionModel, } from './date-selection-model';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { DateAdapter } from './shared/adapter/date-adapter';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { MAT_DATE_FORMATS, MatDateFormats } from './shared/adapter/date-formats';\n\n\n/**\n * An event used for datepicker input and change events. We don't always have access to a native\n * input or change event because the event may have been triggered by the user clicking on the\n * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.\n */\nexport class MatDatepickerInputEvent<D, S = unknown> {\n    /** The new value for the target datepicker input. */\n    value: D | null;\n\n    constructor(\n        /** Reference to the datepicker input component that emitted the event. */\n        public target: MatDatepickerInputBase<S, D>,\n        /** Reference to the native input element associated with the datepicker input. */\n        public targetElement: HTMLElement) {\n        this.value = this.target.value;\n    }\n}\n\n/** Function that can be used to filter out dates from a calendar. */\nexport type DateFilterFn<D> = (date: D | null) => boolean;\n\n/** Base class for datepicker inputs. */\nexport abstract class MatDatepickerInputBase<S, D = ExtractDateTypeFromSelection<S>> implements ControlValueAccessor, AfterViewInit, OnChanges, OnDestroy, Validator {\n\n    /** Whether the component has been initialized. */\n    private _isInitialized: boolean;\n\n    /** The value of the input. */\n    @Input()\n    get value(): D | null {\n        return this._model ? this._getValueFromModel(this._model.selection) : this._pendingValue;\n    }\n    set value(value: D | null) {\n        value = this._dateAdapter.deserialize(value);\n        this._lastValueValid = this._isValidValue(value);\n        value = this._dateAdapter.getValidDateOrNull(value);\n        const oldDate = this.value;\n        this._assignValue(value);\n        this._formatValue(value);\n\n        if (!this._dateAdapter.sameDate(oldDate, value)) {\n            this._valueChange.emit(value);\n        }\n    }\n    protected _model: MatDateSelectionModel<S, D> | undefined;\n\n    /** Whether the datepicker-input is disabled. */\n    @Input()\n    get disabled(): boolean { return !!this._disabled || this._parentDisabled(); }\n    set disabled(value: boolean) {\n        const newValue = coerceBooleanProperty(value);\n        const element = this._elementRef.nativeElement;\n\n        if (this._disabled !== newValue) {\n            this._disabled = newValue;\n            this.stateChanges.next(undefined);\n        }\n\n        // We need to null check the `blur` method, because it's undefined during SSR.\n        // In Ivy static bindings are invoked earlier, before the element is attached to the DOM.\n        // This can cause an error to be thrown in some browsers (IE/Edge) which assert that the\n        // element has been inserted.\n        if (newValue && this._isInitialized && element.blur) {\n            // Normally, native input elements automatically blur if they turn disabled. This behavior\n            // is problematic, because it would mean that it triggers another change detection cycle,\n            // which then causes a changed after checked error if the input element was focused before.\n            element.blur();\n        }\n    }\n    private _disabled: boolean;\n\n    /** Emits when a `change` event is fired on this `<input>`. */\n    @Output() readonly dateChange: EventEmitter<MatDatepickerInputEvent<D, S>> = new EventEmitter<MatDatepickerInputEvent<D, S>>();\n\n    /** Emits when an `input` event is fired on this `<input>`. */\n    @Output() readonly dateInput: EventEmitter<MatDatepickerInputEvent<D, S>> = new EventEmitter<MatDatepickerInputEvent<D, S>>();\n\n    /** Emits when the value changes (either due to user input or programmatic change). */\n    _valueChange = new EventEmitter<D | null>();\n\n    /** Emits when the internal state has changed */\n    stateChanges = new Subject<void>();\n\n    _onTouched = () => { };\n    _validatorOnChange = () => { };\n\n    protected _cvaOnChange: (value: any) => void = () => { };\n    private _valueChangesSubscription = Subscription.EMPTY;\n    private _localeSubscription = Subscription.EMPTY;\n\n    /**\n     * Since the value is kept on the model which is assigned in an Input,\n     * we might get a value before we have a model. This property keeps track\n     * of the value until we have somewhere to assign it.\n     */\n    private _pendingValue: D | null;\n\n    /** The form control validator for whether the input parses. */\n    private _parseValidator: ValidatorFn = (): ValidationErrors | null => {\n        return this._lastValueValid ? null : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };\n    }\n\n    /** The form control validator for the date filter. */\n    private _filterValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        const dateFilter = this._getDateFilter();\n        return !dateFilter || !controlValue || dateFilter(controlValue) ? null : { 'matDatepickerFilter': true };\n    }\n\n    /** The form control validator for the min date. */\n    private _minValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        const min = this._getMinDate();\n        return (!min || !controlValue || this._dateAdapter.compareDate(min, controlValue) <= 0) ? null : { 'matDatepickerMin': { 'min': min, 'actual': controlValue } };\n    }\n\n    /** The form control validator for the max date. */\n    private _maxValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        const max = this._getMaxDate();\n        return (!max || !controlValue || this._dateAdapter.compareDate(max, controlValue) >= 0) ? null : { 'matDatepickerMax': { 'max': max, 'actual': controlValue } };\n    }\n\n    /** Gets the base validator functions. */\n    protected _getValidators(): ValidatorFn[] {\n        return [this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator];\n    }\n\n    /** Gets the minimum date for the input. Used for validation. */\n    abstract _getMinDate(): D | null;\n\n    /** Gets the maximum date for the input. Used for validation. */\n    abstract _getMaxDate(): D | null;\n\n    /** Gets the date filter function. Used for validation. */\n    protected abstract _getDateFilter(): DateFilterFn<D> | undefined;\n\n    /** Registers a date selection model with the input. */\n    _registerModel(model: MatDateSelectionModel<S, D>): void {\n        this._model = model;\n        this._valueChangesSubscription.unsubscribe();\n\n        if (this._pendingValue) {\n            this._assignValue(this._pendingValue);\n        }\n\n        this._valueChangesSubscription = this._model.selectionChanged.subscribe(event => {\n            if (event.source !== this) {\n                const value = this._getValueFromModel(event.selection);\n                this._lastValueValid = this._isValidValue(value);\n                this._cvaOnChange(value);\n                this._onTouched();\n                this._formatValue(value);\n\n                // Note that we can't wrap the entire block with this logic, because for the range inputs\n                // we want to revalidate whenever either one of the inputs changes and we don't have a\n                // good way of distinguishing it at the moment.\n                if (this._canEmitChangeEvent(event)) {\n                    this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n                    this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n                }\n\n                if (this._outsideValueChanged) {\n                    this._outsideValueChanged();\n                }\n            }\n        });\n    }\n\n    /** Opens the popup associated with the input. */\n    protected abstract _openPopup(): void;\n\n    /** Assigns a value to the input's model. */\n    protected abstract _assignValueToModel(model: D | null): void;\n\n    /** Converts a value from the model into a native value for the input. */\n    protected abstract _getValueFromModel(modelValue: S): D | null;\n\n    /** Combined form control validator for this input. */\n    protected abstract _validator: ValidatorFn | null;\n\n    /**\n     * Callback that'll be invoked when the selection model is changed\n     * from somewhere that's not the current datepicker input.\n     */\n    protected abstract _outsideValueChanged?: () => void;\n\n    /** Predicate that determines whether we're allowed to emit a particular change event. */\n    protected abstract _canEmitChangeEvent(event: DateSelectionModelChange<S>): boolean;\n\n    /** Whether the last value set on the input was valid. */\n    protected _lastValueValid = false;\n\n    constructor(\n        protected _elementRef: ElementRef<HTMLInputElement>,\n        @Optional() public _dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) private _dateFormats: MatDateFormats\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n\n        // Update the displayed date when the locale changes.\n        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {\n            this.value = this.value;\n        });\n    }\n\n    ngAfterViewInit() {\n        this._isInitialized = true;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (dateInputsHaveChanged(changes, this._dateAdapter)) {\n            this.stateChanges.next(undefined);\n        }\n    }\n\n    ngOnDestroy() {\n        this._valueChangesSubscription.unsubscribe();\n        this._localeSubscription.unsubscribe();\n        this._valueChange.complete();\n        this.stateChanges.complete();\n    }\n\n    /** @docs-private */\n    registerOnValidatorChange(fn: () => void): void {\n        this._validatorOnChange = fn;\n    }\n\n    /** @docs-private */\n    validate(c: AbstractControl): ValidationErrors | null {\n        return this._validator ? this._validator(c) : null;\n    }\n\n    // Implemented as part of ControlValueAccessor.\n    writeValue(value: D): void {\n        this.value = value;\n    }\n\n    // Implemented as part of ControlValueAccessor.\n    registerOnChange(fn: (value: any) => void): void {\n        this._cvaOnChange = fn;\n    }\n\n    // Implemented as part of ControlValueAccessor.\n    registerOnTouched(fn: () => void): void {\n        this._onTouched = fn;\n    }\n\n    // Implemented as part of ControlValueAccessor.\n    setDisabledState(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n    }\n\n    _onKeydown(event: KeyboardEvent) {\n        const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\n\n        if (isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\n            this._openPopup();\n            event.preventDefault();\n        }\n    }\n\n    _onInput(value: string) {\n        const lastValueWasValid = this._lastValueValid;\n        let date = this._dateAdapter.parse(value, this._dateFormats.parse.dateInput);\n        this._lastValueValid = this._isValidValue(date);\n        date = this._dateAdapter.getValidDateOrNull(date);\n\n        if (!this._dateAdapter.sameDate(date, this.value)) {\n            this._assignValue(date);\n            this._cvaOnChange(date);\n            this._valueChange.emit(date);\n            this.dateInput.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n        } else {\n            // Call the CVA change handler for invalid values\n            // since this is what marks the control as dirty.\n            if (value && !this.value) {\n                this._cvaOnChange(date);\n            }\n\n            if (lastValueWasValid !== this._lastValueValid) {\n                this._validatorOnChange();\n            }\n        }\n    }\n\n    _onChange() {\n        this.dateChange.emit(new MatDatepickerInputEvent(this, this._elementRef.nativeElement));\n    }\n\n    /** Handles blur events on the input. */\n    _onBlur() {\n        // Reformat the input only if we have a valid value.\n        if (this.value) {\n            this._formatValue(this.value);\n        }\n\n        this._onTouched();\n    }\n\n    /** Formats a value and sets it on the input element. */\n    protected _formatValue(value: D | null) {\n        this._elementRef.nativeElement.value =\n            value ? this._dateAdapter.format(value, this._dateFormats.display.dateInput) : '';\n    }\n\n    /** Assigns a value to the model. */\n    private _assignValue(value: D | null) {\n        // We may get some incoming values before the model was\n        // assigned. Save the value so that we can assign it later.\n        if (this._model) {\n            this._assignValueToModel(value);\n            this._pendingValue = null;\n        } else {\n            this._pendingValue = value;\n        }\n    }\n\n    /** Whether a value is considered valid. */\n    private _isValidValue(value: D | null): boolean {\n        return !value || this._dateAdapter.isValid(value);\n    }\n\n    /**\n     * Checks whether a parent control is disabled. This is in place so that it can be overridden\n     * by inputs extending this one which can be placed inside of a group that can be disabled.\n     */\n    protected _parentDisabled() {\n        return false;\n    }\n\n}\n\n/**\n * Checks whether the `SimpleChanges` object from an `ngOnChanges`\n * callback has any changes, accounting for date objects.\n */\nexport function dateInputsHaveChanged(changes: SimpleChanges, adapter: DateAdapter<unknown>): boolean {\n    const keys = Object.keys(changes);\n\n    for (let key of keys) {\n        const { previousValue, currentValue } = changes[key];\n\n        if (adapter.isDateInstance(previousValue) && adapter.isDateInstance(currentValue)) {\n            if (!adapter.sameDate(previousValue, currentValue)) {\n                return true;\n            }\n        } else {\n            return true;\n        }\n    }\n\n    return false;\n}\n"]}

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-input.js

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var MatDatepickerInput_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { Directive, ElementRef, forwardRef, Inject, InjectionToken, Input, Optional, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
+import { MAT_DATE_FORMATS, } from '@angular/material/core';
+import { MatFormField } from '@angular/material/form-field';
+import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
+import { MatDatepicker } from './datepicker';
+import { MatDatepickerInputBase } from './datepicker-input-base';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** @docs-private */
+export const MAT_DATEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => MatDatepickerInput),
+    multi: true
+};
+/** @docs-private */
+export const MAT_DATEPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => MatDatepickerInput),
+    multi: true
+};
+export const MAT_FORM_FIELD = new InjectionToken('MatFormField');
+/** Directive used to connect an input to a MatDatepicker. */
+let MatDatepickerInput = MatDatepickerInput_1 = class MatDatepickerInput extends MatDatepickerInputBase {
+    constructor(elementRef, dateAdapter, dateFormats, _formField) {
+        super(elementRef, dateAdapter, dateFormats);
+        this._formField = _formField;
+        this._validator = Validators.compose(super._getValidators());
+    }
+    /** The datepicker that this input is associated with. */
+    set gipiMatDatepicker(datepicker) {
+        if (datepicker) {
+            this._datepicker = datepicker;
+            this._registerModel(datepicker._registerInput(this));
+        }
+    }
+    /** The minimum valid date. */
+    get min() { return this._min; }
+    set min(value) {
+        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        if (!this._dateAdapter.sameDate(validValue, this._min)) {
+            this._min = validValue;
+            this._validatorOnChange();
+        }
+    }
+    /** The maximum valid date. */
+    get max() { return this._max; }
+    set max(value) {
+        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        if (!this._dateAdapter.sameDate(validValue, this._max)) {
+            this._max = validValue;
+            this._validatorOnChange();
+        }
+    }
+    /** Function that can be used to filter out dates within the datepicker. */
+    get dateFilter() { return this._dateFilter; }
+    set dateFilter(value) {
+        this._dateFilter = value;
+        this._validatorOnChange();
+    }
+    /**
+     * Gets the element that the datepicker popup should be connected to.
+     * @return The element to connect the popup to.
+     */
+    getConnectedOverlayOrigin() {
+        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
+    }
+    /** Returns the palette used by the input's form field, if any. */
+    getThemePalette() {
+        return this._formField ? this._formField.color : undefined;
+    }
+    /** Gets the value at which the calendar should start. */
+    getStartValue() {
+        return this.value;
+    }
+    /**
+     * @deprecated
+     * @breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead
+     */
+    getPopupConnectionElementRef() {
+        return this.getConnectedOverlayOrigin();
+    }
+    /** Opens the associated datepicker. */
+    _openPopup() {
+        if (this._datepicker) {
+            this._datepicker.open();
+        }
+    }
+    _getValueFromModel(modelValue) {
+        return modelValue;
+    }
+    _assignValueToModel(value) {
+        if (this._model) {
+            this._model.updateSelection(value, this);
+        }
+    }
+    /** Gets the input's minimum date. */
+    _getMinDate() {
+        return this._min;
+    }
+    /** Gets the input's maximum date. */
+    _getMaxDate() {
+        return this._max;
+    }
+    /** Gets the input's date filtering function. */
+    _getDateFilter() {
+        return this._dateFilter;
+    }
+    _canEmitChangeEvent() {
+        return true;
+    }
+};
+MatDatepickerInput.ctorParameters = () => [
+    { type: ElementRef },
+    { type: DateAdapter, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
+    { type: MatFormField, decorators: [{ type: Optional }, { type: Inject, args: [MAT_FORM_FIELD,] }] }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", MatDatepicker),
+    __metadata("design:paramtypes", [MatDatepicker])
+], MatDatepickerInput.prototype, "gipiMatDatepicker", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatDatepickerInput.prototype, "min", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatDatepickerInput.prototype, "max", null);
+__decorate([
+    Input('gipiMatDatepickerFilter'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function])
+], MatDatepickerInput.prototype, "dateFilter", null);
+MatDatepickerInput = MatDatepickerInput_1 = __decorate([
+    Directive({
+        selector: 'input[gipiMatDatepicker]',
+        providers: [
+            MAT_DATEPICKER_VALUE_ACCESSOR,
+            MAT_DATEPICKER_VALIDATORS,
+            { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput_1 },
+        ],
+        host: {
+            'class': 'mat-datepicker-input',
+            '[attr.aria-haspopup]': '_datepicker ? "dialog" : null',
+            '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',
+            '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',
+            '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',
+            // Used by the test harness to tie this input to its calendar. We can't depend on
+            // `aria-owns` for this, because it's only defined while the calendar is open.
+            '[attr.data-mat-calendar]': '_datepicker ? _datepicker.id : null',
+            '[disabled]': 'disabled',
+            '(input)': '_onInput($event.target.value)',
+            '(change)': '_onChange()',
+            '(blur)': '_onBlur()',
+            '(keydown)': '_onKeydown($event)',
+        },
+        exportAs: 'gipiMatDatepickerInput',
+    }),
+    __param(1, Optional()),
+    __param(2, Optional()), __param(2, Inject(MAT_DATE_FORMATS)),
+    __param(3, Optional()), __param(3, Inject(MAT_FORM_FIELD)),
+    __metadata("design:paramtypes", [ElementRef,
+        DateAdapter, Object, MatFormField])
+], MatDatepickerInput);
+export { MatDatepickerInput };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-input.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-input.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Directive, ElementRef, forwardRef, Inject, InjectionToken, Input, Optional, } from '@angular/core';\nimport { NG_VALIDATORS, NG_VALUE_ACCESSOR, ValidatorFn, Validators, } from '@angular/forms';\nimport { MAT_DATE_FORMATS, MatDateFormats, ThemePalette, } from '@angular/material/core';\nimport { MatFormField } from '@angular/material/form-field';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\nimport { MatDatepicker } from './datepicker';\nimport { MatDatepickerControl } from './datepicker-base';\nimport { DateFilterFn, MatDatepickerInputBase } from './datepicker-input-base';\nimport { DateAdapter } from './shared/adapter/date-adapter';\n\n/** @docs-private */\nexport const MAT_DATEPICKER_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => MatDatepickerInput),\n    multi: true\n};\n\n/** @docs-private */\nexport const MAT_DATEPICKER_VALIDATORS: any = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => MatDatepickerInput),\n    multi: true\n};\n\nexport const MAT_FORM_FIELD = new InjectionToken<MatFormField>('MatFormField');\n\n/** Directive used to connect an input to a MatDatepicker. */\n@Directive({\n    selector: 'input[gipiMatDatepicker]',\n    providers: [\n        MAT_DATEPICKER_VALUE_ACCESSOR,\n        MAT_DATEPICKER_VALIDATORS,\n        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MatDatepickerInput },\n    ],\n    host: {\n        'class': 'mat-datepicker-input',\n        '[attr.aria-haspopup]': '_datepicker ? \"dialog\" : null',\n        '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',\n        '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',\n        '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',\n        // Used by the test harness to tie this input to its calendar. We can't depend on\n        // `aria-owns` for this, because it's only defined while the calendar is open.\n        '[attr.data-mat-calendar]': '_datepicker ? _datepicker.id : null',\n        '[disabled]': 'disabled',\n        '(input)': '_onInput($event.target.value)',\n        '(change)': '_onChange()',\n        '(blur)': '_onBlur()',\n        '(keydown)': '_onKeydown($event)',\n    },\n    exportAs: 'gipiMatDatepickerInput',\n})\nexport class MatDatepickerInput<D> extends MatDatepickerInputBase<D | null, D> implements MatDatepickerControl<D | null> {\n\n    /** The datepicker that this input is associated with. */\n    @Input()\n    set gipiMatDatepicker(datepicker: MatDatepicker<D>) {\n        if (datepicker) {\n            this._datepicker = datepicker;\n            this._registerModel(datepicker._registerInput(this));\n        }\n    }\n    _datepicker: MatDatepicker<D>;\n\n    /** The minimum valid date. */\n    @Input()\n    get min(): D | null { return this._min; }\n    set min(value: D | null) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n\n        if (!this._dateAdapter.sameDate(validValue, this._min)) {\n            this._min = validValue;\n            this._validatorOnChange();\n        }\n    }\n    private _min: D | null;\n\n    /** The maximum valid date. */\n    @Input()\n    get max(): D | null { return this._max; }\n    set max(value: D | null) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n\n        if (!this._dateAdapter.sameDate(validValue, this._max)) {\n            this._max = validValue;\n            this._validatorOnChange();\n        }\n    }\n    private _max: D | null;\n\n    /** Function that can be used to filter out dates within the datepicker. */\n    @Input('gipiMatDatepickerFilter')\n    get dateFilter() { return this._dateFilter; }\n    set dateFilter(value: DateFilterFn<D | null>) {\n        this._dateFilter = value;\n        this._validatorOnChange();\n    }\n    private _dateFilter: DateFilterFn<D | null>;\n\n    /** The combined form control validator for this input. */\n    protected _validator: ValidatorFn | null;\n\n    constructor(\n        elementRef: ElementRef<HTMLInputElement>,\n        @Optional() dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) dateFormats: MatDateFormats,\n        @Optional() @Inject(MAT_FORM_FIELD) private _formField: MatFormField\n    ) {\n        super(elementRef, dateAdapter, dateFormats);\n        this._validator = Validators.compose(super._getValidators());\n    }\n\n    /**\n     * Gets the element that the datepicker popup should be connected to.\n     * @return The element to connect the popup to.\n     */\n    getConnectedOverlayOrigin(): ElementRef {\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n    }\n\n    /** Returns the palette used by the input's form field, if any. */\n    getThemePalette(): ThemePalette {\n        return this._formField ? this._formField.color : undefined;\n    }\n\n    /** Gets the value at which the calendar should start. */\n    getStartValue(): D | null {\n        return this.value;\n    }\n\n    /**\n     * @deprecated\n     * @breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead\n     */\n    getPopupConnectionElementRef(): ElementRef {\n        return this.getConnectedOverlayOrigin();\n    }\n\n    /** Opens the associated datepicker. */\n    protected _openPopup(): void {\n        if (this._datepicker) {\n            this._datepicker.open();\n        }\n    }\n\n    protected _getValueFromModel(modelValue: D | null): D | null {\n        return modelValue;\n    }\n\n    protected _assignValueToModel(value: D | null): void {\n        if (this._model) {\n            this._model.updateSelection(value, this);\n        }\n    }\n\n    /** Gets the input's minimum date. */\n    _getMinDate() {\n        return this._min;\n    }\n\n    /** Gets the input's maximum date. */\n    _getMaxDate() {\n        return this._max;\n    }\n\n    /** Gets the input's date filtering function. */\n    protected _getDateFilter() {\n        return this._dateFilter;\n    }\n\n    protected _canEmitChangeEvent() {\n        return true;\n    }\n\n    // Unnecessary when selecting a single date.\n    protected _outsideValueChanged: undefined;\n\n}\n"]}

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-intl.js

@@ -0,0 +1,51 @@
+import { __decorate } from "tslib";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/** Datepicker data that requires internationalization. */
+let MatDatepickerIntl = class MatDatepickerIntl {
+    constructor() {
+        /**
+         * Stream that emits whenever the labels here are changed. Use this to notify
+         * components if the labels have changed after initialization.
+         */
+        this.changes = new Subject();
+        /** A label for the calendar popup (used by screen readers). */
+        this.calendarLabel = 'Calendar';
+        /** A label for the button used to open the calendar popup (used by screen readers). */
+        this.openCalendarLabel = 'Open calendar';
+        /** A label for the previous month button (used by screen readers). */
+        this.prevMonthLabel = 'Previous month';
+        /** A label for the next month button (used by screen readers). */
+        this.nextMonthLabel = 'Next month';
+        /** A label for the previous year button (used by screen readers). */
+        this.prevYearLabel = 'Previous year';
+        /** A label for the next year button (used by screen readers). */
+        this.nextYearLabel = 'Next year';
+        /** A label for the previous multi-year button (used by screen readers). */
+        this.prevMultiYearLabel = 'Previous 20 years';
+        /** A label for the next multi-year button (used by screen readers). */
+        this.nextMultiYearLabel = 'Next 20 years';
+        /** A label for the 'switch to month view' button (used by screen readers). */
+        this.switchToMonthViewLabel = 'Choose date';
+        /** A label for the 'switch to year view' button (used by screen readers). */
+        this.switchToMultiYearViewLabel = 'Choose month and year';
+    }
+    /** Formats a range of years. */
+    formatYearRange(start, end) {
+        return `${start} \u2013 ${end}`;
+    }
+};
+MatDatepickerIntl.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function MatDatepickerIntl_Factory() { return new MatDatepickerIntl(); }, token: MatDatepickerIntl, providedIn: "root" });
+MatDatepickerIntl = __decorate([
+    Injectable({ providedIn: 'root' })
+], MatDatepickerIntl);
+export { MatDatepickerIntl };
+//# sourceMappingURL=data:application/json;base64,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