@elderbyte/ngx-starter 18.9.0 → 18.11.0

package/esm2022/lib/common/time/public_api.mjs

@@ -3,4 +3,6 @@ export * from './interval';
 export * from './interval-coerce';
 export * from './time-util';
 export * from './date-util';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VsZGVyYnl0ZS9uZ3gtc3RhcnRlci9zcmMvbGliL2NvbW1vbi90aW1lL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbmV4cG9ydCAqIGZyb20gJy4vcGVyaW9kLWR1cmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJ2YWwnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcnZhbC1jb2VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90aW1lLXV0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlLXV0aWwnO1xuIl19
+export * from './temporal-util';
+export * from './temporal-plain-date-interval';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VsZGVyYnl0ZS9uZ3gtc3RhcnRlci9zcmMvbGliL2NvbW1vbi90aW1lL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIlxuXG5leHBvcnQgKiBmcm9tICcuL3BlcmlvZC1kdXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2ludGVydmFsJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJ2YWwtY29lcmNlJztcbmV4cG9ydCAqIGZyb20gJy4vdGltZS11dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZS11dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vdGVtcG9yYWwtdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3RlbXBvcmFsLXBsYWluLWRhdGUtaW50ZXJ2YWwnO1xuIl19

package/esm2022/lib/common/time/temporal-plain-date-interval.mjs

@@ -0,0 +1,34 @@
+export class TemporalPlainDateInterval {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    shiftDays(days) {
+        return new TemporalPlainDateInterval(this.start.add({ days }), this.end.add({ days }));
+    }
+    shiftMonths(months) {
+        return new TemporalPlainDateInterval(this.start.add({ months }), this.end.add({ months }));
+    }
+    shiftYears(years) {
+        return new TemporalPlainDateInterval(this.start.add({ years }), this.end.add({ years }));
+    }
+    toString() {
+        return `${this.start.toString()} - ${this.end.toString()} (duration: ${this.getDurationInDays()} days)`;
+    }
+    getDuration() {
+        return this.start.until(this.end);
+    }
+    getDurationInDays() {
+        return this.getDuration().days;
+    }
+    getDurationInWeeks() {
+        return this.getDurationInDays() / 7;
+    }
+    getDurationInMonths() {
+        return this.getDuration().months;
+    }
+    getDurationInYears() {
+        return this.getDuration().years;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/time/temporal-util.mjs

@@ -0,0 +1,187 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { TemporalPlainDateInterval } from './temporal-plain-date-interval';
+export class TemporalUtil {
+    static getJSDateFromPlainDateTime(date) {
+        if (date instanceof Temporal.PlainDateTime) {
+            return new Date(date.year, date.month - 1, date.day, date.hour, date.minute, date.second, date.millisecond);
+        }
+        return new Date(date.year, date.month - 1, date.day);
+    }
+    static getPlainDateTimeFromJSDate(date) {
+        const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());
+        const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());
+        return Temporal.PlainDateTime.from(dateTimeIso);
+    }
+    static getPlainDateTimeFromPlainDateAndPlainTime(date, time) {
+        return Temporal.PlainDateTime.from({
+            year: date.year,
+            month: date.month,
+            day: date.day,
+            hour: time.hour,
+            minute: time.minute,
+            second: time.second,
+            millisecond: time.millisecond,
+        });
+    }
+    static isFirstDayOfWeek(date) {
+        return date.dayOfWeek === 1;
+    }
+    static getPlainDateFromJSDate(date) {
+        return this.createTemporalLocalizedDateFromTimestamp(date.getTime());
+    }
+    static getPlainTimeFromJSDate(date) {
+        const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());
+        const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());
+        return Temporal.PlainTime.from(dateTimeIso);
+    }
+    static getPlainDateTimeFromString(dateString) {
+        let jsDate = null;
+        try {
+            jsDate = new Date(dateString);
+            if (typeof jsDate !== 'object' || jsDate.constructor.name !== 'Date') {
+                throw new Error('Invalid date string');
+            }
+        }
+        catch (e) {
+            console.warn('Invalid date string', dateString);
+            return null;
+        }
+        return this.getPlainDateTimeFromJSDate(jsDate);
+    }
+    static getHtmlTimeStringFromPlainTime(time) {
+        if (!time) {
+            return '00:00:00';
+        }
+        return (time.hour.toString().padStart(2, '0') +
+            ':' +
+            time.minute.toString().padStart(2, '0') +
+            ':' +
+            time.second.toString().padStart(2, '0'));
+    }
+    static getQuarterForDate(date = TemporalUtil.getDateTodayLocalized()) {
+        return Math.floor((date.month - 1) / 3) + 1;
+    }
+    static getCurrentDay(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const today = referenceDate;
+        const tomorrow = today.add({ days: 1 });
+        return new TemporalPlainDateInterval(today, tomorrow);
+    }
+    static getYesterday(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const yesterday = referenceDate.subtract({ days: 1 });
+        return new TemporalPlainDateInterval(yesterday, referenceDate);
+    }
+    static getLastSevenDays(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return new TemporalPlainDateInterval(referenceDate.subtract({ days: 7 }), referenceDate);
+    }
+    static getLastThirtyDays(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return new TemporalPlainDateInterval(referenceDate.subtract({ days: 30 }), referenceDate);
+    }
+    static getCurrentWeek(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const startOfWeek = referenceDate.subtract({
+            days: referenceDate.dayOfWeek - 1,
+        });
+        const endOfWeek = startOfWeek.add({ days: 7 });
+        return new TemporalPlainDateInterval(startOfWeek, endOfWeek);
+    }
+    static getCurrentMonth(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const startOfMonth = referenceDate.subtract({
+            days: referenceDate.day - 1,
+        });
+        const endOfMonth = startOfMonth.add({ months: 1 });
+        return new TemporalPlainDateInterval(startOfMonth, endOfMonth);
+    }
+    static getCurrentQuarter(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const quarter = Math.floor((referenceDate.month - 1) / 3);
+        const startOfQuarter = referenceDate.subtract({
+            months: referenceDate.month - 1 - quarter * 3,
+            days: referenceDate.day - 1,
+        });
+        const endOfQuarter = startOfQuarter.add({ months: 3 });
+        return new TemporalPlainDateInterval(startOfQuarter, endOfQuarter);
+    }
+    static getPreviousQuarter(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentQuarter(referenceDate).shiftMonths(-3);
+    }
+    static getCurrentYear(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        const startOfYear = referenceDate.subtract({
+            days: referenceDate.dayOfYear - 1,
+        });
+        const endOfYear = startOfYear.add({ years: 1 });
+        return new TemporalPlainDateInterval(startOfYear, endOfYear);
+    }
+    static getPreviousYear(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentYear(referenceDate).shiftYears(-1);
+    }
+    static getNextYear(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentYear(referenceDate).shiftYears(1);
+    }
+    static getLast365Days(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return new TemporalPlainDateInterval(referenceDate.subtract({ days: 365 }), referenceDate);
+    }
+    static getLast90Days(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return new TemporalPlainDateInterval(referenceDate.subtract({ days: 90 }), referenceDate);
+    }
+    static getPreviousMonth(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentMonth(referenceDate).shiftMonths(-1);
+    }
+    static getNextMonth(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentMonth(referenceDate).shiftMonths(1);
+    }
+    static getPreviousWeek(referenceDate = TemporalUtil.getDateTodayLocalized()) {
+        return TemporalUtil.getCurrentWeek(referenceDate).shiftDays(-7);
+    }
+    static getDateTodayLocalized() {
+        return this.createTemporalLocalizedDateFromTimestamp(Date.now());
+    }
+    static createTemporalLocalizedDateFromTimestamp(timestamp) {
+        const instant = Temporal.Instant.fromEpochMilliseconds(timestamp);
+        const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());
+        const date = Temporal.PlainDate.from(dateTimeIso);
+        return date;
+    }
+    static getHtmlDateString(date) {
+        if (!date) {
+            return '';
+        }
+        return (date.year +
+            '-' +
+            date.month.toString().padStart(2, '0') +
+            '-' +
+            date.day.toString().padStart(2, '0'));
+    }
+    static getPlainDateFromHtmlDateString(dateString) {
+        if (!dateString) {
+            return null;
+        }
+        const dateArr = dateString.split('-');
+        if (dateArr.length !== 3) {
+            return null;
+        }
+        return Temporal.PlainDate.from({
+            year: parseInt(dateArr[0]),
+            month: parseInt(dateArr[1]),
+            day: parseInt(dateArr[2]),
+        });
+    }
+    static getPlainTimeFromHtmlTimeString(timeString) {
+        if (!timeString) {
+            return null;
+        }
+        const timeArr = timeString.split(':');
+        if (timeArr.length !== 2 && timeArr.length !== 3) {
+            return null;
+        }
+        if (timeArr.length === 2) {
+            return Temporal.PlainTime.from({
+                hour: parseInt(timeArr[0]),
+                minute: parseInt(timeArr[1]),
+            });
+        }
+        return Temporal.PlainTime.from({
+            hour: parseInt(timeArr[0]),
+            minute: parseInt(timeArr[1]),
+            second: parseInt(timeArr[2]),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"temporal-util.js","sourceRoot":"","sources":["../../../../../../../projects/elderbyte/ngx-starter/src/lib/common/time/temporal-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\nimport { TemporalPlainDateInterval } from './temporal-plain-date-interval';\n\nexport class TemporalUtil {\n  static getJSDateFromPlainDateTime(\n    date: Temporal.PlainDate | Temporal.PlainDateTime\n  ): Date {\n    if (date instanceof Temporal.PlainDateTime) {\n      return new Date(\n        date.year,\n        date.month - 1,\n        date.day,\n        date.hour,\n        date.minute,\n        date.second,\n        date.millisecond\n      );\n    }\n    return new Date(date.year, date.month - 1, date.day);\n  }\n\n  static getPlainDateTimeFromJSDate(date: Date): Temporal.PlainDateTime {\n    const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());\n    const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());\n    return Temporal.PlainDateTime.from(dateTimeIso);\n  }\n\n  static getPlainDateTimeFromPlainDateAndPlainTime(\n    date: Temporal.PlainDate,\n    time: Temporal.PlainTime\n  ): Temporal.PlainDateTime {\n    return Temporal.PlainDateTime.from({\n      year: date.year,\n      month: date.month,\n      day: date.day,\n      hour: time.hour,\n      minute: time.minute,\n      second: time.second,\n      millisecond: time.millisecond,\n    });\n  }\n\n  static isFirstDayOfWeek(\n    date: Temporal.PlainDate | Temporal.PlainDateTime\n  ): boolean {\n    return date.dayOfWeek === 1;\n  }\n\n  static getPlainDateFromJSDate(date: Date): Temporal.PlainDate {\n    return this.createTemporalLocalizedDateFromTimestamp(date.getTime());\n  }\n\n  static getPlainTimeFromJSDate(date: Date): Temporal.PlainTime {\n    const instant = Temporal.Instant.fromEpochMilliseconds(date.getTime());\n    const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());\n    return Temporal.PlainTime.from(dateTimeIso);\n  }\n\n  static getPlainDateTimeFromString(\n    dateString: string\n  ): Temporal.PlainDateTime {\n    let jsDate: Date = null;\n    try {\n      jsDate = new Date(dateString);\n      if (typeof jsDate !== 'object' || jsDate.constructor.name !== 'Date') {\n        throw new Error('Invalid date string');\n      }\n    } catch (e) {\n      console.warn('Invalid date string', dateString);\n      return null;\n    }\n\n    return this.getPlainDateTimeFromJSDate(jsDate);\n  }\n\n  static getHtmlTimeStringFromPlainTime(\n    time: Temporal.PlainTime | Temporal.PlainDateTime\n  ): string {\n    if (!time) {\n      return '00:00:00';\n    }\n    return (\n      time.hour.toString().padStart(2, '0') +\n      ':' +\n      time.minute.toString().padStart(2, '0') +\n      ':' +\n      time.second.toString().padStart(2, '0')\n    );\n  }\n\n  static getQuarterForDate(\n    date: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): number {\n    return Math.floor((date.month - 1) / 3) + 1;\n  }\n\n  static getCurrentDay(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const today = referenceDate;\n    const tomorrow = today.add({ days: 1 });\n    return new TemporalPlainDateInterval(today, tomorrow);\n  }\n\n  static getYesterday(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const yesterday = referenceDate.subtract({ days: 1 });\n    return new TemporalPlainDateInterval(yesterday, referenceDate);\n  }\n\n  static getLastSevenDays(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return new TemporalPlainDateInterval(\n      referenceDate.subtract({ days: 7 }),\n      referenceDate\n    );\n  }\n\n  static getLastThirtyDays(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return new TemporalPlainDateInterval(\n      referenceDate.subtract({ days: 30 }),\n      referenceDate\n    );\n  }\n\n  static getCurrentWeek(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const startOfWeek = referenceDate.subtract({\n      days: referenceDate.dayOfWeek - 1,\n    });\n    const endOfWeek = startOfWeek.add({ days: 7 });\n    return new TemporalPlainDateInterval(startOfWeek, endOfWeek);\n  }\n\n  static getCurrentMonth(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const startOfMonth = referenceDate.subtract({\n      days: referenceDate.day - 1,\n    });\n    const endOfMonth = startOfMonth.add({ months: 1 });\n    return new TemporalPlainDateInterval(startOfMonth, endOfMonth);\n  }\n\n  static getCurrentQuarter(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const quarter = Math.floor((referenceDate.month - 1) / 3);\n    const startOfQuarter = referenceDate.subtract({\n      months: referenceDate.month - 1 - quarter * 3,\n      days: referenceDate.day - 1,\n    });\n    const endOfQuarter = startOfQuarter.add({ months: 3 });\n    return new TemporalPlainDateInterval(startOfQuarter, endOfQuarter);\n  }\n\n  static getPreviousQuarter(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentQuarter(referenceDate).shiftMonths(-3);\n  }\n\n  static getCurrentYear(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    const startOfYear = referenceDate.subtract({\n      days: referenceDate.dayOfYear - 1,\n    });\n    const endOfYear = startOfYear.add({ years: 1 });\n    return new TemporalPlainDateInterval(startOfYear, endOfYear);\n  }\n\n  static getPreviousYear(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentYear(referenceDate).shiftYears(-1);\n  }\n\n  static getNextYear(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentYear(referenceDate).shiftYears(1);\n  }\n\n  static getLast365Days(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return new TemporalPlainDateInterval(\n      referenceDate.subtract({ days: 365 }),\n      referenceDate\n    );\n  }\n\n  static getLast90Days(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return new TemporalPlainDateInterval(\n      referenceDate.subtract({ days: 90 }),\n      referenceDate\n    );\n  }\n\n  static getPreviousMonth(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentMonth(referenceDate).shiftMonths(-1);\n  }\n\n  static getNextMonth(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentMonth(referenceDate).shiftMonths(1);\n  }\n\n  static getPreviousWeek(\n    referenceDate: Temporal.PlainDate = TemporalUtil.getDateTodayLocalized()\n  ): TemporalPlainDateInterval {\n    return TemporalUtil.getCurrentWeek(referenceDate).shiftDays(-7);\n  }\n\n  static getDateTodayLocalized(): Temporal.PlainDate {\n    return this.createTemporalLocalizedDateFromTimestamp(Date.now());\n  }\n\n  static createTemporalLocalizedDateFromTimestamp(\n    timestamp: number\n  ): Temporal.PlainDate {\n    const instant = Temporal.Instant.fromEpochMilliseconds(timestamp);\n    const dateTimeIso = instant.toZonedDateTimeISO(Temporal.Now.timeZoneId());\n    const date = Temporal.PlainDate.from(dateTimeIso);\n    return date;\n  }\n\n  static getHtmlDateString(\n    date: Temporal.PlainDate | Temporal.PlainDateTime\n  ): string {\n    if (!date) {\n      return '';\n    }\n    return (\n      date.year +\n      '-' +\n      date.month.toString().padStart(2, '0') +\n      '-' +\n      date.day.toString().padStart(2, '0')\n    );\n  }\n\n  static getPlainDateFromHtmlDateString(\n    dateString: string\n  ): Temporal.PlainDate {\n    if (!dateString) {\n      return null;\n    }\n    const dateArr = dateString.split('-');\n    if (dateArr.length !== 3) {\n      return null;\n    }\n    return Temporal.PlainDate.from({\n      year: parseInt(dateArr[0]),\n      month: parseInt(dateArr[1]),\n      day: parseInt(dateArr[2]),\n    });\n  }\n\n  static getPlainTimeFromHtmlTimeString(\n    timeString: string\n  ): Temporal.PlainTime {\n    if (!timeString) {\n      return null;\n    }\n    const timeArr = timeString.split(':');\n    if (timeArr.length !== 2 && timeArr.length !== 3) {\n      return null;\n    }\n\n    if( timeArr.length === 2 ) {\n      return Temporal.PlainTime.from({\n        hour: parseInt(timeArr[0]),\n        minute: parseInt(timeArr[1]),\n      });\n    }\n\n    return Temporal.PlainTime.from({\n      hour: parseInt(timeArr[0]),\n      minute: parseInt(timeArr[1]),\n      second: parseInt(timeArr[2]),\n    });\n  }\n}\n"]}

package/esm2022/lib/components/errors/error-util.mjs

@@ -65,7 +65,7 @@ export class ErrorUtil {
             if (errorDetail.message) {
                 detail += errorDetail.message;
             }
-            title = (errorDetail?.error ?? 'Error') + ': ' + errorDetail?.type ?? 'Unknown Exception';
+            title = `${errorDetail?.error ?? 'Error'}: ${errorDetail?.type ?? 'Unknown Exception'}`;
             return {
                 title: title,
                 detail: detail,
@@ -91,4 +91,4 @@ export class ErrorUtil {
         return error;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-util.js","sourceRoot":"","sources":["../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/errors/error-util.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpErrorResponse} from '@angular/common/http';\nimport {IStandardErrorDetail} from '../../common/errors/standard-error-detail';\nimport {LoggerFactory} from '@elderbyte/ts-logger';\nimport {ExceptionDetail} from '../../common/errors/exception-detail';\n\nexport class ErrorUtil {\n\n  /***************************************************************************\n   *                                                                         *\n   * Fields                                                                  *\n   *                                                                         *\n   **************************************************************************/\n\n  private static readonly logger = LoggerFactory.getLogger('ErrorUtil');\n\n  /***************************************************************************\n   *                                                                         *\n   * Public API                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n  public static buildExceptionDetail(error: any): ExceptionDetail {\n    if (error instanceof HttpErrorResponse) {\n      return ErrorUtil.httpErrorToExceptionDetail(error);\n    } else if (error instanceof Error) {\n      return {title: 'Error', detail: error.message, stacktrace: error.stack};\n    } else if (typeof error === 'string') {\n      return ErrorUtil.stringOrObjToExceptionDetail(error);\n    } else {\n      this.logger.trace('Unknown Error format. Stringifying error ...', error);\n      return {title: 'Unknown Error', detail: error, stacktrace: JSON.stringify(error)};\n    }\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Private methods                                                         *\n   *                                                                         *\n   **************************************************************************/\n\n  private static httpErrorToExceptionDetail(response: HttpErrorResponse): ExceptionDetail {\n    let detail: ExceptionDetail;\n    if (response.error) {\n      detail = ErrorUtil.stringOrObjToExceptionDetail(response.error);\n    }\n    if (!detail || !detail.detail) {\n      detail = {\n        title: response.statusText,\n        detail: response.message,\n        stacktrace: JSON.stringify(response)\n      };\n    }\n    return detail;\n  }\n\n  private static stringOrObjToExceptionDetail(value: string | object): ExceptionDetail {\n\n    const error = ErrorUtil.tryParseJson(value);\n\n    if (typeof error === 'string') {\n      return {\n        title: 'Error',\n        detail: error,\n        stacktrace: null\n      };\n    } else if (error) {\n      const errorDetail = error as IStandardErrorDetail;\n\n      let title = '';\n      let detail = '';\n\n      if (errorDetail.type) {\n        detail += errorDetail.type + ': ';\n      }\n\n      if (errorDetail.message) {\n        detail += errorDetail.message;\n      }\n\n      title = (errorDetail?.error ?? 'Error') + ': ' + errorDetail?.type ?? 'Unknown Exception';\n\n      return {\n        title: title,\n        detail: detail,\n        stacktrace: JSON.stringify(error)\n      };\n    } else {\n      return null;\n    }\n  }\n\n  private static tryParseJson(error: object | string): object | string {\n    if (typeof error === 'string') {\n      if ((error as string).startsWith('{')) {\n        try {\n          this.logger.trace('Error string seems to be JSON. Trying to parse JSON ...', error);\n          error = JSON.parse(error);\n        } catch (e) {\n          this.logger.trace('Failed to parse error string to JSON', e);\n        }\n      }\n    }\n    return error;\n  }\n\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-util.js","sourceRoot":"","sources":["../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/errors/error-util.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpErrorResponse} from '@angular/common/http';\nimport {IStandardErrorDetail} from '../../common/errors/standard-error-detail';\nimport {LoggerFactory} from '@elderbyte/ts-logger';\nimport {ExceptionDetail} from '../../common/errors/exception-detail';\n\nexport class ErrorUtil {\n\n  /***************************************************************************\n   *                                                                         *\n   * Fields                                                                  *\n   *                                                                         *\n   **************************************************************************/\n\n  private static readonly logger = LoggerFactory.getLogger('ErrorUtil');\n\n  /***************************************************************************\n   *                                                                         *\n   * Public API                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n  public static buildExceptionDetail(error: any): ExceptionDetail {\n    if (error instanceof HttpErrorResponse) {\n      return ErrorUtil.httpErrorToExceptionDetail(error);\n    } else if (error instanceof Error) {\n      return {title: 'Error', detail: error.message, stacktrace: error.stack};\n    } else if (typeof error === 'string') {\n      return ErrorUtil.stringOrObjToExceptionDetail(error);\n    } else {\n      this.logger.trace('Unknown Error format. Stringifying error ...', error);\n      return {title: 'Unknown Error', detail: error, stacktrace: JSON.stringify(error)};\n    }\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Private methods                                                         *\n   *                                                                         *\n   **************************************************************************/\n\n  private static httpErrorToExceptionDetail(response: HttpErrorResponse): ExceptionDetail {\n    let detail: ExceptionDetail;\n    if (response.error) {\n      detail = ErrorUtil.stringOrObjToExceptionDetail(response.error);\n    }\n    if (!detail || !detail.detail) {\n      detail = {\n        title: response.statusText,\n        detail: response.message,\n        stacktrace: JSON.stringify(response)\n      };\n    }\n    return detail;\n  }\n\n  private static stringOrObjToExceptionDetail(value: string | object): ExceptionDetail {\n\n    const error = ErrorUtil.tryParseJson(value);\n\n    if (typeof error === 'string') {\n      return {\n        title: 'Error',\n        detail: error,\n        stacktrace: null\n      };\n    } else if (error) {\n      const errorDetail = error as IStandardErrorDetail;\n\n      let title = '';\n      let detail = '';\n\n      if (errorDetail.type) {\n        detail += errorDetail.type + ': ';\n      }\n\n      if (errorDetail.message) {\n        detail += errorDetail.message;\n      }\n\n      title = `${errorDetail?.error ?? 'Error'}: ${errorDetail?.type ?? 'Unknown Exception'}`;\n\n      return {\n        title: title,\n        detail: detail,\n        stacktrace: JSON.stringify(error)\n      };\n    } else {\n      return null;\n    }\n  }\n\n  private static tryParseJson(error: object | string): object | string {\n    if (typeof error === 'string') {\n      if ((error as string).startsWith('{')) {\n        try {\n          this.logger.trace('Error string seems to be JSON. Trying to parse JSON ...', error);\n          error = JSON.parse(error);\n        } catch (e) {\n          this.logger.trace('Failed to parse error string to JSON', e);\n        }\n      }\n    }\n    return error;\n  }\n\n\n}\n"]}

package/esm2022/lib/components/time/elder-interval-input/elder-interval-input.component.mjs

@@ -41,6 +41,7 @@ export class ElderIntervalInputComponent extends ElderFormFieldControlBase {
          **************************************************************************/
         this.logger = LoggerFactory.getLogger(this.constructor.name);
         this._mode = 'date-time-range';
+        this._isDefaultDatePickerDisabled = false;
         this.zone = ZoneId.systemDefault();
         this.controlType = this._mode;
         this.interval$ = this.value$.pipe(map(value => coerceInterval(value)));
@@ -69,6 +70,12 @@ export class ElderIntervalInputComponent extends ElderFormFieldControlBase {
     get mode() {
         return this._mode;
     }
+    set isDefaultDatePickerDisabled(hide) {
+        this._isDefaultDatePickerDisabled = coerceBooleanProperty(hide);
+    }
+    get isDefaultDatePickerDisabled() {
+        return this._isDefaultDatePickerDisabled;
+    }
     get isoValueChange() {
         return this.valueChange.pipe(map(value => coerceIntervalIsoStr(value)));
     }
@@ -179,9 +186,9 @@ export class ElderIntervalInputComponent extends ElderFormFieldControlBase {
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ElderIntervalInputComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.FocusMonitor }, { token: i2.TranslateService }, { token: i3.NgControl, optional: true, self: true }, { token: i4.DateAdapter }, { token: MAT_DATE_LOCALE }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.2", type: ElderIntervalInputComponent, isStandalone: true, selector: "elder-interval-input", inputs: { zone: "zone", valueAsIsoStr: "valueAsIsoStr", mode: "mode", isoValue: "isoValue" }, outputs: { isoValueChange: "isoValueChange" }, providers: [
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.2", type: ElderIntervalInputComponent, isStandalone: true, selector: "elder-interval-input", inputs: { zone: "zone", valueAsIsoStr: "valueAsIsoStr", mode: "mode", isDefaultDatePickerDisabled: "isDefaultDatePickerDisabled", isoValue: "isoValue" }, outputs: { isoValueChange: "isoValueChange" }, providers: [
             { provide: MatFormFieldControl, useExisting: ElderIntervalInputComponent },
-        ], usesInheritance: true, ngImport: i0, template: "@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">\u2013</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <mat-date-range-input\n        class=\"mdc-text-field__input\"\n        [rangePicker]=\"picker\"\n        [disabled]=\"!!disabled\"\n      >\n        <input matStartDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onStartDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n        <input matEndDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onEndDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n      </mat-date-range-input>\n      <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                             [disabled]=\"isLocked\"\n                             [for]=\"picker\">\n        <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n      </mat-datepicker-toggle>\n      <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n", styles: [".elder-flex-interval-control{flex:1 1 auto;overflow:hidden}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: ElderDateTimeInputComponent, selector: "elder-date-time-input", inputs: ["center", "isoValue"], outputs: ["isoValueChange"] }, { kind: "component", type: ElderLocalTimeInputComponent, selector: "elder-local-time-input", inputs: ["isoValue"], outputs: ["isoValueChange"] }, { kind: "component", type: MatDateRangeInput, selector: "mat-date-range-input", inputs: ["rangePicker", "required", "dateFilter", "min", "max", "disabled", "separator", "comparisonStart", "comparisonEnd"], exportAs: ["matDateRangeInput"] }, { kind: "directive", type: MatStartDate, selector: "input[matStartDate]", outputs: ["dateChange", "dateInput"] }, { kind: "directive", type: MatEndDate, selector: "input[matEndDate]", outputs: ["dateChange", "dateInput"] }, { kind: "component", type: MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: MatDatepickerToggleIcon, selector: "[matDatepickerToggleIcon]" }, { kind: "component", type: MatDateRangePicker, selector: "mat-date-range-picker", exportAs: ["matDateRangePicker"] }, { kind: "component", type: ElderLocalDateInputComponent, selector: "elder-local-date-input", inputs: ["zone", "autoDatePicker", "arrows", "today", "center", "datePickerTouchUi", "allowNull", "datePickerEnabled", "isoValue", "dateValue", "isoDateValue"], outputs: ["blurred", "valueUpdatedBlur", "isoValueChange", "dateValueChange", "isoDateValueChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+        ], usesInheritance: true, ngImport: i0, template: "@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">\u2013</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n        <mat-date-range-input\n          class=\"mdc-text-field__input\"\n          [rangePicker]=\"picker\"\n          [disabled]=\"!!disabled\"\n        >\n          <input matStartDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onStartDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n          <input matEndDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onEndDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n        </mat-date-range-input>\n\n        @if(!isDefaultDatePickerDisabled){\n          <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                                [disabled]=\"isLocked\"\n                                [for]=\"picker\">\n            <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n          </mat-datepicker-toggle>\n        }\n        <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n", styles: [".elder-flex-interval-control{flex:1 1 auto;overflow:hidden}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i2.TranslatePipe, name: "translate" }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: ElderDateTimeInputComponent, selector: "elder-date-time-input", inputs: ["center", "isoValue"], outputs: ["isoValueChange"] }, { kind: "component", type: ElderLocalTimeInputComponent, selector: "elder-local-time-input", inputs: ["isoValue"], outputs: ["isoValueChange"] }, { kind: "component", type: MatDateRangeInput, selector: "mat-date-range-input", inputs: ["rangePicker", "required", "dateFilter", "min", "max", "disabled", "separator", "comparisonStart", "comparisonEnd"], exportAs: ["matDateRangeInput"] }, { kind: "directive", type: MatStartDate, selector: "input[matStartDate]", outputs: ["dateChange", "dateInput"] }, { kind: "directive", type: MatEndDate, selector: "input[matEndDate]", outputs: ["dateChange", "dateInput"] }, { kind: "component", type: MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "component", type: MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: MatDatepickerToggleIcon, selector: "[matDatepickerToggleIcon]" }, { kind: "component", type: MatDateRangePicker, selector: "mat-date-range-picker", exportAs: ["matDateRangePicker"] }, { kind: "component", type: ElderLocalDateInputComponent, selector: "elder-local-date-input", inputs: ["zone", "autoDatePicker", "arrows", "today", "center", "datePickerTouchUi", "allowNull", "datePickerEnabled", "isoValue", "dateValue", "isoDateValue"], outputs: ["blurred", "valueUpdatedBlur", "isoValueChange", "dateValueChange", "isoDateValueChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: ElderIntervalInputComponent, decorators: [{
             type: Component,
@@ -191,7 +198,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImpor
                         ElderDateTimeInputComponent, ElderLocalTimeInputComponent,
                         MatDateRangeInput, MatStartDate,
                         MatEndDate, MatDatepickerToggle, MatIcon, MatDatepickerToggleIcon, MatDateRangePicker,
-                        ElderLocalDateInputComponent], template: "@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">\u2013</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <mat-date-range-input\n        class=\"mdc-text-field__input\"\n        [rangePicker]=\"picker\"\n        [disabled]=\"!!disabled\"\n      >\n        <input matStartDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onStartDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n        <input matEndDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onEndDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n      </mat-date-range-input>\n      <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                             [disabled]=\"isLocked\"\n                             [for]=\"picker\">\n        <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n      </mat-datepicker-toggle>\n      <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n", styles: [".elder-flex-interval-control{flex:1 1 auto;overflow:hidden}\n"] }]
+                        ElderLocalDateInputComponent], template: "@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">\u2013</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n        <mat-date-range-input\n          class=\"mdc-text-field__input\"\n          [rangePicker]=\"picker\"\n          [disabled]=\"!!disabled\"\n        >\n          <input matStartDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onStartDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n          <input matEndDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onEndDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n        </mat-date-range-input>\n\n        @if(!isDefaultDatePickerDisabled){\n          <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                                [disabled]=\"isLocked\"\n                                [for]=\"picker\">\n            <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n          </mat-datepicker-toggle>\n        }\n        <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n", styles: [".elder-flex-interval-control{flex:1 1 auto;overflow:hidden}\n"] }]
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.FocusMonitor }, { type: i2.TranslateService }, { type: i3.NgControl, decorators: [{
                     type: Optional
                 }, {
@@ -205,9 +212,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImpor
                 type: Input
             }], mode: [{
                 type: Input
+            }], isDefaultDatePickerDisabled: [{
+                type: Input
             }], isoValueChange: [{
                 type: Output
             }], isoValue: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elder-interval-input.component.js","sourceRoot":"","sources":["../../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/time/elder-interval-input/elder-interval-input.component.ts","../../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/time/elder-interval-input/elder-interval-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  NgZone,\n  Optional,\n  Output,\n  Self\n} from '@angular/core';\nimport {LoggerFactory} from '@elderbyte/ts-logger';\nimport {Interval, IsoIntervalStr} from '../../../common/time/interval';\nimport {Observable, of} from 'rxjs';\nimport {catchError, map} from 'rxjs/operators';\nimport {Instant, LocalDate, LocalTime, ZoneId} from '@js-joda/core';\nimport {ElderFormFieldControlBase} from '../../../common/forms/elder-form-field-control-base.directive';\nimport {FocusMonitor} from '@angular/cdk/a11y';\nimport {TranslateService, TranslateModule} from '@ngx-translate/core';\nimport {NgControl, FormsModule} from '@angular/forms';\nimport {MatFormFieldControl} from '@angular/material/form-field';\nimport {TimeUtil} from '../../../common/time/time-util';\nimport {DateAdapter, MAT_DATE_LOCALE} from '@angular/material/core';\nimport {LocaleDateFormats} from '../date-formats/locale-date-formats';\nimport {ElderLocalDateInputComponent} from '../elder-local-date-input/elder-local-date-input.component';\nimport {MatIcon} from '@angular/material/icon';\nimport {\n  MatDateRangeInput,\n  MatStartDate,\n  MatEndDate,\n  MatDatepickerToggle,\n  MatDatepickerToggleIcon,\n  MatDateRangePicker\n} from '@angular/material/datepicker';\nimport {ElderLocalTimeInputComponent} from '../elder-local-time-input/elder-local-time-input.component';\nimport {ElderDateTimeInputComponent} from '../elder-date-time-input/elder-date-time-input.component';\nimport {AsyncPipe} from '@angular/common';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {coerceInterval, coerceIntervalIsoStr} from '../../../common/time/interval-coerce';\n\nexport type IntervalInputMode =\n\n/**\n * Supports the selection of a single (full) day:\n * 12.12.2020\n */\n  'single-day' |\n\n  /**\n   * Supports a time interval in a day:\n   * 12.12.2020 13:00 - 18:00\n   */\n  'day-time-range' |\n\n  /**\n   * Supports a date interval without time\n   * 12.12.2020 - 22.06.2021\n   */\n  'date-range' |\n\n  /**\n   * Supports a date-time to date-time interval\n   * 12.12.2020 8:00 - 22.06.2021 17:00\n   * This is the default as it supports the most detailed input.\n   */\n  'date-time-range'\n  ;\n\n@Component({\n  selector: 'elder-interval-input',\n  templateUrl: './elder-interval-input.component.html',\n  styleUrls: ['./elder-interval-input.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {provide: MatFormFieldControl, useExisting: ElderIntervalInputComponent},\n  ],\n  standalone: true,\n  imports: [AsyncPipe, TranslateModule, FormsModule,\n    ElderDateTimeInputComponent, ElderLocalTimeInputComponent,\n    MatDateRangeInput, MatStartDate,\n    MatEndDate, MatDatepickerToggle, MatIcon, MatDatepickerToggleIcon, MatDateRangePicker,\n    ElderLocalDateInputComponent]\n})\nexport class ElderIntervalInputComponent extends ElderFormFieldControlBase<Interval | IsoIntervalStr> {\n\n  /***************************************************************************\n   *                                                                         *\n   * Fields                                                                  *\n   *                                                                         *\n   **************************************************************************/\n\n  private readonly logger = LoggerFactory.getLogger(this.constructor.name);\n\n  private _mode: IntervalInputMode = 'date-time-range';\n\n  @Input()\n  public zone = ZoneId.systemDefault();\n\n  public readonly endTime$: Observable<LocalTime>;\n\n  public readonly startLocalDate$: Observable<LocalDate>;\n  public readonly endLocalDate$: Observable<LocalDate>;\n\n  public readonly startDate$: Observable<Date>;\n  public readonly endDate$: Observable<Date>;\n\n  public readonly dateformat: string;\n\n  public readonly interval$: Observable<Interval>;\n  private _valueAsIsoStr: boolean;\n\n  /***************************************************************************\n   *                                                                         *\n   * Constructor                                                             *\n   *                                                                         *\n   **************************************************************************/\n\n  constructor(\n    hostRef: ElementRef,\n    zone: NgZone,\n    focusMonitor: FocusMonitor,\n    translateService: TranslateService,\n    @Optional() @Self() public ngControl: NgControl,\n    customDateAdapter: DateAdapter<Date>,\n    @Inject(MAT_DATE_LOCALE) matDateLocale: string\n  ) {\n    super(\n      hostRef,\n      'interval-input', // => mat-mdc-form-field-type-interval-input\n      focusMonitor,\n      translateService,\n      ngControl\n    );\n\n    this.controlType = this._mode;\n    this.interval$ = this.value$.pipe(\n      map(value => coerceInterval(value))\n    );\n\n    this.endTime$ = this.interval$.pipe(\n      map(interval => interval?.end ? LocalTime.from(interval.end.atZone(this.zone)) : null)\n    );\n\n    this.startLocalDate$ = this.interval$.pipe(\n      map(interval => interval?.start ? LocalDate.from(interval.start.atZone(this.zone)) : null)\n    );\n\n    this.endLocalDate$ = this.interval$.pipe(\n      map(interval => interval?.end ? LocalDate.from(interval.end.atZone(this.zone)) : null)\n    );\n\n    this.startDate$ = this.mapIgnoreErrorObservable(this.startLocalDate$, (d: LocalDate) => TimeUtil.localDateToDate(d));\n    this.endDate$ = this.mapIgnoreErrorObservable(this.endLocalDate$, (d: LocalDate) => TimeUtil.localDateToDate(d));\n\n    this.dateformat = LocaleDateFormats.getFormatsOfLocale(matDateLocale)[0].toLowerCase();\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Properties                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n\n  @Input()\n  public set valueAsIsoStr(enabled: BooleanInput) {\n    this._valueAsIsoStr = coerceBooleanProperty(enabled);\n  }\n\n  public get valueAsIsoStr(): boolean {\n    return this._valueAsIsoStr;\n  }\n\n  @Input()\n  public set mode(mode: IntervalInputMode) {\n    this._mode = mode;\n    this.controlType = mode;\n  }\n\n  public get mode(): IntervalInputMode {\n    return this._mode;\n  }\n\n  @Output()\n  public get isoValueChange(): Observable<IsoIntervalStr | null> {\n    return this.valueChange.pipe(\n      map(value => coerceIntervalIsoStr(value))\n    );\n  }\n\n  @Input()\n  public set isoValue(value: IsoIntervalStr | null) {\n    this.value = value ? this.coerceValue(value) : null;\n  }\n\n  public get shouldLabelFloat(): boolean {\n    return true;\n  }\n\n  public get interval(): Interval | undefined {\n    return coerceInterval(this.value);\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Public API                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n\n  public focus(options?: FocusOptions): void {\n    this.logger.warn('focus() not yet supported!');\n    // this.inputRef?.nativeElement?.focus(options);\n  }\n\n  public blur(): void {\n    this.logger.warn('blur() not yet supported!');\n    // this.inputRef?.nativeElement?.blur();\n  }\n\n  public onDayTimeStartChanged(start: Instant) {\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        this.instantAtEndOfDay(start)\n      )\n    );\n  }\n\n  public onDayTimeEndTimeChanged(endTime: LocalTime): void {\n    const start = this.interval.start;\n    const end = this.instantWithTime(start, endTime);\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        !end.isAfter(start) ? this.instantAtEndOfDay(start) : end\n      )\n    );\n  }\n\n  public onStartChanged(start: Instant): void {\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        this.interval.end\n      )\n    );\n  }\n\n  public onEndChanged(end: Instant): void {\n    this.updateCoercedValue(\n      Interval.of(\n        this.interval.start,\n        end\n      )\n    );\n  }\n\n  public onStartDateChanged(value: Date | null): void {\n    const date = this.toLocalDate(value);\n    this.updateCoercedValue(\n      Interval.of(\n        this.localDateToInstant(date),\n        this.interval?.end\n      )\n    );\n  }\n\n  public onEndDateChanged(value: Date | null): void {\n    const date = this.toLocalDate(value);\n    this.updateCoercedValue(\n      Interval.of(\n        this.interval?.start,\n        this.localDateToInstant(date)\n      )\n    );\n  }\n\n  public onSingleDayDateChanged(date: LocalDate): void {\n    this.updateCoercedValue(\n      Interval.ofDay(date, this.zone)\n    );\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Private methods                                                         *\n   *                                                                         *\n   **************************************************************************/\n\n  private updateCoercedValue(\n    value: Interval | IsoIntervalStr | undefined | null\n  ): void {\n    this.updateValue(this.coerceValue(value));\n  }\n\n  private instantAtStartOfDayNow(): Instant {\n    return LocalDate.now().atStartOfDay().atZone(this.zone).toInstant();\n  }\n\n  private instantAtEndOfDay(instant: Instant): Instant {\n    return LocalDate.ofInstant(instant).atStartOfDay().plusDays(1).atZone(this.zone).toInstant();\n  }\n\n  private localDateToInstant(date: LocalDate): Instant | undefined {\n    if (date) {\n      return date.atStartOfDay().atZone(this.zone).toInstant();\n    } else {\n      return undefined;\n    }\n  }\n\n  protected valuesEquals(\n    a: Interval | IsoIntervalStr | undefined | null,\n    b: Interval | IsoIntervalStr | undefined | null\n  ): boolean {\n    const aInterval = coerceInterval(a);\n    const bInterval = coerceInterval(b);\n    return (aInterval && bInterval)\n      ? aInterval.equals(bInterval)\n      : aInterval === bInterval;\n  }\n\n  private instantWithTime(instant: Instant, time: LocalTime): Instant {\n    return instant\n      .atZone(this.zone)\n      .withHour(time.hour())\n      .withMinute(time.minute())\n      .toInstant();\n  }\n\n  private toLocalDate(value: Date): LocalDate | null {\n    try {\n      return value ? TimeUtil.dateToLocalDate(value) : null;\n    } catch (err) {\n      this.logger.warn('Failed to apply value to dateValue: ' + value, err);\n      return null;\n    }\n  }\n\n  private mapIgnoreErrorObservable<T>(\n    date: Observable<LocalDate>,\n    conversionFn: (d: LocalDate) => T\n  ): Observable<T | null> {\n    return date.pipe(\n      map(localDate => localDate ? conversionFn(localDate) : null),\n      catchError(err => {\n        this.logger.error('Failed to convert local date!', err);\n        return of(null);\n      })\n    );\n  }\n\n  private coerceValue(\n    value: Interval | IsoIntervalStr | undefined | null\n  ): Interval | IsoIntervalStr | undefined | null {\n    if (this.valueAsIsoStr) {\n      return coerceIntervalIsoStr(value);\n    } else {\n      return coerceInterval(value);\n    }\n  }\n}\n","@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">–</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <mat-date-range-input\n        class=\"mdc-text-field__input\"\n        [rangePicker]=\"picker\"\n        [disabled]=\"!!disabled\"\n      >\n        <input matStartDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onStartDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n        <input matEndDate\n               [placeholder]=\"dateformat\"\n               [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n               [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n               (ngModelChange)=\"onEndDateChanged($event)\"\n               [readonly]=\"readonly\"\n               [disabled]=\"!!disabled\"\n        >\n      </mat-date-range-input>\n      <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                             [disabled]=\"isLocked\"\n                             [for]=\"picker\">\n        <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n      </mat-datepicker-toggle>\n      <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elder-interval-input.component.js","sourceRoot":"","sources":["../../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/time/elder-interval-input/elder-interval-input.component.ts","../../../../../../../../projects/elderbyte/ngx-starter/src/lib/components/time/elder-interval-input/elder-interval-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  Inject,\n  Input,\n  NgZone,\n  Optional,\n  Output,\n  Self\n} from '@angular/core';\nimport {LoggerFactory} from '@elderbyte/ts-logger';\nimport {Interval, IsoIntervalStr} from '../../../common/time/interval';\nimport {Observable, of} from 'rxjs';\nimport {catchError, map} from 'rxjs/operators';\nimport {Instant, LocalDate, LocalTime, ZoneId} from '@js-joda/core';\nimport {ElderFormFieldControlBase} from '../../../common/forms/elder-form-field-control-base.directive';\nimport {FocusMonitor} from '@angular/cdk/a11y';\nimport {TranslateService, TranslateModule} from '@ngx-translate/core';\nimport {NgControl, FormsModule} from '@angular/forms';\nimport {MatFormFieldControl} from '@angular/material/form-field';\nimport {TimeUtil} from '../../../common/time/time-util';\nimport {DateAdapter, MAT_DATE_LOCALE} from '@angular/material/core';\nimport {LocaleDateFormats} from '../date-formats/locale-date-formats';\nimport {ElderLocalDateInputComponent} from '../elder-local-date-input/elder-local-date-input.component';\nimport {MatIcon} from '@angular/material/icon';\nimport {\n  MatDateRangeInput,\n  MatStartDate,\n  MatEndDate,\n  MatDatepickerToggle,\n  MatDatepickerToggleIcon,\n  MatDateRangePicker\n} from '@angular/material/datepicker';\nimport {ElderLocalTimeInputComponent} from '../elder-local-time-input/elder-local-time-input.component';\nimport {ElderDateTimeInputComponent} from '../elder-date-time-input/elder-date-time-input.component';\nimport {AsyncPipe} from '@angular/common';\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {coerceInterval, coerceIntervalIsoStr} from '../../../common/time/interval-coerce';\n\nexport type IntervalInputMode =\n\n/**\n * Supports the selection of a single (full) day:\n * 12.12.2020\n */\n  'single-day' |\n\n  /**\n   * Supports a time interval in a day:\n   * 12.12.2020 13:00 - 18:00\n   */\n  'day-time-range' |\n\n  /**\n   * Supports a date interval without time\n   * 12.12.2020 - 22.06.2021\n   */\n  'date-range' |\n\n  /**\n   * Supports a date-time to date-time interval\n   * 12.12.2020 8:00 - 22.06.2021 17:00\n   * This is the default as it supports the most detailed input.\n   */\n  'date-time-range'\n  ;\n\n@Component({\n  selector: 'elder-interval-input',\n  templateUrl: './elder-interval-input.component.html',\n  styleUrls: ['./elder-interval-input.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {provide: MatFormFieldControl, useExisting: ElderIntervalInputComponent},\n  ],\n  standalone: true,\n  imports: [AsyncPipe, TranslateModule, FormsModule,\n    ElderDateTimeInputComponent, ElderLocalTimeInputComponent,\n    MatDateRangeInput, MatStartDate,\n    MatEndDate, MatDatepickerToggle, MatIcon, MatDatepickerToggleIcon, MatDateRangePicker,\n    ElderLocalDateInputComponent]\n})\nexport class ElderIntervalInputComponent extends ElderFormFieldControlBase<Interval | IsoIntervalStr> {\n\n  /***************************************************************************\n   *                                                                         *\n   * Fields                                                                  *\n   *                                                                         *\n   **************************************************************************/\n\n  private readonly logger = LoggerFactory.getLogger(this.constructor.name);\n\n  private _mode: IntervalInputMode = 'date-time-range';\n  private _isDefaultDatePickerDisabled = false;\n\n  @Input()\n  public zone = ZoneId.systemDefault();\n\n  public readonly endTime$: Observable<LocalTime>;\n\n  public readonly startLocalDate$: Observable<LocalDate>;\n  public readonly endLocalDate$: Observable<LocalDate>;\n\n  public readonly startDate$: Observable<Date>;\n  public readonly endDate$: Observable<Date>;\n\n  public readonly dateformat: string;\n\n  public readonly interval$: Observable<Interval>;\n  private _valueAsIsoStr: boolean;\n\n  /***************************************************************************\n   *                                                                         *\n   * Constructor                                                             *\n   *                                                                         *\n   **************************************************************************/\n\n  constructor(\n    hostRef: ElementRef,\n    zone: NgZone,\n    focusMonitor: FocusMonitor,\n    translateService: TranslateService,\n    @Optional() @Self() public ngControl: NgControl,\n    customDateAdapter: DateAdapter<Date>,\n    @Inject(MAT_DATE_LOCALE) matDateLocale: string\n  ) {\n    super(\n      hostRef,\n      'interval-input', // => mat-mdc-form-field-type-interval-input\n      focusMonitor,\n      translateService,\n      ngControl\n    );\n\n    this.controlType = this._mode;\n    this.interval$ = this.value$.pipe(\n      map(value => coerceInterval(value))\n    );\n\n    this.endTime$ = this.interval$.pipe(\n      map(interval => interval?.end ? LocalTime.from(interval.end.atZone(this.zone)) : null)\n    );\n\n    this.startLocalDate$ = this.interval$.pipe(\n      map(interval => interval?.start ? LocalDate.from(interval.start.atZone(this.zone)) : null)\n    );\n\n    this.endLocalDate$ = this.interval$.pipe(\n      map(interval => interval?.end ? LocalDate.from(interval.end.atZone(this.zone)) : null)\n    );\n\n    this.startDate$ = this.mapIgnoreErrorObservable(this.startLocalDate$, (d: LocalDate) => TimeUtil.localDateToDate(d));\n    this.endDate$ = this.mapIgnoreErrorObservable(this.endLocalDate$, (d: LocalDate) => TimeUtil.localDateToDate(d));\n\n    this.dateformat = LocaleDateFormats.getFormatsOfLocale(matDateLocale)[0].toLowerCase();\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Properties                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n\n  @Input()\n  public set valueAsIsoStr(enabled: BooleanInput) {\n    this._valueAsIsoStr = coerceBooleanProperty(enabled);\n  }\n\n  public get valueAsIsoStr(): boolean {\n    return this._valueAsIsoStr;\n  }\n\n  @Input()\n  public set mode(mode: IntervalInputMode) {\n    this._mode = mode;\n    this.controlType = mode;\n  }\n\n  public get mode(): IntervalInputMode {\n    return this._mode;\n  }\n\n  @Input()\n  public set isDefaultDatePickerDisabled(hide: BooleanInput) {\n    this._isDefaultDatePickerDisabled = coerceBooleanProperty(hide);\n  }\n\n  public get isDefaultDatePickerDisabled(): boolean {\n    return this._isDefaultDatePickerDisabled;\n  }\n\n  @Output()\n  public get isoValueChange(): Observable<IsoIntervalStr | null> {\n    return this.valueChange.pipe(\n      map(value => coerceIntervalIsoStr(value))\n    );\n  }\n\n  @Input()\n  public set isoValue(value: IsoIntervalStr | null) {\n    this.value = value ? this.coerceValue(value) : null;\n  }\n\n  public get shouldLabelFloat(): boolean {\n    return true;\n  }\n\n  public get interval(): Interval | undefined {\n    return coerceInterval(this.value);\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Public API                                                              *\n   *                                                                         *\n   **************************************************************************/\n\n\n  public focus(options?: FocusOptions): void {\n    this.logger.warn('focus() not yet supported!');\n    // this.inputRef?.nativeElement?.focus(options);\n  }\n\n  public blur(): void {\n    this.logger.warn('blur() not yet supported!');\n    // this.inputRef?.nativeElement?.blur();\n  }\n\n  public onDayTimeStartChanged(start: Instant) {\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        this.instantAtEndOfDay(start)\n      )\n    );\n  }\n\n  public onDayTimeEndTimeChanged(endTime: LocalTime): void {\n    const start = this.interval.start;\n    const end = this.instantWithTime(start, endTime);\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        !end.isAfter(start) ? this.instantAtEndOfDay(start) : end\n      )\n    );\n  }\n\n  public onStartChanged(start: Instant): void {\n    this.updateCoercedValue(\n      Interval.of(\n        start,\n        this.interval.end\n      )\n    );\n  }\n\n  public onEndChanged(end: Instant): void {\n    this.updateCoercedValue(\n      Interval.of(\n        this.interval.start,\n        end\n      )\n    );\n  }\n\n  public onStartDateChanged(value: Date | null): void {\n    const date = this.toLocalDate(value);\n    this.updateCoercedValue(\n      Interval.of(\n        this.localDateToInstant(date),\n        this.interval?.end\n      )\n    );\n  }\n\n  public onEndDateChanged(value: Date | null): void {\n    const date = this.toLocalDate(value);\n    this.updateCoercedValue(\n      Interval.of(\n        this.interval?.start,\n        this.localDateToInstant(date)\n      )\n    );\n  }\n\n  public onSingleDayDateChanged(date: LocalDate): void {\n    this.updateCoercedValue(\n      Interval.ofDay(date, this.zone)\n    );\n  }\n\n  /***************************************************************************\n   *                                                                         *\n   * Private methods                                                         *\n   *                                                                         *\n   **************************************************************************/\n\n  private updateCoercedValue(\n    value: Interval | IsoIntervalStr | undefined | null\n  ): void {\n    this.updateValue(this.coerceValue(value));\n  }\n\n  private instantAtStartOfDayNow(): Instant {\n    return LocalDate.now().atStartOfDay().atZone(this.zone).toInstant();\n  }\n\n  private instantAtEndOfDay(instant: Instant): Instant {\n    return LocalDate.ofInstant(instant).atStartOfDay().plusDays(1).atZone(this.zone).toInstant();\n  }\n\n  private localDateToInstant(date: LocalDate): Instant | undefined {\n    if (date) {\n      return date.atStartOfDay().atZone(this.zone).toInstant();\n    } else {\n      return undefined;\n    }\n  }\n\n  protected valuesEquals(\n    a: Interval | IsoIntervalStr | undefined | null,\n    b: Interval | IsoIntervalStr | undefined | null\n  ): boolean {\n    const aInterval = coerceInterval(a);\n    const bInterval = coerceInterval(b);\n    return (aInterval && bInterval)\n      ? aInterval.equals(bInterval)\n      : aInterval === bInterval;\n  }\n\n  private instantWithTime(instant: Instant, time: LocalTime): Instant {\n    return instant\n      .atZone(this.zone)\n      .withHour(time.hour())\n      .withMinute(time.minute())\n      .toInstant();\n  }\n\n  private toLocalDate(value: Date): LocalDate | null {\n    try {\n      return value ? TimeUtil.dateToLocalDate(value) : null;\n    } catch (err) {\n      this.logger.warn('Failed to apply value to dateValue: ' + value, err);\n      return null;\n    }\n  }\n\n  private mapIgnoreErrorObservable<T>(\n    date: Observable<LocalDate>,\n    conversionFn: (d: LocalDate) => T\n  ): Observable<T | null> {\n    return date.pipe(\n      map(localDate => localDate ? conversionFn(localDate) : null),\n      catchError(err => {\n        this.logger.error('Failed to convert local date!', err);\n        return of(null);\n      })\n    );\n  }\n\n  private coerceValue(\n    value: Interval | IsoIntervalStr | undefined | null\n  ): Interval | IsoIntervalStr | undefined | null {\n    if (this.valueAsIsoStr) {\n      return coerceIntervalIsoStr(value);\n    } else {\n      return coerceInterval(value);\n    }\n  }\n}\n","@switch (mode) {\n\n  @case ('date-time-range') {\n    <div class=\"layout-row\">\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.start\"\n                             (valueUpdated)=\"onStartChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n      <span class=\"mat-date-range-input-separator flex-none\">–</span>\n      <elder-date-time-input class=\"flex\" center\n                             [value]=\"(interval$ | async)?.end\"\n                             (valueUpdated)=\"onEndChanged($event)\"\n                             [required]=\"required\"\n                             [readonly]=\"readonly\"\n                             [disabled]=\"disabled\"\n                             [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-date-time-input>\n    </div>\n  }\n  @case ('day-time-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n\n      <!--  [name]=\"name + '-day-start'\" -->\n      <elder-date-time-input\n        [value]=\"(interval$ | async)?.start\"\n        (valueUpdated)=\"onDayTimeStartChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.from' | translate)\"\n      ></elder-date-time-input>\n\n      <!-- [name]=\"name + '-day-end'\" -->\n      <elder-local-time-input\n        [value]=\"endTime$ | async\"\n        (valueUpdated)=\"onDayTimeEndTimeChanged($event)\"\n        [required]=\"required\"\n        [readonly]=\"readonly\"\n        [disabled]=\"disabled\"\n        [placeholder]=\"(placeholder || '') + ' ' + ('interval.to' | translate)\"\n      ></elder-local-time-input>\n    </div>\n  }\n\n  @case ('date-range') {\n    <div class=\"layout-row gap-xs elder-flex-interval-control\">\n        <mat-date-range-input\n          class=\"mdc-text-field__input\"\n          [rangePicker]=\"picker\"\n          [disabled]=\"!!disabled\"\n        >\n          <input matStartDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"startDate$ | async\" name=\"date-range.start\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onStartDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n          <input matEndDate\n                [placeholder]=\"dateformat\"\n                [ngModel]=\"endDate$ | async\" name=\"date-range.end\"\n                [ngModelOptions]=\"{ standalone: true, updateOn: 'blur'}\"\n                (ngModelChange)=\"onEndDateChanged($event)\"\n                [readonly]=\"readonly\"\n                [disabled]=\"!!disabled\"\n          >\n        </mat-date-range-input>\n\n        @if(!isDefaultDatePickerDisabled){\n          <mat-datepicker-toggle class=\"elder-control-icon-button\"\n                                [disabled]=\"isLocked\"\n                                [for]=\"picker\">\n            <mat-icon matDatepickerToggleIcon>calendar_month</mat-icon>\n          </mat-datepicker-toggle>\n        }\n        <mat-date-range-picker #picker></mat-date-range-picker>\n    </div>\n  }\n\n  @case ('single-day') {\n    <div class=\"layout-row elder-flex-control\">\n\n      <!-- [name]=\"name\" -->\n      <elder-local-date-input class=\"flex\" center\n                              [value]=\"startLocalDate$ | async\"\n                              (valueUpdated)=\"onSingleDayDateChanged($event)\"\n                              [required]=\"required\"\n                              [readonly]=\"readonly\"\n                              [disabled]=\"disabled\"\n                              [placeholder]=\"(placeholder || '')\"\n      ></elder-local-date-input>\n    </div>\n  }\n}\n\n\n\n\n\n\n"]}