@ng-matero/extensions 15.5.1 → 16.0.0

package/esm2022/datetimepicker/datetimepicker-input.mjs

@@ -0,0 +1,350 @@
+import { Directive, EventEmitter, forwardRef, Inject, Input, Optional, Output, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DOWN_ARROW } from '@angular/cdk/keycodes';
+import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
+import { Subscription } from 'rxjs';
+import { MTX_DATETIME_FORMATS, } from '@ng-matero/extensions/core';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { MtxDatetimepickerFilterType } from './datetimepicker-filtertype';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-matero/extensions/core";
+import * as i2 from "@angular/material/form-field";
+export const MAT_DATETIMEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => MtxDatetimepickerInput),
+    multi: true,
+};
+export const MAT_DATETIMEPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => MtxDatetimepickerInput),
+    multi: true,
+};
+/**
+ * An event used for datetimepicker 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 MtxDatetimepickerInputEvent instead.
+ */
+export class MtxDatetimepickerInputEvent {
+    constructor(target, targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+}
+/** Directive used to connect an input to a MtxDatetimepicker. */
+class MtxDatetimepickerInput {
+    constructor(_elementRef, _dateAdapter, _dateFormats, _formField) {
+        this._elementRef = _elementRef;
+        this._dateAdapter = _dateAdapter;
+        this._dateFormats = _dateFormats;
+        this._formField = _formField;
+        /** 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 disabled state has changed */
+        this._disabledChange = new EventEmitter();
+        this._datetimepickerSubscription = Subscription.EMPTY;
+        this._localeSubscription = Subscription.EMPTY;
+        /** Whether the last value set on the input was valid. */
+        this._lastValueValid = false;
+        this._onTouched = () => { };
+        this._cvaOnChange = () => { };
+        this._validatorOnChange = () => { };
+        /** The form control validator for whether the input parses. */
+        this._parseValidator = () => {
+            return this._lastValueValid
+                ? null
+                : { mtxDatetimepickerParse: { text: this._elementRef.nativeElement.value } };
+        };
+        /** The form control validator for the min date. */
+        this._minValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this.min ||
+                !controlValue ||
+                this._dateAdapter.compareDatetime(this.min, controlValue) <= 0
+                ? null
+                : { mtxDatetimepickerMin: { min: this.min, actual: controlValue } };
+        };
+        /** The form control validator for the max date. */
+        this._maxValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this.max ||
+                !controlValue ||
+                this._dateAdapter.compareDatetime(this.max, controlValue) >= 0
+                ? null
+                : { mtxDatetimepickerMax: { max: this.max, actual: controlValue } };
+        };
+        /** The form control validator for the date filter. */
+        this._filterValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this._dateFilter ||
+                !controlValue ||
+                this._dateFilter(controlValue, MtxDatetimepickerFilterType.DATE)
+                ? null
+                : { mtxDatetimepickerFilter: true };
+        };
+        /** The combined form control validator for this input. */
+        this._validator = Validators.compose([
+            this._parseValidator,
+            this._minValidator,
+            this._maxValidator,
+            this._filterValidator,
+        ]);
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MTX_DATETIME_FORMATS');
+        }
+        // Update the displayed date when the locale changes.
+        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {
+            this.value = this._dateAdapter.deserialize(this.value);
+        });
+    }
+    /** The datetimepicker that this input is associated with. */
+    set mtxDatetimepicker(value) {
+        this.registerDatetimepicker(value);
+    }
+    set mtxDatetimepickerFilter(filter) {
+        this._dateFilter = filter;
+        this._validatorOnChange();
+    }
+    /** The value of the input. */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        value = this._dateAdapter.deserialize(value);
+        this._lastValueValid = !value || this._dateAdapter.isValid(value);
+        value = this._dateAdapter.getValidDateOrNull(value);
+        const oldDate = this.value;
+        this._value = value;
+        this._formatValue(value);
+        // use timeout to ensure the datetimepicker is instantiated and we get the correct format
+        setTimeout(() => {
+            if (!this._dateAdapter.sameDatetime(oldDate, value)) {
+                this._valueChange.emit(value);
+            }
+        });
+    }
+    /** The minimum valid date. */
+    get min() {
+        return this._min;
+    }
+    set min(value) {
+        this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    /** The maximum valid date. */
+    get max() {
+        return this._max;
+    }
+    set max(value) {
+        this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    /** Whether the datetimepicker-input is disabled. */
+    get disabled() {
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (this._disabled !== newValue) {
+            this._disabled = newValue;
+            this._disabledChange.emit(newValue);
+        }
+    }
+    ngAfterContentInit() {
+        if (this._datetimepicker) {
+            this._datetimepickerSubscription = this._datetimepicker.selectedChanged.subscribe((selected) => {
+                this.value = selected;
+                this._cvaOnChange(selected);
+                this._onTouched();
+                this.dateInput.emit(new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+                this.dateChange.emit(new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._datetimepickerSubscription.unsubscribe();
+        this._localeSubscription.unsubscribe();
+        this._valueChange.complete();
+        this._disabledChange.complete();
+    }
+    registerOnValidatorChange(fn) {
+        this._validatorOnChange = fn;
+    }
+    validate(c) {
+        return this._validator ? this._validator(c) : null;
+    }
+    /**
+     * Gets the element that the datetimepicker popup should be connected to.
+     * @return The element to connect the popup to.
+     */
+    getConnectedOverlayOrigin() {
+        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
+    }
+    /** Gets the ID of an element that should be used a description for the calendar overlay. */
+    getOverlayLabelId() {
+        if (this._formField) {
+            return this._formField.getLabelId();
+        }
+        return this._elementRef.nativeElement.getAttribute('aria-labelledby');
+    }
+    // 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(disabled) {
+        this.disabled = disabled;
+    }
+    _onKeydown(event) {
+        if (event.altKey && event.keyCode === DOWN_ARROW) {
+            this._datetimepicker.open();
+            event.preventDefault();
+        }
+    }
+    _onInput(value) {
+        let date = this._dateAdapter.parse(value, this.getParseFormat());
+        this._lastValueValid = !date || this._dateAdapter.isValid(date);
+        date = this._dateAdapter.getValidDateOrNull(date);
+        this._value = date;
+        this._cvaOnChange(date);
+        this._valueChange.emit(date);
+        this.dateInput.emit(new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    _onChange() {
+        this.dateChange.emit(new MtxDatetimepickerInputEvent(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();
+    }
+    registerDatetimepicker(value) {
+        if (value) {
+            this._datetimepicker = value;
+            this._datetimepicker._registerInput(this);
+        }
+    }
+    getDisplayFormat() {
+        switch (this._datetimepicker.type) {
+            case 'date':
+                return this._dateFormats.display.dateInput;
+            case 'datetime':
+                return this._dateFormats.display.datetimeInput;
+            case 'time':
+                return this._dateFormats.display.timeInput;
+            case 'month':
+                return this._dateFormats.display.monthInput;
+            case 'year':
+                return this._dateFormats.display.yearInput;
+        }
+    }
+    getParseFormat() {
+        let parseFormat;
+        switch (this._datetimepicker.type) {
+            case 'date':
+                parseFormat = this._dateFormats.parse.dateInput;
+                break;
+            case 'datetime':
+                parseFormat = this._dateFormats.parse.datetimeInput;
+                break;
+            case 'time':
+                parseFormat = this._dateFormats.parse.timeInput;
+                break;
+            case 'month':
+                parseFormat = this._dateFormats.parse.monthInput;
+                break;
+            case 'year':
+                parseFormat = this._dateFormats.parse.yearInput;
+                break;
+        }
+        if (!parseFormat) {
+            parseFormat = this._dateFormats.parse.dateInput;
+        }
+        return parseFormat;
+    }
+    /** Formats a value and sets it on the input element. */
+    _formatValue(value) {
+        this._elementRef.nativeElement.value = value
+            ? this._dateAdapter.format(value, this.getDisplayFormat())
+            : '';
+    }
+    /** Returns the palette used by the input's form field, if any. */
+    getThemePalette() {
+        return this._formField ? this._formField.color : undefined;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerInput, deps: [{ token: i0.ElementRef }, { token: i1.DatetimeAdapter, optional: true }, { token: MTX_DATETIME_FORMATS, optional: true }, { token: i2.MatFormField, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.3", type: MtxDatetimepickerInput, selector: "input[mtxDatetimepicker]", inputs: { mtxDatetimepicker: "mtxDatetimepicker", mtxDatetimepickerFilter: "mtxDatetimepickerFilter", value: "value", min: "min", max: "max", disabled: "disabled" }, outputs: { dateChange: "dateChange", dateInput: "dateInput" }, host: { listeners: { "input": "_onInput($event.target.value)", "change": "_onChange()", "blur": "_onBlur()", "keydown": "_onKeydown($event)" }, properties: { "attr.aria-haspopup": "true", "attr.aria-owns": "(_datetimepicker?.opened && _datetimepicker.id) || null", "attr.min": "min ? _dateAdapter.toIso8601(min) : null", "attr.max": "max ? _dateAdapter.toIso8601(max) : null", "disabled": "disabled" } }, providers: [
+            MAT_DATETIMEPICKER_VALUE_ACCESSOR,
+            MAT_DATETIMEPICKER_VALIDATORS,
+            { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxDatetimepickerInput },
+        ], exportAs: ["mtxDatetimepickerInput"], ngImport: i0 }); }
+}
+export { MtxDatetimepickerInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerInput, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[mtxDatetimepicker]',
+                    providers: [
+                        MAT_DATETIMEPICKER_VALUE_ACCESSOR,
+                        MAT_DATETIMEPICKER_VALIDATORS,
+                        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxDatetimepickerInput },
+                    ],
+                    host: {
+                        '[attr.aria-haspopup]': 'true',
+                        '[attr.aria-owns]': '(_datetimepicker?.opened && _datetimepicker.id) || null',
+                        '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',
+                        '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',
+                        '[disabled]': 'disabled',
+                        '(input)': '_onInput($event.target.value)',
+                        '(change)': '_onChange()',
+                        '(blur)': '_onBlur()',
+                        '(keydown)': '_onKeydown($event)',
+                    },
+                    exportAs: 'mtxDatetimepickerInput',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.DatetimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MTX_DATETIME_FORMATS]
+                }] }, { type: i2.MatFormField, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { dateChange: [{
+                type: Output
+            }], dateInput: [{
+                type: Output
+            }], mtxDatetimepicker: [{
+                type: Input
+            }], mtxDatetimepickerFilter: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetimepicker-input.js","sourceRoot":"","sources":["../../../../projects/extensions/datetimepicker/datetimepicker-input.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator,\n  ValidatorFn,\n  Validators,\n} from '@angular/forms';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { DOWN_ARROW } from '@angular/cdk/keycodes';\nimport { ThemePalette } from '@angular/material/core';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\nimport { MatFormField } from '@angular/material/form-field';\nimport { Subscription } from 'rxjs';\nimport {\n  DatetimeAdapter,\n  MTX_DATETIME_FORMATS,\n  MtxDatetimeFormats,\n} from '@ng-matero/extensions/core';\nimport { MtxDatetimepicker } from './datetimepicker';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { MtxDatetimepickerFilterType } from './datetimepicker-filtertype';\n\nexport const MAT_DATETIMEPICKER_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => MtxDatetimepickerInput),\n  multi: true,\n};\n\nexport const MAT_DATETIMEPICKER_VALIDATORS: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MtxDatetimepickerInput),\n  multi: true,\n};\n\n/**\n * An event used for datetimepicker 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 MtxDatetimepickerInputEvent instead.\n */\nexport class MtxDatetimepickerInputEvent<D> {\n  /** The new value for the target datetimepicker input. */\n  value: D | null;\n\n  constructor(public target: MtxDatetimepickerInput<D>, public targetElement: HTMLElement) {\n    this.value = this.target.value;\n  }\n}\n\n/** Directive used to connect an input to a MtxDatetimepicker. */\n@Directive({\n  selector: 'input[mtxDatetimepicker]',\n  providers: [\n    MAT_DATETIMEPICKER_VALUE_ACCESSOR,\n    MAT_DATETIMEPICKER_VALIDATORS,\n    { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxDatetimepickerInput },\n  ],\n  host: {\n    '[attr.aria-haspopup]': 'true',\n    '[attr.aria-owns]': '(_datetimepicker?.opened && _datetimepicker.id) || null',\n    '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',\n    '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(blur)': '_onBlur()',\n    '(keydown)': '_onKeydown($event)',\n  },\n  exportAs: 'mtxDatetimepickerInput',\n})\nexport class MtxDatetimepickerInput<D>\n  implements AfterContentInit, ControlValueAccessor, OnDestroy, Validator\n{\n  _datetimepicker!: MtxDatetimepicker<D>;\n\n  _dateFilter!: (date: D | null, type: MtxDatetimepickerFilterType) => boolean;\n\n  /** Emits when a `change` event is fired on this `<input>`. */\n  @Output() dateChange = new EventEmitter<MtxDatetimepickerInputEvent<D>>();\n\n  /** Emits when an `input` event is fired on this `<input>`. */\n  @Output() dateInput = new EventEmitter<MtxDatetimepickerInputEvent<D>>();\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 disabled state has changed */\n  _disabledChange = new EventEmitter<boolean>();\n\n  private _datetimepickerSubscription = Subscription.EMPTY;\n\n  private _localeSubscription = Subscription.EMPTY;\n\n  /** Whether the last value set on the input was valid. */\n  private _lastValueValid = false;\n\n  constructor(\n    private _elementRef: ElementRef,\n    @Optional() public _dateAdapter: DatetimeAdapter<D>,\n    @Optional() @Inject(MTX_DATETIME_FORMATS) private _dateFormats: MtxDatetimeFormats,\n    @Optional() private _formField: MatFormField\n  ) {\n    if (!this._dateAdapter) {\n      throw createMissingDateImplError('DatetimeAdapter');\n    }\n    if (!this._dateFormats) {\n      throw createMissingDateImplError('MTX_DATETIME_FORMATS');\n    }\n\n    // Update the displayed date when the locale changes.\n    this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => {\n      this.value = this._dateAdapter.deserialize(this.value);\n    });\n  }\n\n  /** The datetimepicker that this input is associated with. */\n  @Input()\n  set mtxDatetimepicker(value: MtxDatetimepicker<D>) {\n    this.registerDatetimepicker(value);\n  }\n\n  @Input()\n  set mtxDatetimepickerFilter(\n    filter: (date: D | null, type: MtxDatetimepickerFilterType) => boolean\n  ) {\n    this._dateFilter = filter;\n    this._validatorOnChange();\n  }\n\n  /** The value of the input. */\n  @Input()\n  get value(): D | null {\n    return this._value;\n  }\n  set value(value: D | null) {\n    value = this._dateAdapter.deserialize(value);\n    this._lastValueValid = !value || this._dateAdapter.isValid(value);\n    value = this._dateAdapter.getValidDateOrNull(value);\n    const oldDate = this.value;\n    this._value = value;\n    this._formatValue(value);\n\n    // use timeout to ensure the datetimepicker is instantiated and we get the correct format\n    setTimeout(() => {\n      if (!this._dateAdapter.sameDatetime(oldDate, value)) {\n        this._valueChange.emit(value);\n      }\n    });\n  }\n  private _value!: D | null;\n\n  /** The minimum valid date. */\n  @Input()\n  get min(): D | null {\n    return this._min;\n  }\n  set min(value: D | null) {\n    this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    this._validatorOnChange();\n  }\n  private _min!: D | null;\n\n  /** The maximum valid date. */\n  @Input()\n  get max(): D | null {\n    return this._max;\n  }\n  set max(value: D | null) {\n    this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    this._validatorOnChange();\n  }\n  private _max!: D | null;\n\n  /** Whether the datetimepicker-input is disabled. */\n  @Input()\n  get disabled(): boolean {\n    return !!this._disabled;\n  }\n  set disabled(value: boolean) {\n    const newValue = coerceBooleanProperty(value);\n\n    if (this._disabled !== newValue) {\n      this._disabled = newValue;\n      this._disabledChange.emit(newValue);\n    }\n  }\n  private _disabled!: boolean;\n\n  _onTouched = () => {};\n\n  ngAfterContentInit() {\n    if (this._datetimepicker) {\n      this._datetimepickerSubscription = this._datetimepicker.selectedChanged.subscribe(\n        (selected: D) => {\n          this.value = selected;\n          this._cvaOnChange(selected);\n          this._onTouched();\n          this.dateInput.emit(\n            new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement)\n          );\n          this.dateChange.emit(\n            new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement)\n          );\n        }\n      );\n    }\n  }\n\n  ngOnDestroy() {\n    this._datetimepickerSubscription.unsubscribe();\n    this._localeSubscription.unsubscribe();\n    this._valueChange.complete();\n    this._disabledChange.complete();\n  }\n\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorOnChange = fn;\n  }\n\n  validate(c: AbstractControl): ValidationErrors | null {\n    return this._validator ? this._validator(c) : null;\n  }\n\n  /**\n   * Gets the element that the datetimepicker 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  /** Gets the ID of an element that should be used a description for the calendar overlay. */\n  getOverlayLabelId(): string | null {\n    if (this._formField) {\n      return this._formField.getLabelId();\n    }\n\n    return this._elementRef.nativeElement.getAttribute('aria-labelledby');\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(disabled: boolean): void {\n    this.disabled = disabled;\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    if (event.altKey && event.keyCode === DOWN_ARROW) {\n      this._datetimepicker.open();\n      event.preventDefault();\n    }\n  }\n\n  _onInput(value: string) {\n    let date = this._dateAdapter.parse(value, this.getParseFormat());\n    this._lastValueValid = !date || this._dateAdapter.isValid(date);\n    date = this._dateAdapter.getValidDateOrNull(date);\n    this._value = date;\n    this._cvaOnChange(date);\n    this._valueChange.emit(date);\n    this.dateInput.emit(new MtxDatetimepickerInputEvent(this, this._elementRef.nativeElement));\n  }\n\n  _onChange() {\n    this.dateChange.emit(new MtxDatetimepickerInputEvent(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  private registerDatetimepicker(value: MtxDatetimepicker<D>) {\n    if (value) {\n      this._datetimepicker = value;\n      this._datetimepicker._registerInput(this);\n    }\n  }\n\n  private getDisplayFormat() {\n    switch (this._datetimepicker.type) {\n      case 'date':\n        return this._dateFormats.display.dateInput;\n      case 'datetime':\n        return this._dateFormats.display.datetimeInput;\n      case 'time':\n        return this._dateFormats.display.timeInput;\n      case 'month':\n        return this._dateFormats.display.monthInput;\n      case 'year':\n        return this._dateFormats.display.yearInput;\n    }\n  }\n\n  private getParseFormat() {\n    let parseFormat;\n\n    switch (this._datetimepicker.type) {\n      case 'date':\n        parseFormat = this._dateFormats.parse.dateInput;\n        break;\n      case 'datetime':\n        parseFormat = this._dateFormats.parse.datetimeInput;\n        break;\n      case 'time':\n        parseFormat = this._dateFormats.parse.timeInput;\n        break;\n      case 'month':\n        parseFormat = this._dateFormats.parse.monthInput;\n        break;\n      case 'year':\n        parseFormat = this._dateFormats.parse.yearInput;\n        break;\n    }\n    if (!parseFormat) {\n      parseFormat = this._dateFormats.parse.dateInput;\n    }\n\n    return parseFormat;\n  }\n\n  private _cvaOnChange: (value: any) => void = () => {};\n\n  private _validatorOnChange = () => {};\n\n  /** The form control validator for whether the input parses. */\n  private _parseValidator: ValidatorFn = (): ValidationErrors | null => {\n    return this._lastValueValid\n      ? null\n      : { mtxDatetimepickerParse: { text: this._elementRef.nativeElement.value } };\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(\n      this._dateAdapter.deserialize(control.value)\n    );\n    return !this.min ||\n      !controlValue ||\n      (this._dateAdapter.compareDatetime(this.min, controlValue) as number) <= 0\n      ? null\n      : { mtxDatetimepickerMin: { min: this.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(\n      this._dateAdapter.deserialize(control.value)\n    );\n    return !this.max ||\n      !controlValue ||\n      (this._dateAdapter.compareDatetime(this.max, controlValue) as number) >= 0\n      ? null\n      : { mtxDatetimepickerMax: { max: this.max, actual: controlValue } };\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(\n      this._dateAdapter.deserialize(control.value)\n    );\n    return !this._dateFilter ||\n      !controlValue ||\n      this._dateFilter(controlValue, MtxDatetimepickerFilterType.DATE)\n      ? null\n      : { mtxDatetimepickerFilter: true };\n  };\n\n  /** The combined form control validator for this input. */\n  private _validator: ValidatorFn | null = Validators.compose([\n    this._parseValidator,\n    this._minValidator,\n    this._maxValidator,\n    this._filterValidator,\n  ]);\n\n  /** Formats a value and sets it on the input element. */\n  private _formatValue(value: D | null) {\n    this._elementRef.nativeElement.value = value\n      ? this._dateAdapter.format(value, this.getDisplayFormat())\n      : '';\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  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}

package/esm2022/datetimepicker/datetimepicker-intl.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+class MtxDatetimepickerIntl {
+    constructor() {
+        /**
+         * Stream to emit from when labels are changed. Use this to notify components when 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';
+        /** Label for the button used to close the calendar popup. */
+        this.closeCalendarLabel = 'Close 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 24 years';
+        /** A label for the next multi-year button (used by screen readers). */
+        this.nextMultiYearLabel = 'Next 24 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.switchToYearViewLabel = 'Choose month';
+        /** A label for the 'switch to multi-year view' button (used by screen readers). */
+        this.switchToMultiYearViewLabel = 'Choose month and year';
+        /** A label for the first date of a range of dates (used by screen readers). */
+        this.startDateLabel = 'Start date';
+        /** A label for the last date of a range of dates (used by screen readers). */
+        this.endDateLabel = 'End date';
+        /** A label for the 'switch to clock hour view' button (used by screen readers). */
+        this.switchToClockHourViewLabel = 'Choose hour';
+        /** A label for the 'switch to clock minute view' button (used by screen readers). */
+        this.switchToClockMinuteViewLabel = 'Choose minute';
+        /** Label used for ok button within the manual time input. */
+        this.okLabel = 'OK';
+        /** Label used for cancel button within the manual time input. */
+        this.cancelLabel = 'Cancel';
+    }
+    /** Formats a range of years (used for visuals). */
+    formatYearRange(start, end) {
+        return `${start} \u2013 ${end}`;
+    }
+    /** Formats a label for a range of years (used by screen readers). */
+    formatYearRangeLabel(start, end) {
+        return `${start} to ${end}`;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerIntl, providedIn: 'root' }); }
+}
+export { MtxDatetimepickerIntl };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerIntl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/datetimepicker/datetimepicker-module.mjs

@@ -0,0 +1,83 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MtxCalendar } from './calendar';
+import { MtxCalendarBody } from './calendar-body';
+import { MtxClock } from './clock';
+import { MtxTime, MtxTimeInput } from './time';
+import { MtxDatetimepicker, MtxDatetimepickerContent, MTX_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, } from './datetimepicker';
+import { MtxDatetimepickerInput } from './datetimepicker-input';
+import { MtxDatetimepickerToggle, MtxDatetimepickerToggleIcon } from './datetimepicker-toggle';
+import { MtxMonthView } from './month-view';
+import { MtxYearView } from './year-view';
+import { MtxMultiYearView } from './multi-year-view';
+import * as i0 from "@angular/core";
+class MtxDatetimepickerModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerModule, declarations: [MtxCalendar,
+            MtxCalendarBody,
+            MtxClock,
+            MtxTime,
+            MtxTimeInput,
+            MtxDatetimepicker,
+            MtxDatetimepickerToggle,
+            MtxDatetimepickerToggleIcon,
+            MtxDatetimepickerInput,
+            MtxDatetimepickerContent,
+            MtxMonthView,
+            MtxYearView,
+            MtxMultiYearView], imports: [CommonModule, MatButtonModule, OverlayModule, A11yModule, PortalModule], exports: [MtxCalendar,
+            MtxCalendarBody,
+            MtxClock,
+            MtxTime,
+            MtxDatetimepicker,
+            MtxDatetimepickerToggle,
+            MtxDatetimepickerToggleIcon,
+            MtxDatetimepickerInput,
+            MtxDatetimepickerContent,
+            MtxMonthView,
+            MtxYearView,
+            MtxMultiYearView] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerModule, providers: [MTX_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [CommonModule, MatButtonModule, OverlayModule, A11yModule, PortalModule] }); }
+}
+export { MtxDatetimepickerModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxDatetimepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, MatButtonModule, OverlayModule, A11yModule, PortalModule],
+                    declarations: [
+                        MtxCalendar,
+                        MtxCalendarBody,
+                        MtxClock,
+                        MtxTime,
+                        MtxTimeInput,
+                        MtxDatetimepicker,
+                        MtxDatetimepickerToggle,
+                        MtxDatetimepickerToggleIcon,
+                        MtxDatetimepickerInput,
+                        MtxDatetimepickerContent,
+                        MtxMonthView,
+                        MtxYearView,
+                        MtxMultiYearView,
+                    ],
+                    exports: [
+                        MtxCalendar,
+                        MtxCalendarBody,
+                        MtxClock,
+                        MtxTime,
+                        MtxDatetimepicker,
+                        MtxDatetimepickerToggle,
+                        MtxDatetimepickerToggleIcon,
+                        MtxDatetimepickerInput,
+                        MtxDatetimepickerContent,
+                        MtxMonthView,
+                        MtxYearView,
+                        MtxMultiYearView,
+                    ],
+                    providers: [MTX_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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