@muziehdesign/components 18.3.0-beta.2385 → 19.2.0-beta.2377

package/esm2022/lib/alert/alert.component.mjs

@@ -0,0 +1,46 @@
+import { CommonModule } from '@angular/common';
+import { Component, Input } from '@angular/core';
+import { SvgIconComponent } from '../svg-icon/svg-icon.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AlertComponent {
+    constructor() {
+        this.title = '';
+        this.type = 'info';
+    }
+    ngOnInit() { }
+    getAlertClass() {
+        return `alert-${this.type}`;
+    }
+    getAlertIcon() {
+        let icon = '';
+        if (this.type === 'info') {
+            icon = 'information-circle';
+        }
+        else if (this.type === 'success') {
+            icon = 'check-circle';
+        }
+        else if (this.type === 'error') {
+            icon = 'x-circle';
+        }
+        else if (this.type === 'warning') {
+            icon = 'exclamation';
+        }
+        return icon;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AlertComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: AlertComponent, isStandalone: true, selector: "mz-alert", inputs: { title: "title", type: "type", body: "body", footer: "footer" }, ngImport: i0, template: "<div [className]=\"'alert alert-' + type\">\n\n  <div>\n    <div class=\"alert-icon\">\n      <mz-svg-icon [key]=\"getAlertIcon()\" type=\"solid\"></mz-svg-icon>\n    </div>\n\n    <div class=\"alert-title\">\n      <strong>{{ title }}</strong>\n    </div>\n  </div>\n\n  <div class=\"alert-body\" *ngIf=\"body\">\n    <ng-container *ngTemplateOutlet=\"body\"></ng-container>\n  </div>\n\n  <div class=\"alert-footer\" *ngIf=\"footer\">\n    <ng-container *ngTemplateOutlet=\"footer\"></ng-container>\n  </div>\n\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: SvgIconComponent, selector: "mz-svg-icon", inputs: ["key", "type", "size"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AlertComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mz-alert', imports: [CommonModule, SvgIconComponent], standalone: true, template: "<div [className]=\"'alert alert-' + type\">\n\n  <div>\n    <div class=\"alert-icon\">\n      <mz-svg-icon [key]=\"getAlertIcon()\" type=\"solid\"></mz-svg-icon>\n    </div>\n\n    <div class=\"alert-title\">\n      <strong>{{ title }}</strong>\n    </div>\n  </div>\n\n  <div class=\"alert-body\" *ngIf=\"body\">\n    <ng-container *ngTemplateOutlet=\"body\"></ng-container>\n  </div>\n\n  <div class=\"alert-footer\" *ngIf=\"footer\">\n    <ng-container *ngTemplateOutlet=\"footer\"></ng-container>\n  </div>\n\n</div>" }]
+        }], ctorParameters: () => [], propDecorators: { title: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], body: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/button.directive.mjs

@@ -0,0 +1,86 @@
+import { Directive, ElementRef, HostBinding, Input, Renderer2 } from '@angular/core';
+import { fromEvent, Subscription } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class ButtonDirective {
+    constructor(renderer, hostElement) {
+        this.renderer = renderer;
+        this.hostElement = hostElement;
+        this.variant = 'secondary';
+        this.busy = false;
+        this.svgContent = `
+    <svg class="button-loading-spinner" xmlns="http://www.w3.org/2000/svg" fill="none"
+        viewBox="0 0 24 24">
+        <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4">
+        </circle>
+        <path class="opacity-75" fill="currentColor"
+            d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z">
+        </path>
+    </svg>
+    `;
+        this.subscription = new Subscription();
+    }
+    ngOnChanges(changes) {
+        if (changes['busy'] && Boolean(changes['busy'].previousValue) !== Boolean(changes['busy'].currentValue)) {
+            this.attachOrDeattachSpinner();
+        }
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    get elementClass() {
+        return ['button', `button-${this.variant}`, this.busy ? 'loading' : ''].join(' ');
+    }
+    attachOrDeattachSpinner() {
+        if (this.busy) {
+            const loadingElement = this.renderer.createElement('span');
+            loadingElement.innerHTML = this.svgContent;
+            this.renderer.addClass(loadingElement, 'button-loading-overlay');
+            this.renderer.appendChild(this.hostElement.nativeElement, loadingElement);
+            this.addEventSubscription();
+        }
+        else {
+            this.renderer.removeChild(this.hostElement.nativeElement, this.getOverlayDiv());
+            this.subscription?.unsubscribe();
+        }
+    }
+    addEventSubscription() {
+        const el = this.hostElement.nativeElement;
+        this.subscription = fromEvent(el.parentNode, 'click', { capture: true })
+            .pipe(filter((e) => Boolean(this.busy && this.getElementsToVerify().includes(e.target))))
+            .subscribe((e) => {
+            e.stopPropagation();
+        });
+    }
+    getChildElement(query) {
+        return this.hostElement.nativeElement.querySelector(query);
+    }
+    getElementsToVerify() {
+        return [this.hostElement.nativeElement, this.getOverlayDiv(), this.getChildElement('.button-loading-overlay'), this.getChildElement('.button-loading-overlay svg'), this.getChildElement('.button-loading-overlay svg circle'), this.getChildElement('.button-loading-overlay svg path')];
+    }
+    getOverlayDiv() {
+        return this.getChildElement('.button-loading-overlay');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ButtonDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ButtonDirective, isStandalone: true, selector: "[mzButton]", inputs: { variant: "variant", busy: "busy" }, host: { attributes: { "role": "button" }, properties: { "attr.tabindex": "0", "attr.aria-disabled": "busy", "class": "this.elementClass" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mzButton]',
+                    standalone: true,
+                    host: {
+                        role: 'button',
+                        '[attr.tabindex]': '0',
+                        '[attr.aria-disabled]': 'busy',
+                    },
+                }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }], propDecorators: { variant: [{
+                type: Input
+            }], busy: [{
+                type: Input
+            }], elementClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components.module.mjs

@@ -0,0 +1,130 @@
+import { CommonModule, DatePipe } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { SpinnerComponent } from './spinner/spinner.component';
+import { EnumDisplayPipe } from './enum-display/enum-display.pipe';
+import { SvgIconComponent } from './svg-icon/svg-icon.component';
+import { ResultTableComponent } from './result-table/result-table.component';
+import { PaginationComponent } from './pagination/pagination.component';
+import { PageLoadingIndicatorComponent } from './page-loading-indicator/page-loading-indicator.component';
+import { PageHeaderComponent } from './page-header/page-header.component';
+import { TimeValueAccessorDirective } from './time-value-accessor.directive';
+import { FormsModule } from '@angular/forms';
+import { AlertComponent } from './alert/alert.component';
+import { PhoneNumberPipe } from './phone-number/phone-number.pipe';
+import { DateDisplayPipe } from './date-display/date-display.pipe';
+import { SortDirective } from './sort.directive';
+import { SortKeyDirective } from './sort-key.directive';
+import { SubjectDisplayPipe } from './subject-display/subject-display.pipe';
+import { ButtonDirective } from './button.directive';
+import { WizardProgressTrackerComponent } from './wizard-progress-tracker/wizard-progress-tracker.component';
+import { DateTimeComponent } from './date-time/date-time.component';
+import { TimeValueValidatorDirective } from './time-value-validator.directive';
+import { InfiniteScrollComponent } from './infinite-scroll/infinite-scroll.component';
+import * as i0 from "@angular/core";
+export class MuziehComponentsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MuziehComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: MuziehComponentsModule, imports: [CommonModule,
+            FormsModule,
+            ButtonDirective,
+            SvgIconComponent,
+            SpinnerComponent,
+            WizardProgressTrackerComponent,
+            AlertComponent,
+            EnumDisplayPipe,
+            ResultTableComponent,
+            InfiniteScrollComponent,
+            PaginationComponent,
+            PageLoadingIndicatorComponent,
+            PageHeaderComponent,
+            TimeValueAccessorDirective,
+            DateDisplayPipe,
+            PhoneNumberPipe,
+            SortKeyDirective,
+            SortDirective,
+            SubjectDisplayPipe,
+            DateTimeComponent,
+            TimeValueValidatorDirective], exports: [EnumDisplayPipe,
+            SpinnerComponent,
+            SvgIconComponent,
+            ResultTableComponent,
+            InfiniteScrollComponent,
+            PaginationComponent,
+            PageLoadingIndicatorComponent,
+            PageHeaderComponent,
+            TimeValueAccessorDirective,
+            DateDisplayPipe,
+            AlertComponent,
+            PhoneNumberPipe,
+            SortKeyDirective,
+            SortDirective,
+            SubjectDisplayPipe,
+            ButtonDirective,
+            WizardProgressTrackerComponent,
+            DateTimeComponent,
+            TimeValueValidatorDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MuziehComponentsModule, providers: [
+            DatePipe,
+        ], imports: [CommonModule,
+            FormsModule,
+            SpinnerComponent,
+            WizardProgressTrackerComponent,
+            AlertComponent,
+            ResultTableComponent,
+            InfiniteScrollComponent,
+            PaginationComponent,
+            PageLoadingIndicatorComponent,
+            DateTimeComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MuziehComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ButtonDirective,
+                        SvgIconComponent,
+                        SpinnerComponent,
+                        WizardProgressTrackerComponent,
+                        AlertComponent,
+                        EnumDisplayPipe,
+                        ResultTableComponent,
+                        InfiniteScrollComponent,
+                        PaginationComponent,
+                        PageLoadingIndicatorComponent,
+                        PageHeaderComponent,
+                        TimeValueAccessorDirective,
+                        DateDisplayPipe,
+                        PhoneNumberPipe,
+                        SortKeyDirective,
+                        SortDirective,
+                        SubjectDisplayPipe,
+                        DateTimeComponent,
+                        TimeValueValidatorDirective,
+                    ],
+                    exports: [
+                        EnumDisplayPipe,
+                        SpinnerComponent,
+                        SvgIconComponent,
+                        ResultTableComponent,
+                        InfiniteScrollComponent,
+                        PaginationComponent,
+                        PageLoadingIndicatorComponent,
+                        PageHeaderComponent,
+                        TimeValueAccessorDirective,
+                        DateDisplayPipe,
+                        AlertComponent,
+                        PhoneNumberPipe,
+                        SortKeyDirective,
+                        SortDirective,
+                        SubjectDisplayPipe,
+                        ButtonDirective,
+                        WizardProgressTrackerComponent,
+                        DateTimeComponent,
+                        TimeValueValidatorDirective,
+                    ],
+                    providers: [
+                        DatePipe,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/date-display/date-display-config.mjs

@@ -0,0 +1,12 @@
+import { InjectionToken } from "@angular/core";
+export const DATE_PIPE_CONFIG_OPTIONS = Object.freeze({
+    formats: new Map([
+        ['short', 'MM/dd/yyyy hh:mm a'],
+        ['medium', 'MMM d y h:mm:ss a'],
+        ['shortDate', 'MM/dd/yyyy'],
+        ['mediumDate', 'MMM d y']
+    ]),
+    dateFormat: 'MM/dd/yyyy hh:mm a'
+});
+export const MZ_DATE_PIPE_DEFAULT_OPTIONS = new InjectionToken('MzDateDisplayDefaultOptions');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1kaXNwbGF5LWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9kYXRlLWRpc3BsYXkvZGF0ZS1kaXNwbGF5LWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRTlDLE1BQU0sQ0FBQyxNQUFNLHdCQUF3QixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDbEQsT0FBTyxFQUFFLElBQUksR0FBRyxDQUFpQjtRQUM3QixDQUFDLE9BQU8sRUFBRSxvQkFBb0IsQ0FBQztRQUMvQixDQUFDLFFBQVEsRUFBRSxtQkFBbUIsQ0FBQztRQUMvQixDQUFDLFdBQVcsRUFBRSxZQUFZLENBQUM7UUFDM0IsQ0FBQyxZQUFZLEVBQUUsU0FBUyxDQUFDO0tBQzVCLENBQUM7SUFDRixVQUFVLEVBQUUsb0JBQW9CO0NBQ1IsQ0FBQyxDQUFDO0FBTTlCLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHLElBQUksY0FBYyxDQUFtQiw2QkFBNkIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0ZVBpcGVDb25maWcgfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uXCI7XG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCJcblxuZXhwb3J0IGNvbnN0IERBVEVfUElQRV9DT05GSUdfT1BUSU9OUyA9IE9iamVjdC5mcmVlemUoe1xuICAgIGZvcm1hdHM6IG5ldyBNYXA8c3RyaW5nLCBzdHJpbmc+KFtcbiAgICAgICAgWydzaG9ydCcsICdNTS9kZC95eXl5IGhoOm1tIGEnXSxcbiAgICAgICAgWydtZWRpdW0nLCAnTU1NIGQgeSBoOm1tOnNzIGEnXSxcbiAgICAgICAgWydzaG9ydERhdGUnLCAnTU0vZGQveXl5eSddLFxuICAgICAgICBbJ21lZGl1bURhdGUnLCAnTU1NIGQgeSddXG4gICAgXSksXG4gICAgZGF0ZUZvcm1hdDogJ01NL2RkL3l5eXkgaGg6bW0gYSdcbn0gc2F0aXNmaWVzIE16RGF0ZVBpcGVDb25maWcpO1xuXG5leHBvcnQgaW50ZXJmYWNlIE16RGF0ZVBpcGVDb25maWcgZXh0ZW5kcyBEYXRlUGlwZUNvbmZpZyB7XG4gICAgZm9ybWF0czogTWFwPHN0cmluZywgc3RyaW5nPlxufVxuXG5leHBvcnQgY29uc3QgTVpfREFURV9QSVBFX0RFRkFVTFRfT1BUSU9OUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxNekRhdGVQaXBlQ29uZmlnPignTXpEYXRlRGlzcGxheURlZmF1bHRPcHRpb25zJyk7Il19

package/esm2022/lib/date-display/date-display.pipe.mjs

@@ -0,0 +1,35 @@
+import { DatePipe } from '@angular/common';
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @deprecated use mzDate instead
+ */
+export class DateDisplayPipe {
+    constructor(datePipe) {
+        this.datePipe = datePipe;
+    }
+    transform(value, format) {
+        let redefinedDate;
+        if (format === 'concise') {
+            redefinedDate = this.datePipe.transform(value, 'MM/dd/yyyy');
+        }
+        else if (format === 'detailed') {
+            redefinedDate = this.datePipe.transform(value, 'MM/dd/yyyy h:mm:ss a');
+        }
+        else {
+            redefinedDate = this.datePipe.transform(value, 'MM/dd/yyyy');
+        }
+        return redefinedDate;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateDisplayPipe, deps: [{ token: i1.DatePipe }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: DateDisplayPipe, isStandalone: true, name: "mzDateDisplay" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateDisplayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mzDateDisplay',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.DatePipe }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/date-display/date.pipe.mjs

@@ -0,0 +1,41 @@
+import { DatePipe } from '@angular/common';
+import { Inject, LOCALE_ID, Optional, Pipe } from '@angular/core';
+import { DATE_PIPE_CONFIG_OPTIONS, MZ_DATE_PIPE_DEFAULT_OPTIONS } from './date-display-config';
+import * as i0 from "@angular/core";
+export class MzDatePipe extends DatePipe {
+    constructor(locale, defaultMzOptions) {
+        const o = defaultMzOptions || DATE_PIPE_CONFIG_OPTIONS;
+        super(locale, null, o);
+        this.options = o;
+    }
+    transform(value, format, timezone, locale) {
+        let translatedFormat = format;
+        let translatedTimezone = timezone;
+        if (format) {
+            translatedFormat = this.options.formats.get(format) || format;
+        }
+        if (timezone === 'original' && typeof value === 'string') {
+            const match = value.match(/([+-]\d{2}:\d{2})$/);
+            translatedTimezone = match ? match[1] : '+00:00';
+        }
+        return super.transform(value, translatedFormat, translatedTimezone, locale);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MzDatePipe, deps: [{ token: LOCALE_ID }, { token: MZ_DATE_PIPE_DEFAULT_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: MzDatePipe, isStandalone: true, name: "mzDate" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MzDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'mzDate',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MZ_DATE_PIPE_DEFAULT_OPTIONS]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/date-time/date-time.component.mjs

@@ -0,0 +1,139 @@
+import { ChangeDetectorRef, Component, forwardRef, Input, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatDatepicker } from '@angular/material/datepicker';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/datepicker";
+export class DateTimeComponent {
+    constructor(_cd) {
+        this._cd = _cd;
+        this.lz = (n) => ('0' + n).slice(-2);
+        this.formatDate = (dt) => `${dt.getMonth() + 1}/${dt.getDate()}/${dt.getFullYear()}`;
+        this.formatTime = (t) => `${this.lz(t.getHours())}:${this.lz(t.getMinutes())}`;
+        this.formatDateTime = (dt, t) => `${this.formatDate(dt)} ${t}`;
+        this.limitDate = (dt) => {
+            if (this.min) {
+                dt = new Date(Math.max(dt.getTime(), this.min.getTime()));
+            }
+            if (this.max) {
+                dt = new Date(Math.min(dt.getTime(), this.max.getTime()));
+            }
+            return dt;
+        };
+        this.onTimeHourPending = false;
+        this.type = 'outline';
+        this.disabled = false;
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
+    }
+    writeValue(value) {
+        if (value) {
+            const dt = new Date(value);
+            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());
+            this.time = this.formatTime(value);
+        }
+        else {
+            this.date = undefined;
+            this.time = undefined;
+        }
+        this._cd.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    updateDate(e) {
+        const input = e.target;
+        let dt = new Date(input.value);
+        if (!isNaN(dt.getTime())) {
+            dt = this.limitDate(dt);
+            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());
+            if (this.time === undefined || this.time === '') {
+                this.time = this.formatTime(new Date());
+            }
+        }
+        else {
+            this.date = undefined;
+            this.time = undefined;
+        }
+        this.propagateModelChange();
+        this._cd.markForCheck();
+    }
+    updateTime(e) {
+        const input = e.target;
+        // this is just a listener event in case the end user types in "0". We wait for
+        // the next entered value for the time input field to self fix the problem.
+        if (!this.onTimeHourPending && !input.value) {
+            this.onTimeHourPending = true;
+            return;
+        }
+        this.onTimeHourPending = false;
+        if (!input.value) {
+            this.date = undefined;
+        }
+        else if (!this.date || isNaN(this.date.getTime())) {
+            const dt = this.limitDate(this.min ?? new Date());
+            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());
+        }
+        this.time = input.value;
+        this.propagateModelChange();
+    }
+    updateDateEvent(event) {
+        if (event.value) {
+            const dt = this.limitDate(new Date(event.value));
+            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());
+            if (this.time === undefined || this.time === '') {
+                this.time = this.formatTime(new Date());
+            }
+        }
+        else {
+            this.date = undefined;
+            this.time = undefined;
+        }
+        this.propagateModelChange();
+        this._cd.markForCheck();
+    }
+    focusOnDateInput() {
+        this.datepicker.open();
+    }
+    propagateModelChange() {
+        if (this.time && this.date) {
+            const dateString = this.formatDateTime(this.date, this.time);
+            this.onChange(new Date(dateString));
+        }
+        else {
+            this.onChange(undefined);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimeComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: DateTimeComponent, isStandalone: true, selector: "mz-datetime", inputs: { min: "min", max: "max", disabled: "disabled" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => DateTimeComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "datepicker", first: true, predicate: ["datePicker"], descendants: true }], ngImport: i0, template: "<div class=\"flex\">\n  <div class=\"field-control-combo\">\n    <input class=\"field-control\" type=\"text\" [value]=\"date\" (change)=\"updateDate($event)\" [min]=\"min\" [max]=\"max\"\n      [matDatepicker]=\"datePicker\" (dateChange)=\"updateDateEvent($event)\" [disabled]=\"disabled\" ngDefaultControl>\n    <div class=\"field-control-addon\">\n      <button class=\"button button-secondary button-icon\" type=\"button\" (click)=\"datePicker.open()\"\n        [disabled]=\"disabled\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"h-6 w-6\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\"\n          stroke-width=\"2\">\n          <path stroke-linecap=\"round\" stroke-linejoin=\"round\"\n            d=\"M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z\" />\n        </svg>\n      </button>\n      <mat-datepicker #datePicker></mat-datepicker>\n    </div>\n  </div>\n  <div class=\"field-control-group mt-1 ml-6\">\n    <input class=\"field-control\" type=\"time\" [value]=\"time\" (change)=\"updateTime($event)\"\n      ngDefaultControl [disabled]=\"disabled\">\n  </div>\n</div>\n", styles: ["input:disabled,button:disabled{opacity:.6}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDatepickerModule }, { kind: "component", type: i1.MatDatepicker, selector: "mat-datepicker", exportAs: ["matDatepicker"] }, { kind: "directive", type: i1.MatDatepickerInput, selector: "input[matDatepicker]", inputs: ["matDatepicker", "min", "max", "matDatepickerFilter"], exportAs: ["matDatepickerInput"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mz-datetime', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DateTimeComponent),
+                            multi: true,
+                        },
+                    ], imports: [CommonModule, MatDatepickerModule], standalone: true, template: "<div class=\"flex\">\n  <div class=\"field-control-combo\">\n    <input class=\"field-control\" type=\"text\" [value]=\"date\" (change)=\"updateDate($event)\" [min]=\"min\" [max]=\"max\"\n      [matDatepicker]=\"datePicker\" (dateChange)=\"updateDateEvent($event)\" [disabled]=\"disabled\" ngDefaultControl>\n    <div class=\"field-control-addon\">\n      <button class=\"button button-secondary button-icon\" type=\"button\" (click)=\"datePicker.open()\"\n        [disabled]=\"disabled\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"h-6 w-6\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\"\n          stroke-width=\"2\">\n          <path stroke-linecap=\"round\" stroke-linejoin=\"round\"\n            d=\"M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z\" />\n        </svg>\n      </button>\n      <mat-datepicker #datePicker></mat-datepicker>\n    </div>\n  </div>\n  <div class=\"field-control-group mt-1 ml-6\">\n    <input class=\"field-control\" type=\"time\" [value]=\"time\" (change)=\"updateTime($event)\"\n      ngDefaultControl [disabled]=\"disabled\">\n  </div>\n</div>\n", styles: ["input:disabled,button:disabled{opacity:.6}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { datepicker: [{
+                type: ViewChild,
+                args: ['datePicker']
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time.component.js","sourceRoot":"","sources":["../../../../../projects/components/src/lib/date-time/date-time.component.ts","../../../../../projects/components/src/lib/date-time/date-time.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, forwardRef, Input, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatDatepickerInputEvent, MatDatepickerModule } from '@angular/material/datepicker';\nimport { TimeValue } from './time-value';\nimport { MatDatepicker } from '@angular/material/datepicker';\nimport { CommonModule } from '@angular/common';\n\n@Component({\n    selector: 'mz-datetime',\n    templateUrl: './date-time.component.html',\n    styleUrls: ['./date-time.component.css'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => DateTimeComponent),\n            multi: true,\n        },\n    ],\n    imports: [CommonModule, MatDatepickerModule],\n    standalone: true,\n})\nexport class DateTimeComponent implements ControlValueAccessor {\n    date: Date | undefined;\n    time: string | undefined;\n\n    private lz = (n: number) => ('0' + n).slice(-2);\n    private formatDate = (dt: Date) => `${dt.getMonth() + 1}/${dt.getDate()}/${dt.getFullYear()}`;\n    private formatTime = (t: Date) => `${this.lz(t.getHours())}:${this.lz(t.getMinutes())}`;\n    private formatDateTime = (dt: Date, t: string) => `${this.formatDate(dt)} ${t}`;\n    private limitDate = (dt: Date) => {\n        if (this.min) {\n            dt = new Date(Math.max(dt.getTime(), this.min.getTime()));\n        }\n\n        if (this.max) {\n            dt = new Date(Math.min(dt.getTime(), this.max.getTime()));\n        }\n\n        return dt;\n    };\n    private onTimeHourPending = false; \n\n    type = 'outline';\n    @ViewChild('datePicker') datepicker!: MatDatepicker<Date>;\n\n    @Input()\n    min?: Date | undefined;\n\n    @Input()\n    max?: Date | undefined;\n\n    @Input()\n    disabled = false;\n\n    constructor(private _cd: ChangeDetectorRef) {}\n\n    onChange = (_: any) => {};\n    onTouched = () => {};\n\n    writeValue(value: Date) {\n        if (value) {\n            const dt = new Date(value);\n\n            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());\n            this.time = this.formatTime(value);\n        } else {\n            this.date = undefined;\n            this.time = undefined;\n        }\n\n        this._cd.markForCheck();\n    }\n\n    registerOnChange(fn: (value: any) => any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouched = fn;\n    }\n\n    updateDate(e: Event): void {\n        const input = e.target as HTMLInputElement;\n\n        let dt = new Date(input.value);\n\n        if (!isNaN(dt.getTime())) {\n            dt = this.limitDate(dt);\n\n            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());\n\n            if (this.time === undefined || this.time === '') {\n                this.time = this.formatTime(new Date());\n            }\n        } else {\n            this.date = undefined;\n            this.time = undefined;\n        }\n\n        this.propagateModelChange();\n        this._cd.markForCheck();\n    }\n\n    updateTime(e: Event): void {\n        const input = e.target as HTMLInputElement;\n\n        // this is just a listener event in case the end user types in \"0\". We wait for\n        // the next entered value for the time input field to self fix the problem.\n        if (!this.onTimeHourPending && !input.value) {\n            this.onTimeHourPending = true;\n            return;\n        }\n\n        this.onTimeHourPending = false;\n\n        if (!input.value) {\n            this.date = undefined;\n        } else if (!this.date || isNaN(this.date.getTime())) {\n            const dt = this.limitDate(this.min ?? new Date());\n\n            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());\n        }\n        this.time = input.value;\n\n        this.propagateModelChange();\n    }\n\n    updateDateEvent(event: MatDatepickerInputEvent<Date>) {\n        if (event.value) {\n            const dt = this.limitDate(new Date(event.value));\n\n            this.date = new Date(dt.getFullYear(), dt.getMonth(), dt.getDate());\n\n            if (this.time === undefined || this.time === '') {\n                this.time = this.formatTime(new Date());\n            }\n        } else {\n            this.date = undefined;\n            this.time = undefined;\n        }\n\n        this.propagateModelChange();\n        this._cd.markForCheck();\n    }\n\n    focusOnDateInput() {\n        this.datepicker.open();\n    }\n\n    private propagateModelChange(): void {\n        if (this.time && this.date) {\n            const dateString = this.formatDateTime(this.date, this.time);\n            this.onChange(new Date(dateString));\n        } else {\n            this.onChange(undefined);\n        }\n    }\n}\n\nexport interface ScheduleInputModel {\n    time: TimeValue;\n}\n","<div class=\"flex\">\n  <div class=\"field-control-combo\">\n    <input class=\"field-control\" type=\"text\" [value]=\"date\" (change)=\"updateDate($event)\" [min]=\"min\" [max]=\"max\"\n      [matDatepicker]=\"datePicker\" (dateChange)=\"updateDateEvent($event)\" [disabled]=\"disabled\" ngDefaultControl>\n    <div class=\"field-control-addon\">\n      <button class=\"button button-secondary button-icon\" type=\"button\" (click)=\"datePicker.open()\"\n        [disabled]=\"disabled\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" class=\"h-6 w-6\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\"\n          stroke-width=\"2\">\n          <path stroke-linecap=\"round\" stroke-linejoin=\"round\"\n            d=\"M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z\" />\n        </svg>\n      </button>\n      <mat-datepicker #datePicker></mat-datepicker>\n    </div>\n  </div>\n  <div class=\"field-control-group mt-1 ml-6\">\n    <input class=\"field-control\" type=\"time\" [value]=\"time\" (change)=\"updateTime($event)\"\n      ngDefaultControl [disabled]=\"disabled\">\n  </div>\n</div>\n"]}

package/esm2022/lib/date-time/time-value.mjs

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