cmat 0.0.3

package/esm2022/components/material-datetimepicker/datetimepicker-input.mjs

@@ -0,0 +1,340 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, EventEmitter, forwardRef, Inject, Input, Optional, Output } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators } from '@angular/forms';
+import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
+import { Subscription } from 'rxjs';
+import { CMAT_DATETIME_FORMATS } from 'cmat/components/adapter';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { CmatDatetimepickerFilterType } from './datetimepicker-filtertype';
+import * as i0 from "@angular/core";
+import * as i1 from "cmat/components/adapter";
+import * as i2 from "@angular/material/form-field";
+export const CMAT_DATETIMEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => CmatDatetimepickerInputDirective),
+    multi: true
+};
+export const CMAT_DATETIMEPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => CmatDatetimepickerInputDirective),
+    multi: true
+};
+/**
+ * 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 CmatDatetimepickerInputEvent {
+    constructor(target, targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+}
+/** Directive used to connect an input to a MatDatepicker. */
+export class CmatDatetimepickerInputDirective {
+    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._datepickerSubscription = 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 = () => this._lastValueValid ?
+            null : { 'matDatepickerParse': { '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 : { 'matDatepickerMin': { '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 : { 'matDatepickerMax': { '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, CmatDatetimepickerFilterType.DATE) ?
+                null : { 'matDatepickerFilter': true };
+        };
+        /** The combined form control validator for this input. */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this._validator = Validators.compose([this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('CDatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('CMAT_DATETIME_FORMATS');
+        }
+        // Update the displayed date when the locale changes.
+        this._localeSubscription = _dateAdapter.localeChanges.subscribe();
+    }
+    /** The datepicker that this input is associated with. */
+    set cmatDatetimepicker(value) {
+        this._registerDatetimepicker(value);
+    }
+    set cmatDatepickerFilter(filter) {
+        this.dateFilter = filter;
+        this._validatorOnChange();
+    }
+    /** The value of the input. */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    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. */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    get min() {
+        return this._min;
+    }
+    set min(value) {
+        this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    /** The maximum valid date. */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    get max() {
+        return this._max;
+    }
+    set max(value) {
+        this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    /** Whether the datepicker-input is disabled. */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    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._datepickerSubscription = this.datetimepicker.selectedChanged.subscribe((selected) => {
+                this.value = selected;
+                this._cvaOnChange(selected);
+                this._onTouched();
+                this.dateInput.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+                this.dateChange.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._datepickerSubscription.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 datepicker 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.code === 'ArrowDown') {
+            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 CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    onChange() {
+        this.dateChange.emit(new CmatDatetimepickerInputEvent(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();
+    }
+    /** Returns the palette used by the input's form field, if any. */
+    getThemePalette() {
+        return this._formField ? this._formField.color : undefined;
+    }
+    _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()) : '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerInputDirective, deps: [{ token: i0.ElementRef }, { token: i1.DatetimeAdapter, optional: true }, { token: CMAT_DATETIME_FORMATS, optional: true }, { token: i2.MatFormField, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatDatetimepickerInputDirective, isStandalone: true, selector: "input[cmatDatetimepicker]", inputs: { cmatDatetimepicker: "cmatDatetimepicker", cmatDatepickerFilter: "cmatDatepickerFilter", 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 ? datetimepicker.toIso8601(min) : null", "attr.max": "max ? datetimepicker.toIso8601(max) : null", "disabled": "disabled" } }, providers: [
+            CMAT_DATETIMEPICKER_VALUE_ACCESSOR,
+            CMAT_DATETIMEPICKER_VALIDATORS,
+            { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: CmatDatetimepickerInputDirective },
+        ], exportAs: ["cmatDatepickerInput"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[cmatDatetimepicker]',
+                    providers: [
+                        CMAT_DATETIMEPICKER_VALUE_ACCESSOR,
+                        CMAT_DATETIMEPICKER_VALIDATORS,
+                        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: CmatDatetimepickerInputDirective },
+                    ],
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        '[attr.aria-haspopup]': 'true',
+                        '[attr.aria-owns]': '(datetimepicker?.opened && datetimepicker.id) || null',
+                        '[attr.min]': 'min ? datetimepicker.toIso8601(min) : null',
+                        '[attr.max]': 'max ? datetimepicker.toIso8601(max) : null',
+                        '[disabled]': 'disabled',
+                        '(input)': 'onInput($event.target.value)',
+                        '(change)': 'onChange()',
+                        '(blur)': 'onBlur()',
+                        '(keydown)': 'onKeydown($event)'
+                    },
+                    exportAs: 'cmatDatepickerInput',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.DatetimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CMAT_DATETIME_FORMATS]
+                }] }, { type: i2.MatFormField, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { dateChange: [{
+                type: Output
+            }], dateInput: [{
+                type: Output
+            }], cmatDatetimepicker: [{
+                type: Input
+            }], cmatDatepickerFilter: [{
+                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/cmat/components/material-datetimepicker/datetimepicker-input.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\r\n/* eslint-disable @typescript-eslint/naming-convention */\r\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { AfterContentInit, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, OnDestroy, Optional, Output } from '@angular/core';\r\nimport {\r\n    AbstractControl,\r\n    ControlValueAccessor,\r\n    NG_VALIDATORS,\r\n    NG_VALUE_ACCESSOR,\r\n    ValidationErrors,\r\n    Validator,\r\n    ValidatorFn,\r\n    Validators\r\n} from '@angular/forms';\r\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\r\nimport { MatFormField } from '@angular/material/form-field';\r\nimport { Subscription } from 'rxjs';\r\nimport { DatetimeAdapter,CMAT_DATETIME_FORMATS, CmatDatetimeFormats } from 'cmat/components/adapter';\r\nimport { CmatDatetimepickerComponent } from './datetimepicker';\r\nimport { createMissingDateImplError } from './datetimepicker-errors';\r\nimport { CmatDatetimepickerFilterType } from './datetimepicker-filtertype';\r\nimport { ThemePalette } from '@angular/material/core';\r\n\r\nexport const CMAT_DATETIMEPICKER_VALUE_ACCESSOR: any = {\r\n    provide: NG_VALUE_ACCESSOR,\r\n    useExisting: forwardRef(() => CmatDatetimepickerInputDirective),\r\n    multi: true\r\n};\r\n\r\nexport const CMAT_DATETIMEPICKER_VALIDATORS: any = {\r\n    provide: NG_VALIDATORS,\r\n    useExisting: forwardRef(() => CmatDatetimepickerInputDirective),\r\n    multi: true\r\n};\r\n\r\n/**\r\n * An event used for datepicker input and change events. We don't always have access to a native\r\n * input or change event because the event may have been triggered by the user clicking on the\r\n * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.\r\n */\r\nexport class CmatDatetimepickerInputEvent<D> {\r\n    /** The new value for the target datepicker input. */\r\n    value: D | null;\r\n\r\n    constructor(public target: CmatDatetimepickerInputDirective<D>, public targetElement: HTMLElement) {\r\n        this.value = this.target.value;\r\n    }\r\n}\r\n\r\n/** Directive used to connect an input to a MatDatepicker. */\r\n@Directive({\r\n    selector: 'input[cmatDatetimepicker]',\r\n    providers: [\r\n        CMAT_DATETIMEPICKER_VALUE_ACCESSOR,\r\n        CMAT_DATETIMEPICKER_VALIDATORS,\r\n        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: CmatDatetimepickerInputDirective },\r\n    ],\r\n    // eslint-disable-next-line @angular-eslint/no-host-metadata-property\r\n    host: {\r\n        '[attr.aria-haspopup]': 'true',\r\n        '[attr.aria-owns]': '(datetimepicker?.opened && datetimepicker.id) || null',\r\n        '[attr.min]': 'min ? datetimepicker.toIso8601(min) : null',\r\n        '[attr.max]': 'max ? datetimepicker.toIso8601(max) : null',\r\n        '[disabled]': 'disabled',\r\n        '(input)': 'onInput($event.target.value)',\r\n        '(change)': 'onChange()',\r\n        '(blur)': 'onBlur()',\r\n        '(keydown)': 'onKeydown($event)'\r\n    },\r\n    exportAs: 'cmatDatepickerInput',\r\n    standalone: true\r\n})\r\nexport class CmatDatetimepickerInputDirective<D> implements AfterContentInit, ControlValueAccessor, OnDestroy,\r\n    Validator {\r\n    /** Emits when a `change` event is fired on this `<input>`. */\r\n    @Output() dateChange = new EventEmitter<CmatDatetimepickerInputEvent<D>>();\r\n    /** Emits when an `input` event is fired on this `<input>`. */\r\n    @Output() dateInput = new EventEmitter<CmatDatetimepickerInputEvent<D>>();\r\n\r\n    datetimepicker: CmatDatetimepickerComponent<D>;\r\n    dateFilter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean;\r\n\r\n    /** Emits when the value changes (either due to user input or programmatic change). */\r\n    valueChange = new EventEmitter<D | null>();\r\n    /** Emits when the disabled state has changed */\r\n    disabledChange = new EventEmitter<boolean>();\r\n\r\n    private _datepickerSubscription = Subscription.EMPTY;\r\n    private _localeSubscription = Subscription.EMPTY;\r\n    /** Whether the last value set on the input was valid. */\r\n    private _lastValueValid = false;\r\n    private _value: D | null;\r\n    private _min: D | null;\r\n    private _max: D | null;\r\n    private _disabled: boolean;\r\n\r\n    constructor(private _elementRef: ElementRef,\r\n        @Optional() public _dateAdapter: DatetimeAdapter<D>,\r\n        @Optional() @Inject(CMAT_DATETIME_FORMATS) private _dateFormats: CmatDatetimeFormats,\r\n        @Optional() private _formField: MatFormField) {\r\n        if (!this._dateAdapter) {\r\n            throw createMissingDateImplError('CDatetimeAdapter');\r\n        }\r\n        if (!this._dateFormats) {\r\n            throw createMissingDateImplError('CMAT_DATETIME_FORMATS');\r\n        }\r\n\r\n        // Update the displayed date when the locale changes.\r\n        this._localeSubscription = _dateAdapter.localeChanges.subscribe();\r\n    }\r\n\r\n    /** The datepicker that this input is associated with. */\r\n    @Input()\r\n    set cmatDatetimepicker(value: CmatDatetimepickerComponent<D>) {\r\n        this._registerDatetimepicker(value);\r\n    }\r\n\r\n    @Input() set cmatDatepickerFilter(filter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean) {\r\n        this.dateFilter = filter;\r\n        this._validatorOnChange();\r\n    }\r\n\r\n\r\n\r\n    /** The value of the input. */\r\n    // eslint-disable-next-line @typescript-eslint/member-ordering\r\n    @Input()\r\n    get value(): D | null {\r\n        return this._value;\r\n    }\r\n\r\n    set value(value: D | null) {\r\n        value = this._dateAdapter.deserialize(value);\r\n        this._lastValueValid = !value || this._dateAdapter.isValid(value);\r\n        value = this._dateAdapter.getValidDateOrNull(value);\r\n        const oldDate = this.value;\r\n        this._value = value;\r\n        this._formatValue(value);\r\n\r\n        // use timeout to ensure the datetimepicker is instantiated and we get the correct format\r\n        setTimeout(() => {\r\n            if (!this._dateAdapter.sameDatetime(oldDate, value)) {\r\n                this.valueChange.emit(value);\r\n            }\r\n        });\r\n    }\r\n\r\n    /** The minimum valid date. */\r\n    // eslint-disable-next-line @typescript-eslint/member-ordering\r\n    @Input()\r\n    get min(): D | null {\r\n        return this._min;\r\n    }\r\n\r\n    set min(value: D | null) {\r\n        this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\r\n        this._validatorOnChange();\r\n    }\r\n\r\n    /** The maximum valid date. */\r\n    // eslint-disable-next-line @typescript-eslint/member-ordering\r\n    @Input()\r\n    get max(): D | null {\r\n        return this._max;\r\n    }\r\n\r\n    set max(value: D | null) {\r\n        this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\r\n        this._validatorOnChange();\r\n    }\r\n\r\n    /** Whether the datepicker-input is disabled. */\r\n    // eslint-disable-next-line @typescript-eslint/member-ordering\r\n    @Input()\r\n    get disabled(): boolean {\r\n        return !!this._disabled;\r\n    }\r\n\r\n    set disabled(value: any) {\r\n        const newValue = coerceBooleanProperty(value);\r\n\r\n        if (this._disabled !== newValue) {\r\n            this._disabled = newValue;\r\n            this.disabledChange.emit(newValue);\r\n        }\r\n    }\r\n\r\n    ngAfterContentInit(): void {\r\n        if (this.datetimepicker) {\r\n            this._datepickerSubscription = this.datetimepicker.selectedChanged.subscribe((selected: D) => {\r\n                this.value = selected;\r\n                this._cvaOnChange(selected);\r\n                this._onTouched();\r\n                this.dateInput.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));\r\n                this.dateChange.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));\r\n            });\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this._datepickerSubscription.unsubscribe();\r\n        this._localeSubscription.unsubscribe();\r\n        this.valueChange.complete();\r\n        this.disabledChange.complete();\r\n    }\r\n\r\n    registerOnValidatorChange(fn: () => void): void {\r\n        this._validatorOnChange = fn;\r\n    }\r\n\r\n    validate(c: AbstractControl): ValidationErrors | null {\r\n        return this._validator ? this._validator(c) : null;\r\n    }\r\n\r\n    /**\r\n     * Gets the element that the datepicker popup should be connected to.\r\n     *\r\n     * @return The element to connect the popup to.\r\n     */\r\n    getConnectedOverlayOrigin(): ElementRef {\r\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\r\n    }\r\n\r\n    /** Gets the ID of an element that should be used a description for the calendar overlay. */\r\n    getOverlayLabelId(): string | null {\r\n        if (this._formField) {\r\n            return this._formField.getLabelId();\r\n        }\r\n\r\n        return this._elementRef.nativeElement.getAttribute('aria-labelledby');\r\n    }\r\n\r\n    // Implemented as part of ControlValueAccessor\r\n    writeValue(value: D): void {\r\n        this.value = value;\r\n    }\r\n\r\n    // Implemented as part of ControlValueAccessor\r\n    registerOnChange(fn: (value: any) => void): void {\r\n        this._cvaOnChange = fn;\r\n    }\r\n\r\n    // Implemented as part of ControlValueAccessor\r\n    registerOnTouched(fn: () => void): void {\r\n        this._onTouched = fn;\r\n    }\r\n\r\n    // Implemented as part of ControlValueAccessor\r\n    setDisabledState(disabled: boolean): void {\r\n        this.disabled = disabled;\r\n    }\r\n\r\n    onKeydown(event: KeyboardEvent): void {\r\n        if (event.altKey && event.code === 'ArrowDown') {\r\n            this.datetimepicker.open();\r\n            event.preventDefault();\r\n        }\r\n    }\r\n\r\n    onInput(value: string): void {\r\n        let date = this._dateAdapter.parse(value, this._getParseFormat());\r\n        this._lastValueValid = !date || this._dateAdapter.isValid(date);\r\n        date = this._dateAdapter.getValidDateOrNull(date);\r\n        this._value = date;\r\n        this._cvaOnChange(date);\r\n        this.valueChange.emit(date);\r\n        this.dateInput.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));\r\n    }\r\n\r\n    onChange(): void {\r\n        this.dateChange.emit(new CmatDatetimepickerInputEvent(this, this._elementRef.nativeElement));\r\n    }\r\n\r\n    /** Handles blur events on the input. */\r\n    onBlur(): void {\r\n        // Reformat the input only if we have a valid value.\r\n        if (this.value) {\r\n            this._formatValue(this.value);\r\n        }\r\n\r\n        this._onTouched();\r\n    }\r\n\r\n    /** Returns the palette used by the input's form field, if any. */\r\n    getThemePalette(): ThemePalette {\r\n        return this._formField ? this._formField.color : undefined;\r\n    }\r\n\r\n    private _registerDatetimepicker(value: CmatDatetimepickerComponent<D>): void {\r\n        if (value) {\r\n            this.datetimepicker = value;\r\n            this.datetimepicker.registerInput(this);\r\n        }\r\n    }\r\n\r\n    private _getDisplayFormat(): any {\r\n        switch (this.datetimepicker.type) {\r\n            case 'date':\r\n                return this._dateFormats.display.dateInput;\r\n            case 'datetime':\r\n                return this._dateFormats.display.datetimeInput;\r\n            case 'time':\r\n                return this._dateFormats.display.timeInput;\r\n            case 'month':\r\n                return this._dateFormats.display.monthInput;\r\n            case 'year':\r\n                return this._dateFormats.display.yearInput;\r\n        }\r\n    }\r\n\r\n    private _getParseFormat(): any {\r\n        let parseFormat: any;\r\n\r\n        switch (this.datetimepicker.type) {\r\n            case 'date':\r\n                parseFormat = this._dateFormats.parse.dateInput;\r\n                break;\r\n            case 'datetime':\r\n                parseFormat = this._dateFormats.parse.datetimeInput;\r\n                break;\r\n            case 'time':\r\n                parseFormat = this._dateFormats.parse.timeInput;\r\n                break;\r\n            case 'month':\r\n                parseFormat = this._dateFormats.parse.monthInput;\r\n                break;\r\n            case 'year':\r\n                parseFormat = this._dateFormats.parse.yearInput;\r\n                break;\r\n        }\r\n        if (!parseFormat) {\r\n            parseFormat = this._dateFormats.parse.dateInput;\r\n        }\r\n\r\n        return parseFormat;\r\n    }\r\n\r\n    private _onTouched = (): void => { };\r\n    private _cvaOnChange: (value: any) => void = () => {};\r\n    private _validatorOnChange = (): void => { };\r\n\r\n    /** The form control validator for whether the input parses. */\r\n    private _parseValidator: ValidatorFn = (): ValidationErrors | null => this._lastValueValid ?\r\n        null : { 'matDatepickerParse': { 'text': this._elementRef.nativeElement.value } };\r\n\r\n    /** The form control validator for the min date. */\r\n    private _minValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\r\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n        return (!this.min || !controlValue ||\r\n            (this._dateAdapter.compareDatetime(this.min, controlValue) as number) <= 0) ?\r\n            null : { 'matDatepickerMin': { 'min': this.min, 'actual': controlValue } };\r\n    };\r\n\r\n    /** The form control validator for the max date. */\r\n    private _maxValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\r\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n        return (!this.max || !controlValue ||\r\n            (this._dateAdapter.compareDatetime(this.max, controlValue) as number) >= 0) ?\r\n            null : { 'matDatepickerMax': { 'max': this.max, 'actual': controlValue } };\r\n    };\r\n\r\n    /** The form control validator for the date filter. */\r\n    private _filterValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\r\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\r\n        return !this.dateFilter || !controlValue || this.dateFilter(controlValue, CmatDatetimepickerFilterType.DATE) ?\r\n            null : { 'matDatepickerFilter': true };\r\n    };\r\n\r\n    /** The combined form control validator for this input. */\r\n    // eslint-disable-next-line @typescript-eslint/member-ordering\r\n    private _validator: ValidatorFn | null =\r\n        Validators.compose(\r\n            [this._parseValidator, this._minValidator, this._maxValidator, this._filterValidator]);\r\n\r\n    /** Formats a value and sets it on the input element. */\r\n    private _formatValue(value: D | null): void {\r\n        this._elementRef.nativeElement.value =\r\n            value ? this._dateAdapter.format(value, this._getDisplayFormat()) : '';\r\n    }\r\n}\r\n"]}

package/esm2022/components/material-datetimepicker/datetimepicker-intl.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class CmatDatetimepickerIntl {
+    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 = '日历';
+        /** A label for the button used to open the calendar popup (used by screen readers). */
+        this.openCalendarLabel = '打开日历';
+        /** Label for the button used to close the calendar popup. */
+        this.closeCalendarLabel = '关闭日历';
+        /** A label for the previous month button (used by screen readers). */
+        this.prevMonthLabel = '上个月';
+        /** A label for the next month button (used by screen readers). */
+        this.nextMonthLabel = '下个月';
+        /** A label for the previous year button (used by screen readers). */
+        this.prevYearLabel = '去年';
+        /** A label for the next year button (used by screen readers). */
+        this.nextYearLabel = '明年';
+        /** A label for the previous multi-year button (used by screen readers). */
+        this.prevMultiYearLabel = '过去24年';
+        /** A label for the next multi-year button (used by screen readers). */
+        this.nextMultiYearLabel = '未来24年';
+        /** A label for the 'switch to month view' button (used by screen readers). */
+        this.switchToMonthViewLabel = '选择日期';
+        /** A label for the 'switch to year view' button (used by screen readers). */
+        this.switchToYearViewLabel = '选择月份';
+        /** A label for the 'switch to multi-year view' button (used by screen readers). */
+        this.switchToMultiYearViewLabel = '选择年月';
+        /** A label for the first date of a range of dates (used by screen readers). */
+        this.startDateLabel = '开始日期';
+        /** A label for the last date of a range of dates (used by screen readers). */
+        this.endDateLabel = '结束日期';
+        /** A label for the 'switch to clock hour view' button (used by screen readers). */
+        this.switchToClockHourViewLabel = '选择小时';
+        /** A label for the 'switch to clock minute view' button (used by screen readers). */
+        this.switchToClockMinuteViewLabel = '选择分钟';
+        /** Label used for ok button within the manual time input. */
+        this.okLabel = '确认';
+        /** Label used for cancel button within the manual time input. */
+        this.cancelLabel = '取消';
+    }
+    /** 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}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerIntl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerIntl, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerIntl, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/material-datetimepicker/datetimepicker-toggle.mjs

@@ -0,0 +1,88 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, ContentChild, Directive, HostBinding, Input, ViewChild, ViewEncapsulation } from '@angular/core';
+import { merge, of as observableOf, Subscription } from 'rxjs';
+import { MatButtonModule } from '@angular/material/button';
+import { NgIf, NgSwitch, NgSwitchCase, NgSwitchDefault } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "./datetimepicker-intl";
+import * as i2 from "@angular/material/button";
+/** Can be used to override the icon of a `cmatDatetimepickerToggle`. */
+export class CmatDatetimepickerToggleIconDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerToggleIconDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.0", type: CmatDatetimepickerToggleIconDirective, isStandalone: true, selector: "[cmatDatetimepickerToggleIcon]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerToggleIconDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cmatDatetimepickerToggleIcon]',
+                    standalone: true
+                }]
+        }] });
+export class CmatDatetimepickerToggleComponent {
+    constructor(intl, _changeDetectorRef) {
+        this.intl = intl;
+        this._changeDetectorRef = _changeDetectorRef;
+        this.class = 'cmat-datetimepicker-toggle';
+        this._stateChanges = Subscription.EMPTY;
+    }
+    /** Whether the toggle button is disabled. */
+    get disabled() {
+        return this._disabled === undefined ? this.datetimepicker.disabled : !!this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    ngOnChanges(changes) {
+        if (changes['datepicker']) {
+            this._watchStateChanges();
+        }
+    }
+    ngOnDestroy() {
+        this._stateChanges.unsubscribe();
+    }
+    ngAfterContentInit() {
+        this._watchStateChanges();
+    }
+    open(event) {
+        if (this.datetimepicker && !this.disabled) {
+            this.datetimepicker.open();
+            event.stopPropagation();
+        }
+    }
+    _watchStateChanges() {
+        const datepickerDisabled = this.datetimepicker ? this.datetimepicker.disabledChange : observableOf();
+        const inputDisabled = this.datetimepicker && this.datetimepicker.datetimepickerInput ?
+            this.datetimepicker.datetimepickerInput.disabledChange : observableOf();
+        this._stateChanges.unsubscribe();
+        this._stateChanges = merge([this.intl.changes, datepickerDisabled, inputDisabled])
+            .subscribe(() => this._changeDetectorRef.markForCheck());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerToggleComponent, deps: [{ token: i1.CmatDatetimepickerIntl }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatDatetimepickerToggleComponent, isStandalone: true, selector: "cmat-datetimepicker-toggle", inputs: { datetimepicker: ["for", "datetimepicker"], tabIndex: "tabIndex", ariaLabel: ["aria-label", "ariaLabel"], disableRipple: "disableRipple", disabled: "disabled" }, host: { properties: { "class": "this.class" } }, queries: [{ propertyName: "customIcon", first: true, predicate: CmatDatetimepickerToggleIconDirective, descendants: true }], viewQueries: [{ propertyName: "button", first: true, predicate: ["button"], descendants: true }], exportAs: ["cmatDatetimepickerToggle"], usesOnChanges: true, ngImport: i0, template: "<button type=\"button\" (click)=\"open($event)\" [attr.aria-haspopup]=\"datetimepicker ? 'dialog' : null\"\r\n    [attr.aria-label]=\"ariaLabel || intl.openCalendarLabel\" [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n    [disabled]=\"disabled\" [disableRipple]=\"disableRipple\" [disabled]=\"disabled\" mat-icon-button type=\"button\">\r\n    <ng-container *ngIf=\"!customIcon\" [ngSwitch]=\"datetimepicker.type\">\r\n        <svg *ngSwitchCase=\"'time'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchCase=\"'datetime'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M15,13H16.5V15.82L18.94,17.23L18.19,18.53L15,16.69V13M19,8H5V19H9.67C9.24,18.09 9,17.07 9,16A7,7 0 0,1 16,9C17.07,9 18.09,9.24 19,9.67V8M5,21C3.89,21 3,20.1 3,19V5C3,3.89 3.89,3 5,3H6V1H8V3H16V1H18V3H19A2,2 0 0,1 21,5V11.1C22.24,12.36 23,14.09 23,16A7,7 0 0,1 16,23C14.09,23 12.36,22.24 11.1,21H5M16,11.15A4.85,4.85 0 0,0 11.15,16C11.15,18.68 13.32,20.85 16,20.85A4.85,4.85 0 0,0 20.85,16C20.85,13.32 18.68,11.15 16,11.15Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchDefault class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path d=\"M0 0h24v24H0z\" fill=\"none\" />\r\n            <path\r\n                d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\r\n        </svg>\r\n    </ng-container>\r\n\r\n    <ng-content select=\"[cmatDatetimepickerToggleIcon]\"></ng-content>\r\n</button>", dependencies: [{ kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: NgSwitchDefault, selector: "[ngSwitchDefault]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDatetimepickerToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-datetimepicker-toggle', exportAs: 'cmatDatetimepickerToggle', encapsulation: ViewEncapsulation.None, preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [MatButtonModule, NgIf, NgSwitch, NgSwitchCase, NgSwitchDefault], template: "<button type=\"button\" (click)=\"open($event)\" [attr.aria-haspopup]=\"datetimepicker ? 'dialog' : null\"\r\n    [attr.aria-label]=\"ariaLabel || intl.openCalendarLabel\" [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n    [disabled]=\"disabled\" [disableRipple]=\"disableRipple\" [disabled]=\"disabled\" mat-icon-button type=\"button\">\r\n    <ng-container *ngIf=\"!customIcon\" [ngSwitch]=\"datetimepicker.type\">\r\n        <svg *ngSwitchCase=\"'time'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchCase=\"'datetime'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M15,13H16.5V15.82L18.94,17.23L18.19,18.53L15,16.69V13M19,8H5V19H9.67C9.24,18.09 9,17.07 9,16A7,7 0 0,1 16,9C17.07,9 18.09,9.24 19,9.67V8M5,21C3.89,21 3,20.1 3,19V5C3,3.89 3.89,3 5,3H6V1H8V3H16V1H18V3H19A2,2 0 0,1 21,5V11.1C22.24,12.36 23,14.09 23,16A7,7 0 0,1 16,23C14.09,23 12.36,22.24 11.1,21H5M16,11.15A4.85,4.85 0 0,0 11.15,16C11.15,18.68 13.32,20.85 16,20.85A4.85,4.85 0 0,0 20.85,16C20.85,13.32 18.68,11.15 16,11.15Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchDefault class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path d=\"M0 0h24v24H0z\" fill=\"none\" />\r\n            <path\r\n                d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\r\n        </svg>\r\n    </ng-container>\r\n\r\n    <ng-content select=\"[cmatDatetimepickerToggleIcon]\"></ng-content>\r\n</button>" }]
+        }], ctorParameters: () => [{ type: i1.CmatDatetimepickerIntl }, { type: i0.ChangeDetectorRef }], propDecorators: { datetimepicker: [{
+                type: Input,
+                args: ['for']
+            }], tabIndex: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], disableRipple: [{
+                type: Input
+            }], customIcon: [{
+                type: ContentChild,
+                args: [CmatDatetimepickerToggleIconDirective]
+            }], button: [{
+                type: ViewChild,
+                args: ['button']
+            }], class: [{
+                type: HostBinding,
+                args: ['class']
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetimepicker-toggle.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/material-datetimepicker/datetimepicker-toggle.ts","../../../../../projects/cmat/components/material-datetimepicker/datetimepicker-toggle.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport {\r\n  AfterContentInit,\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ContentChild,\r\n  Directive,\r\n  HostBinding,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  SimpleChanges,\r\n  ViewChild,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport { merge, of as observableOf, Subscription } from 'rxjs';\r\nimport { CmatDatetimepickerComponent } from './datetimepicker';\r\nimport { CmatDatetimepickerIntl } from './datetimepicker-intl';\r\nimport { MatButton, MatButtonModule } from '@angular/material/button';\r\nimport { NgIf, NgSwitch, NgSwitchCase, NgSwitchDefault } from '@angular/common';\r\n\r\n/** Can be used to override the icon of a `cmatDatetimepickerToggle`. */\r\n@Directive({\r\n    selector: '[cmatDatetimepickerToggleIcon]',\r\n    standalone: true\r\n})\r\nexport class CmatDatetimepickerToggleIconDirective { }\r\n\r\n@Component({\r\n    selector: 'cmat-datetimepicker-toggle',\r\n    templateUrl: 'datetimepicker-toggle.html',\r\n    exportAs: 'cmatDatetimepickerToggle',\r\n    encapsulation: ViewEncapsulation.None,\r\n    preserveWhitespaces: false,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    standalone: true,\r\n    imports: [MatButtonModule, NgIf, NgSwitch, NgSwitchCase, NgSwitchDefault]\r\n})\r\nexport class CmatDatetimepickerToggleComponent<D> implements AfterContentInit, OnChanges, OnDestroy {\r\n  /** Datepicker instance that the button will toggle. */\r\n  // eslint-disable-next-line @angular-eslint/no-input-rename\r\n  @Input('for') datetimepicker: CmatDatetimepickerComponent<D>;\r\n  /** Tabindex for the toggle. */\r\n  @Input() tabIndex!: number;\r\n\r\n  /** Screen-reader label for the button. */\r\n  @Input('aria-label') ariaLabel?: string;\r\n\r\n  /** Whether ripples on the toggle should be disabled. */\r\n  @Input() disableRipple!: boolean;\r\n\r\n  /** Custom icon set by the consumer. */\r\n  @ContentChild(CmatDatetimepickerToggleIconDirective) customIcon!: CmatDatetimepickerToggleIconDirective;\r\n\r\n  /** Underlying button element. */\r\n  @ViewChild('button') button!: MatButton;\r\n\r\n\r\n  @HostBinding('class') class = 'cmat-datetimepicker-toggle';\r\n  private _stateChanges = Subscription.EMPTY;\r\n  private _disabled: boolean;\r\n\r\n\r\n  constructor(protected intl: CmatDatetimepickerIntl, private _changeDetectorRef: ChangeDetectorRef) {\r\n  }\r\n\r\n  /** Whether the toggle button is disabled. */\r\n  @Input()\r\n  get disabled(): boolean {\r\n    return this._disabled === undefined ? this.datetimepicker.disabled : !!this._disabled;\r\n  }\r\n\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['datepicker']) {\r\n      this._watchStateChanges();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._stateChanges.unsubscribe();\r\n  }\r\n\r\n  ngAfterContentInit(): void {\r\n    this._watchStateChanges();\r\n  }\r\n\r\n  open(event: Event): void {\r\n    if (this.datetimepicker && !this.disabled) {\r\n      this.datetimepicker.open();\r\n      event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  private _watchStateChanges(): void {\r\n    const datepickerDisabled = this.datetimepicker ? this.datetimepicker.disabledChange : observableOf();\r\n    const inputDisabled = this.datetimepicker && this.datetimepicker.datetimepickerInput ?\r\n      this.datetimepicker.datetimepickerInput.disabledChange : observableOf();\r\n\r\n    this._stateChanges.unsubscribe();\r\n    this._stateChanges = merge([this.intl.changes, datepickerDisabled, inputDisabled])\r\n      .subscribe(() => this._changeDetectorRef.markForCheck());\r\n  }\r\n}\r\n","<button type=\"button\" (click)=\"open($event)\" [attr.aria-haspopup]=\"datetimepicker ? 'dialog' : null\"\r\n    [attr.aria-label]=\"ariaLabel || intl.openCalendarLabel\" [attr.tabindex]=\"disabled ? -1 : tabIndex\"\r\n    [disabled]=\"disabled\" [disableRipple]=\"disableRipple\" [disabled]=\"disabled\" mat-icon-button type=\"button\">\r\n    <ng-container *ngIf=\"!customIcon\" [ngSwitch]=\"datetimepicker.type\">\r\n        <svg *ngSwitchCase=\"'time'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchCase=\"'datetime'\" class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path\r\n                d=\"M15,13H16.5V15.82L18.94,17.23L18.19,18.53L15,16.69V13M19,8H5V19H9.67C9.24,18.09 9,17.07 9,16A7,7 0 0,1 16,9C17.07,9 18.09,9.24 19,9.67V8M5,21C3.89,21 3,20.1 3,19V5C3,3.89 3.89,3 5,3H6V1H8V3H16V1H18V3H19A2,2 0 0,1 21,5V11.1C22.24,12.36 23,14.09 23,16A7,7 0 0,1 16,23C14.09,23 12.36,22.24 11.1,21H5M16,11.15A4.85,4.85 0 0,0 11.15,16C11.15,18.68 13.32,20.85 16,20.85A4.85,4.85 0 0,0 20.85,16C20.85,13.32 18.68,11.15 16,11.15Z\">\r\n            </path>\r\n        </svg>\r\n        <svg *ngSwitchDefault class=\"cmat-datetimepicker-toggle-default-icon\" viewBox=\"0 0 24 24\" width=\"24px\"\r\n            height=\"24px\" fill=\"currentColor\" focusable=\"false\">\r\n            <path d=\"M0 0h24v24H0z\" fill=\"none\" />\r\n            <path\r\n                d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\r\n        </svg>\r\n    </ng-container>\r\n\r\n    <ng-content select=\"[cmatDatetimepickerToggleIcon]\"></ng-content>\r\n</button>"]}

package/esm2022/components/material-datetimepicker/datetimepicker-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWVwaWNrZXItdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbWF0L2NvbXBvbmVudHMvbWF0ZXJpYWwtZGF0ZXRpbWVwaWNrZXIvZGF0ZXRpbWVwaWNrZXItdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBQb3NzaWJsZSB0eXBlcyBmb3IgZGF0ZXRpbWVwaWNrZXIuICovXHJcbmV4cG9ydCB0eXBlIENtYXREYXRldGltZXBpY2tlclR5cGUgPSAnZGF0ZScgfCAndGltZScgfCAnbW9udGgnIHwgJ3llYXInIHwgJ2RhdGV0aW1lJztcclxuXHJcbi8qKiBQb3NzaWJsZSB2aWV3cyBmb3IgZGF0ZXRpbWVwaWNrZXIgY2FsZW5kYXIuICovXHJcbmV4cG9ydCB0eXBlIENtYXRDYWxlbmRhclZpZXcgPSAnY2xvY2snIHwgJ21vbnRoJyB8ICd5ZWFyJyB8ICdtdWx0aS15ZWFyJztcclxuXHJcbi8qKiBQb3NzaWJsZSB0eXBlcyBmb3IgQU0gLyBQTSAqL1xyXG5leHBvcnQgdHlwZSBDbWF0QU1QTSA9ICdBTScgfCAnUE0nO1xyXG5cclxuLyoqIFBvc3NpYmxlIG1vZGVzIGZvciBkYXRldGltZXBpY2tlciBkcm9wZG93biBkaXNwbGF5LiAqL1xyXG5leHBvcnQgdHlwZSBDbWF0RGF0ZXRpbWVwaWNrZXJNb2RlID0gJ2F1dG8nIHwgJ3BvcnRyYWl0JyB8ICdsYW5kc2NhcGUnO1xyXG5cclxuLyoqIFBvc3NpYmxlIHBvc2l0aW9ucyBmb3IgdGhlIGRhdGV0aW1lcGlja2VyIGRyb3Bkb3duIGFsb25nIHRoZSBYIGF4aXMuICovXHJcbmV4cG9ydCB0eXBlIERhdGV0aW1lcGlja2VyRHJvcGRvd25Qb3NpdGlvblggPSAnc3RhcnQnIHwgJ2VuZCc7XHJcblxyXG4vKiogUG9zc2libGUgcG9zaXRpb25zIGZvciB0aGUgZGF0ZXRpbWVwaWNrZXIgZHJvcGRvd24gYWxvbmcgdGhlIFkgYXhpcy4gKi9cclxuZXhwb3J0IHR5cGUgRGF0ZXRpbWVwaWNrZXJEcm9wZG93blBvc2l0aW9uWSA9ICdhYm92ZScgfCAnYmVsb3cnO1xyXG5cclxuZXhwb3J0IHR5cGUgQ21hdENsb2NrVmlldyA9ICdob3VyJyB8ICdtaW51dGUnO1xyXG4iXX0=