@simpleangularcontrols/sac-common 10.0.0-rc.1

package/esm2015/controls/datetime/dateselector.js

@@ -0,0 +1,458 @@
+import { EventEmitter, Input, Output, Directive, Injector, } from '@angular/core';
+import * as moment_ from 'moment';
+import { SACICON_SERVICE, SacDefaultIconService } from '../../services';
+// #region Classes
+/**
+ *Basis Komponente für DateSelectorItem
+ */
+class DateSelectorItem {
+    // #endregion Properties
+    // #region Constructors
+    /**
+     * Konstruktor
+     * @param displaytext Anzeigetext
+     * @param date Datum
+     * @param isenabled Element ist aktiv
+     * @param isselected Element ist selektiert
+     * @param iscurrent Element ist aktuelles Element
+     * @param isnew Element ist neu
+     */
+    constructor(displaytext, date, isenabled, isselected, iscurrent, isnew) {
+        // #region Properties
+        /**
+         * Datum
+         */
+        this.date = undefined;
+        /**
+         * DisplayText Property; default Wert - ''
+         */
+        this.displaytext = '';
+        /**
+         * Boolean Property, die zeigt, ob das Element aktuell ist; default Wert - false
+         */
+        this.iscurrent = false;
+        /**
+         * Boolean Property, die zeigt, ob das Control enabled ist; default Wert - false
+         */
+        this.isenabled = false;
+        /**
+         * Boolean Property, die zeigt, ob das Element neu ist; default Wert - false
+         */
+        this.isnew = false;
+        /**
+         * Boolean Property, die zeigt, ob das Element selektiert ist; default Wert - false
+         */
+        this.isselected = false;
+        this.displaytext = displaytext;
+        this.date = date;
+        this.isenabled = isenabled;
+        this.iscurrent = iscurrent;
+        this.isselected = isselected;
+        this.isnew = isnew;
+    }
+}
+/**
+ *Basis Komponente für SacDateSelector
+ */
+export class SacDateSelectorCommon {
+    // #endregion Properties
+    // #region Constructors
+    constructor(injector) {
+        /**
+         * Anfang des Kalenders
+         */
+        this.beginOfCalendar = 1;
+        /**
+         * Boolean Property für automatische Selektierung; default Wert - false
+         */
+        this.autoapplyselection = false;
+        /**
+         * Array von Daten
+         */
+        this.dates = [];
+        /**
+         * Datum Selector
+         */
+        this.dateselection = false;
+        /**
+         * Monat
+         */
+        this.month = 4;
+        /**
+         * Output Event beim Datum Selektieren
+         */
+        this.selectdate = new EventEmitter();
+        /**
+         * Time Selector
+         */
+        this.timeselection = false;
+        /**
+         * Jahr
+         */
+        this.year = 2018;
+        this.iconService = injector.get(SACICON_SERVICE, new SacDefaultIconService());
+    }
+    // #endregion Constructors
+    // #region Public Getters And Setters
+    /**
+     * Get icon to switch to next month
+     */
+    get iconMonthNext() {
+        return this.iconService.DateTimeSelectorComponentMonthNextIcon;
+    }
+    /**
+     * Get icon to switch to previous month
+     */
+    get iconMonthPrev() {
+        return this.iconService.DateTimeSelectorComponentMonthPrevIcon;
+    }
+    /**
+     * Input für ursprüngliches Datum
+     */
+    get initialvalue() {
+        return this._initialValue.toDate();
+    }
+    set initialvalue(v) {
+        if (v === null || v === undefined) {
+            this._initialValue = null;
+        }
+        else {
+            this._initialValue = moment(v);
+        }
+        this._selectedValue = null;
+        if (this._initialValue === null) {
+            this.initCalendar(moment());
+        }
+        else {
+            this.initCalendar(this._initialValue);
+        }
+    }
+    // #endregion Public Getters And Setters
+    // #region Public Methods
+    /**
+     * Selektierung übernehmen
+     */
+    applySelection() {
+        if (this.timeselection === false && this._selectedValue !== null) {
+            this._selectedValue.hour(0);
+            this._selectedValue.minute(0);
+            this._selectedValue.second(0);
+            this._selectedValue.millisecond(0);
+        }
+        if (this.dateselection === false && this._selectedValue !== null) {
+            const tempValue = this._selectedValue.local();
+            tempValue.date(1);
+            tempValue.month(0);
+            tempValue.year(1900);
+            this._selectedValue = tempValue.utc();
+        }
+        this.selectdate.emit({
+            date: this._selectedValue,
+        });
+    }
+    /**
+     * Modus ändern
+     */
+    changeMode() {
+        if (this.beginOfCalendar === 0) {
+            this.beginOfCalendar = 1;
+        }
+        else {
+            this.beginOfCalendar = 0;
+        }
+        this.initDates();
+    }
+    /**
+     * Getter für Stunden Uhrzeit
+     */
+    getHours() {
+        if (this._selectedValue === null) {
+            /**
+             * Wert aus Init Value lesen
+             */
+            if (this._initialValue === null) {
+                return 0;
+            }
+            else {
+                return this._initialValue.hour();
+            }
+        }
+        else {
+            return this._selectedValue.hour();
+        }
+    }
+    /**
+     * Getter für Minuten Uhrzeit
+     */
+    getMinutes() {
+        if (this._selectedValue === null) {
+            /**
+             * Wert aus Init Value lesen
+             */
+            if (this._initialValue === null) {
+                return 0;
+            }
+            else {
+                return this._initialValue.minutes();
+            }
+        }
+        else {
+            return this._selectedValue.minutes();
+        }
+    }
+    /**
+     * Vorheriger Monat
+     */
+    monthBack() {
+        this.month = this.month - 1;
+        if (this.month < 0) {
+            this.month = 11;
+            this.year = this.year - 1;
+        }
+        this.initDates();
+    }
+    /**
+     * Nächster Monat
+     */
+    monthNext() {
+        this.month = this.month + 1;
+        if (this.month > 11) {
+            this.month = 0;
+            this.year = this.year + 1;
+        }
+        this.initDates();
+    }
+    /**
+     * Init Event
+     */
+    ngOnInit() {
+        /**
+         * Init Initial Date if Empty
+         */
+        if (this._initialValue === undefined) {
+            this.initialvalue = null;
+        }
+        this.initDates();
+    }
+    /**
+     * Selektierung resetten
+     */
+    resetSelection() {
+        this.selectdate.emit({
+            date: null,
+        });
+    }
+    /**
+     * Methode ergibt das selektierte Datum
+     */
+    selectDate(v) {
+        if (v.isenabled) {
+            this.dates.forEach((date) => date
+                .filter((filter) => filter.isnew)
+                .forEach((itm) => (itm.isnew = false)));
+            this.dates.forEach((date) => date
+                .filter((filter) => filter.isselected)
+                .forEach((itm) => (itm.isselected = false)));
+            v.isnew = true;
+            v.isselected = true;
+            const dateValue = moment(v.date);
+            // Übernehmen der Zeit aus dem bestehenden Wert
+            if (this._selectedValue === null) {
+                if (this._initialValue !== null) {
+                    dateValue.hour(this._initialValue.hour());
+                    dateValue.minute(this._initialValue.minute());
+                }
+            }
+            else {
+                dateValue.hour(this._selectedValue.hour());
+                dateValue.minute(this._selectedValue.minute());
+            }
+            // Sekunden un Milisekunden Clean
+            dateValue.second(0);
+            dateValue.millisecond(0);
+            this._selectedValue = dateValue;
+            if (this.autoapplyselection) {
+                this.applySelection();
+            }
+        }
+    }
+    /**
+     * Setter für Stunden Uhrzeit
+     */
+    setHours(v) {
+        /**
+         * Select Value setzen falls leer
+         */
+        this.initSelectedValue();
+        if (v === null) {
+            this._selectedValue.hour(0);
+        }
+        else {
+            this._selectedValue.hour(v);
+        }
+    }
+    /**
+     * Setter für Minuten Uhrzeit
+     */
+    setMinutes(v) {
+        /**
+         * Select Value setzen falls leer
+         */
+        this.initSelectedValue();
+        if (v === null) {
+            this._selectedValue.minutes(0);
+        }
+        else {
+            this._selectedValue.minutes(v);
+        }
+    }
+    /**
+     * Auswahl auf aktuelle Zeit stellen
+     */
+    setToday() {
+        this._selectedValue = moment();
+        /**
+         * Sekunden un Milisekunden Clean
+         */
+        this._selectedValue.second(0);
+        this._selectedValue.millisecond(0);
+        /**
+         * Kalender Daten initialisieren falls Kalender angezeigt
+         */
+        if (this.dateselection) {
+            this.initCalendar(this._selectedValue);
+        }
+        if (this.autoapplyselection) {
+            this.applySelection();
+        }
+    }
+    // #endregion Public Methods
+    // #region Private Methods
+    /**
+     * Ursprünglicher Kalender
+     */
+    initCalendar(v) {
+        /**
+         * Monat und Jahr setzen
+         */
+        this.month = v.month();
+        this.year = v.year();
+        /**
+         * Daten für Kalender initialiseren
+         */
+        this.initDates();
+    }
+    /**
+     * Initial Datum
+     */
+    initDates() {
+        const currentMonth = moment(new Date(this.year, this.month, 1));
+        const lastMonth = moment(new Date(this.year, this.month, 1));
+        lastMonth.add({ months: -1 });
+        const nextMonths = moment(new Date(this.year, this.month, 1));
+        nextMonths.add({ months: 1 });
+        const weekdayBegin = currentMonth.weekday();
+        const weekdayEnd = moment(new Date(currentMonth.year(), currentMonth.month(), currentMonth.daysInMonth())).weekday();
+        // Clear Array
+        const daysInCalendar = [];
+        this.dates = [];
+        if (weekdayBegin !== this.beginOfCalendar) {
+            const lastMonthDay = lastMonth.daysInMonth();
+            const lastMonthDate = new Date(lastMonth.year(), lastMonth.month(), lastMonthDay);
+            const lastMonthWeekday = moment(lastMonthDate).weekday();
+            let daysInLastMonth = 7 - ((7 + this.beginOfCalendar - lastMonthWeekday) % 7);
+            if (daysInLastMonth === 7) {
+                daysInLastMonth = 0;
+            }
+            for (let day = lastMonthDay; day >= lastMonthDay - daysInLastMonth; day--) {
+                daysInCalendar.splice(0, 0, new DateSelectorItem(day.toString(), new Date(lastMonth.year(), lastMonth.month(), day), false, false, false, false));
+            }
+        }
+        // Add all Days in Month
+        for (let dayinmonth = 1; dayinmonth <= currentMonth.daysInMonth(); dayinmonth++) {
+            let isSelectedDate = false;
+            let isNewDate = false;
+            const isCurrentDate = moment().month() === this.month &&
+                moment().year() === this.year &&
+                moment().date() === dayinmonth;
+            // Initial Wert setzen, falls vorhanden
+            if (this._initialValue !== null) {
+                isSelectedDate =
+                    this._initialValue.month() === this.month &&
+                        this._initialValue.year() === this.year &&
+                        this._initialValue.date() === dayinmonth;
+            }
+            // Selected Date Wert setzen, falls Wert gesetzt
+            if (this._selectedValue !== null) {
+                isNewDate =
+                    this._selectedValue.month() === this.month &&
+                        this._selectedValue.year() === this.year &&
+                        this._selectedValue.date() === dayinmonth;
+            }
+            daysInCalendar.push(new DateSelectorItem(dayinmonth.toString(), moment([this.year, this.month, dayinmonth]).toDate(), true, isSelectedDate, isCurrentDate, isNewDate));
+        }
+        let endOfCalender;
+        if (this.beginOfCalendar === 0) {
+            endOfCalender = 6;
+        }
+        else {
+            endOfCalender = 0;
+        }
+        if (weekdayEnd !== endOfCalender) {
+            let countMissingDays;
+            if (this.beginOfCalendar === 0) {
+                countMissingDays = endOfCalender - weekdayEnd;
+            }
+            else {
+                countMissingDays = 7 - weekdayEnd;
+            }
+            for (let i = 1; i <= countMissingDays; i++) {
+                daysInCalendar.push(new DateSelectorItem(i.toString(), new Date(nextMonths.year(), nextMonths.month(), i), false, false, false, false));
+            }
+        }
+        for (let index = 0; index < daysInCalendar.length / 7; index++) {
+            for (let day = 0; day < 7; day++) {
+                if (day === 0) {
+                    this.dates[index] = [];
+                }
+                this.dates[index].push(daysInCalendar[index * 7 + day]);
+            }
+        }
+    }
+    initSelectedValue() {
+        /**
+         * Select Value setzen falls leer
+         */
+        if (this._selectedValue === null) {
+            if (this._initialValue === null) {
+                this._selectedValue = moment();
+            }
+            else {
+                this._selectedValue = this._initialValue;
+            }
+        }
+    }
+}
+SacDateSelectorCommon.decorators = [
+    { type: Directive }
+];
+SacDateSelectorCommon.ctorParameters = () => [
+    { type: Injector }
+];
+SacDateSelectorCommon.propDecorators = {
+    autoapplyselection: [{ type: Input }],
+    dateselection: [{ type: Input }],
+    month: [{ type: Input }],
+    selectdate: [{ type: Output }],
+    timeselection: [{ type: Input }],
+    year: [{ type: Input }],
+    initialvalue: [{ type: Input }]
+};
+// #endregion Classes
+// #region Variables
+/**
+ * Moment
+ */
+const moment = moment_['default'];
+// #endregion Variables
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dateselector.js","sourceRoot":"C:/Projekte/simpleangularcontrols-ng10/ch.jnetwork.sac-controls/projects/sac-common/src/","sources":["controls/datetime/dateselector.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  Directive,\r\n  Injector,\r\n} from '@angular/core';\r\nimport * as moment_ from 'moment';\r\n// Import Moment.JS\r\nimport { Moment } from 'moment';\r\nimport { SACICON_SERVICE, SacDefaultIconService } from '../../services';\r\nimport { ISacIconService } from '../../interfaces/ISacIconService';\r\n\r\n// #region Classes\r\n\r\n/**\r\n *Basis Komponente für DateSelectorItem\r\n */\r\nclass DateSelectorItem {\r\n  // #region Properties\r\n\r\n  /**\r\n   * Datum\r\n   */\r\n  public date: Date = undefined;\r\n  /**\r\n   * DisplayText Property; default Wert - ''\r\n   */\r\n  public displaytext: string = '';\r\n  /**\r\n   * Boolean Property, die zeigt, ob das Element aktuell ist; default Wert - false\r\n   */\r\n  public iscurrent: boolean = false;\r\n  /**\r\n   * Boolean Property, die zeigt, ob das Control enabled ist; default Wert - false\r\n   */\r\n  public isenabled: boolean = false;\r\n  /**\r\n   * Boolean Property, die zeigt, ob das Element neu ist; default Wert - false\r\n   */\r\n  public isnew: boolean = false;\r\n  /**\r\n   * Boolean Property, die zeigt, ob das Element selektiert ist; default Wert - false\r\n   */\r\n  public isselected: boolean = false;\r\n\r\n  // #endregion Properties\r\n\r\n  // #region Constructors\r\n\r\n  /**\r\n   * Konstruktor\r\n   * @param displaytext Anzeigetext\r\n   * @param date Datum\r\n   * @param isenabled Element ist aktiv\r\n   * @param isselected Element ist selektiert\r\n   * @param iscurrent Element ist aktuelles Element\r\n   * @param isnew Element ist neu\r\n   */\r\n  constructor(\r\n    displaytext: string,\r\n    date: Date,\r\n    isenabled: boolean,\r\n    isselected: boolean,\r\n    iscurrent: boolean,\r\n    isnew: boolean\r\n  ) {\r\n    this.displaytext = displaytext;\r\n    this.date = date;\r\n    this.isenabled = isenabled;\r\n    this.iscurrent = iscurrent;\r\n    this.isselected = isselected;\r\n    this.isnew = isnew;\r\n  }\r\n\r\n  // #endregion Constructors\r\n}\r\n\r\n/**\r\n *Basis Komponente für SacDateSelector\r\n */\r\n@Directive()\r\nexport class SacDateSelectorCommon implements OnInit {\r\n  // #region Properties\r\n\r\n  /**\r\n   * Ursprüngliches Datum\r\n   */\r\n  private _initialValue: Moment | null;\r\n  /**\r\n   * Aktuell gewähltes Datum\r\n   */\r\n  private _selectedValue: Moment | null;\r\n  /**\r\n   * Anfang des Kalenders\r\n   */\r\n  private beginOfCalendar: number = 1;\r\n  /**\r\n   * icon service to resolve icons\r\n   */\r\n  private iconService: ISacIconService;\r\n\r\n  /**\r\n   * Boolean Property für automatische Selektierung; default Wert - false\r\n   */\r\n  @Input()\r\n  public autoapplyselection = false;\r\n  /**\r\n   * Array von Daten\r\n   */\r\n  public dates: DateSelectorItem[][] = [];\r\n  /**\r\n   * Datum Selector\r\n   */\r\n  @Input()\r\n  public dateselection: boolean = false;\r\n  /**\r\n   * Monat\r\n   */\r\n  @Input()\r\n  public month: number = 4;\r\n  /**\r\n   * Output Event beim Datum Selektieren\r\n   */\r\n  @Output()\r\n  public selectdate = new EventEmitter<any>();\r\n  /**\r\n   * Time Selector\r\n   */\r\n  @Input()\r\n  public timeselection: boolean = false;\r\n  /**\r\n   * Jahr\r\n   */\r\n  @Input()\r\n  public year: number = 2018;\r\n\r\n  // #endregion Properties\r\n\r\n  // #region Constructors\r\n\r\n  constructor(injector: Injector) {\r\n    this.iconService = injector.get(\r\n      SACICON_SERVICE,\r\n      new SacDefaultIconService()\r\n    );\r\n  }\r\n\r\n  // #endregion Constructors\r\n\r\n  // #region Public Getters And Setters\r\n\r\n  /**\r\n   * Get icon to switch to next month\r\n   */\r\n  public get iconMonthNext(): string {\r\n    return this.iconService.DateTimeSelectorComponentMonthNextIcon;\r\n  }\r\n\r\n  /**\r\n   * Get icon to switch to previous month\r\n   */\r\n  public get iconMonthPrev(): string {\r\n    return this.iconService.DateTimeSelectorComponentMonthPrevIcon;\r\n  }\r\n\r\n  /**\r\n   * Input für ursprüngliches Datum\r\n   */\r\n  @Input()\r\n  public get initialvalue(): Date {\r\n    return this._initialValue.toDate();\r\n  }\r\n\r\n  public set initialvalue(v: Date | null) {\r\n    if (v === null || v === undefined) {\r\n      this._initialValue = null;\r\n    } else {\r\n      this._initialValue = moment(v);\r\n    }\r\n\r\n    this._selectedValue = null;\r\n\r\n    if (this._initialValue === null) {\r\n      this.initCalendar(moment());\r\n    } else {\r\n      this.initCalendar(this._initialValue);\r\n    }\r\n  }\r\n\r\n  // #endregion Public Getters And Setters\r\n\r\n  // #region Public Methods\r\n\r\n  /**\r\n   * Selektierung übernehmen\r\n   */\r\n  public applySelection(): void {\r\n    if (this.timeselection === false && this._selectedValue !== null) {\r\n      this._selectedValue.hour(0);\r\n      this._selectedValue.minute(0);\r\n      this._selectedValue.second(0);\r\n      this._selectedValue.millisecond(0);\r\n    }\r\n\r\n    if (this.dateselection === false && this._selectedValue !== null) {\r\n      const tempValue: Moment = this._selectedValue.local();\r\n      tempValue.date(1);\r\n      tempValue.month(0);\r\n      tempValue.year(1900);\r\n      this._selectedValue = tempValue.utc();\r\n    }\r\n\r\n    this.selectdate.emit({\r\n      date: this._selectedValue,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Modus ändern\r\n   */\r\n  public changeMode(): void {\r\n    if (this.beginOfCalendar === 0) {\r\n      this.beginOfCalendar = 1;\r\n    } else {\r\n      this.beginOfCalendar = 0;\r\n    }\r\n\r\n    this.initDates();\r\n  }\r\n\r\n  /**\r\n   * Getter für Stunden Uhrzeit\r\n   */\r\n  public getHours(): number {\r\n    if (this._selectedValue === null) {\r\n      /**\r\n       * Wert aus Init Value lesen\r\n       */\r\n      if (this._initialValue === null) {\r\n        return 0;\r\n      } else {\r\n        return this._initialValue.hour();\r\n      }\r\n    } else {\r\n      return this._selectedValue.hour();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Getter für Minuten Uhrzeit\r\n   */\r\n  public getMinutes(): number {\r\n    if (this._selectedValue === null) {\r\n      /**\r\n       * Wert aus Init Value lesen\r\n       */\r\n      if (this._initialValue === null) {\r\n        return 0;\r\n      } else {\r\n        return this._initialValue.minutes();\r\n      }\r\n    } else {\r\n      return this._selectedValue.minutes();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Vorheriger Monat\r\n   */\r\n  public monthBack(): void {\r\n    this.month = this.month - 1;\r\n\r\n    if (this.month < 0) {\r\n      this.month = 11;\r\n      this.year = this.year - 1;\r\n    }\r\n\r\n    this.initDates();\r\n  }\r\n\r\n  /**\r\n   * Nächster Monat\r\n   */\r\n  public monthNext(): void {\r\n    this.month = this.month + 1;\r\n\r\n    if (this.month > 11) {\r\n      this.month = 0;\r\n      this.year = this.year + 1;\r\n    }\r\n\r\n    this.initDates();\r\n  }\r\n\r\n  /**\r\n   * Init Event\r\n   */\r\n  public ngOnInit() {\r\n    /**\r\n     * Init Initial Date if Empty\r\n     */\r\n    if (this._initialValue === undefined) {\r\n      this.initialvalue = null;\r\n    }\r\n\r\n    this.initDates();\r\n  }\r\n\r\n  /**\r\n   * Selektierung resetten\r\n   */\r\n  public resetSelection(): void {\r\n    this.selectdate.emit({\r\n      date: null,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Methode ergibt das selektierte Datum\r\n   */\r\n  public selectDate(v: DateSelectorItem): void {\r\n    if (v.isenabled) {\r\n      this.dates.forEach((date) =>\r\n        date\r\n          .filter((filter) => filter.isnew)\r\n          .forEach((itm) => (itm.isnew = false))\r\n      );\r\n      this.dates.forEach((date) =>\r\n        date\r\n          .filter((filter) => filter.isselected)\r\n          .forEach((itm) => (itm.isselected = false))\r\n      );\r\n      v.isnew = true;\r\n      v.isselected = true;\r\n\r\n      const dateValue: Moment = moment(v.date);\r\n\r\n      // Übernehmen der Zeit aus dem bestehenden Wert\r\n      if (this._selectedValue === null) {\r\n        if (this._initialValue !== null) {\r\n          dateValue.hour(this._initialValue.hour());\r\n          dateValue.minute(this._initialValue.minute());\r\n        }\r\n      } else {\r\n        dateValue.hour(this._selectedValue.hour());\r\n        dateValue.minute(this._selectedValue.minute());\r\n      }\r\n\r\n      // Sekunden un Milisekunden Clean\r\n      dateValue.second(0);\r\n      dateValue.millisecond(0);\r\n      this._selectedValue = dateValue;\r\n\r\n      if (this.autoapplyselection) {\r\n        this.applySelection();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setter für Stunden Uhrzeit\r\n   */\r\n  public setHours(v: number | null): void {\r\n    /**\r\n     * Select Value setzen falls leer\r\n     */\r\n    this.initSelectedValue();\r\n\r\n    if (v === null) {\r\n      this._selectedValue.hour(0);\r\n    } else {\r\n      this._selectedValue.hour(v);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setter für Minuten Uhrzeit\r\n   */\r\n  public setMinutes(v: number | null): void {\r\n    /**\r\n     * Select Value setzen falls leer\r\n     */\r\n    this.initSelectedValue();\r\n\r\n    if (v === null) {\r\n      this._selectedValue.minutes(0);\r\n    } else {\r\n      this._selectedValue.minutes(v);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Auswahl auf aktuelle Zeit stellen\r\n   */\r\n  public setToday(): void {\r\n    this._selectedValue = moment();\r\n\r\n    /**\r\n     * Sekunden un Milisekunden Clean\r\n     */\r\n    this._selectedValue.second(0);\r\n    this._selectedValue.millisecond(0);\r\n\r\n    /**\r\n     * Kalender Daten initialisieren falls Kalender angezeigt\r\n     */\r\n    if (this.dateselection) {\r\n      this.initCalendar(this._selectedValue);\r\n    }\r\n\r\n    if (this.autoapplyselection) {\r\n      this.applySelection();\r\n    }\r\n  }\r\n\r\n  // #endregion Public Methods\r\n\r\n  // #region Private Methods\r\n\r\n  /**\r\n   * Ursprünglicher Kalender\r\n   */\r\n  private initCalendar(v: Moment) {\r\n    /**\r\n     * Monat und Jahr setzen\r\n     */\r\n    this.month = v.month();\r\n    this.year = v.year();\r\n\r\n    /**\r\n     * Daten für Kalender initialiseren\r\n     */\r\n    this.initDates();\r\n  }\r\n\r\n  /**\r\n   * Initial Datum\r\n   */\r\n  private initDates(): void {\r\n    const currentMonth = moment(new Date(this.year, this.month, 1));\r\n    const lastMonth = moment(new Date(this.year, this.month, 1));\r\n    lastMonth.add({ months: -1 });\r\n    const nextMonths = moment(new Date(this.year, this.month, 1));\r\n    nextMonths.add({ months: 1 });\r\n\r\n    const weekdayBegin: number = currentMonth.weekday();\r\n    const weekdayEnd: number = moment(\r\n      new Date(\r\n        currentMonth.year(),\r\n        currentMonth.month(),\r\n        currentMonth.daysInMonth()\r\n      )\r\n    ).weekday();\r\n    // Clear Array\r\n    const daysInCalendar: DateSelectorItem[] = [];\r\n    this.dates = [];\r\n\r\n    if (weekdayBegin !== this.beginOfCalendar) {\r\n      const lastMonthDay = lastMonth.daysInMonth();\r\n      const lastMonthDate = new Date(\r\n        lastMonth.year(),\r\n        lastMonth.month(),\r\n        lastMonthDay\r\n      );\r\n      const lastMonthWeekday = moment(lastMonthDate).weekday();\r\n\r\n      let daysInLastMonth =\r\n        7 - ((7 + this.beginOfCalendar - lastMonthWeekday) % 7);\r\n      if (daysInLastMonth === 7) {\r\n        daysInLastMonth = 0;\r\n      }\r\n\r\n      for (\r\n        let day = lastMonthDay;\r\n        day >= lastMonthDay - daysInLastMonth;\r\n        day--\r\n      ) {\r\n        daysInCalendar.splice(\r\n          0,\r\n          0,\r\n          new DateSelectorItem(\r\n            day.toString(),\r\n            new Date(lastMonth.year(), lastMonth.month(), day),\r\n            false,\r\n            false,\r\n            false,\r\n            false\r\n          )\r\n        );\r\n      }\r\n    }\r\n\r\n    // Add all Days in Month\r\n    for (\r\n      let dayinmonth = 1;\r\n      dayinmonth <= currentMonth.daysInMonth();\r\n      dayinmonth++\r\n    ) {\r\n      let isSelectedDate: boolean = false;\r\n      let isNewDate: boolean = false;\r\n      const isCurrentDate: boolean =\r\n        moment().month() === this.month &&\r\n        moment().year() === this.year &&\r\n        moment().date() === dayinmonth;\r\n\r\n      // Initial Wert setzen, falls vorhanden\r\n      if (this._initialValue !== null) {\r\n        isSelectedDate =\r\n          this._initialValue.month() === this.month &&\r\n          this._initialValue.year() === this.year &&\r\n          this._initialValue.date() === dayinmonth;\r\n      }\r\n\r\n      // Selected Date Wert setzen, falls Wert gesetzt\r\n      if (this._selectedValue !== null) {\r\n        isNewDate =\r\n          this._selectedValue.month() === this.month &&\r\n          this._selectedValue.year() === this.year &&\r\n          this._selectedValue.date() === dayinmonth;\r\n      }\r\n\r\n      daysInCalendar.push(\r\n        new DateSelectorItem(\r\n          dayinmonth.toString(),\r\n          moment([this.year, this.month, dayinmonth]).toDate(),\r\n          true,\r\n          isSelectedDate,\r\n          isCurrentDate,\r\n          isNewDate\r\n        )\r\n      );\r\n    }\r\n\r\n    let endOfCalender: number;\r\n    if (this.beginOfCalendar === 0) {\r\n      endOfCalender = 6;\r\n    } else {\r\n      endOfCalender = 0;\r\n    }\r\n\r\n    if (weekdayEnd !== endOfCalender) {\r\n      let countMissingDays: number;\r\n\r\n      if (this.beginOfCalendar === 0) {\r\n        countMissingDays = endOfCalender - weekdayEnd;\r\n      } else {\r\n        countMissingDays = 7 - weekdayEnd;\r\n      }\r\n\r\n      for (let i = 1; i <= countMissingDays; i++) {\r\n        daysInCalendar.push(\r\n          new DateSelectorItem(\r\n            i.toString(),\r\n            new Date(nextMonths.year(), nextMonths.month(), i),\r\n            false,\r\n            false,\r\n            false,\r\n            false\r\n          )\r\n        );\r\n      }\r\n    }\r\n\r\n    for (let index = 0; index < daysInCalendar.length / 7; index++) {\r\n      for (let day = 0; day < 7; day++) {\r\n        if (day === 0) {\r\n          this.dates[index] = [];\r\n        }\r\n\r\n        this.dates[index].push(daysInCalendar[index * 7 + day]);\r\n      }\r\n    }\r\n  }\r\n\r\n  private initSelectedValue() {\r\n    /**\r\n     * Select Value setzen falls leer\r\n     */\r\n    if (this._selectedValue === null) {\r\n      if (this._initialValue === null) {\r\n        this._selectedValue = moment();\r\n      } else {\r\n        this._selectedValue = this._initialValue;\r\n      }\r\n    }\r\n  }\r\n\r\n  // #endregion Private Methods\r\n}\r\n\r\n// #endregion Classes\r\n\r\n// #region Variables\r\n\r\n/**\r\n * Moment\r\n */\r\nconst moment = moment_['default'];\r\n\r\n// #endregion Variables\r\n"]}

package/esm2015/controls/datetime/dateselector.ngfactory.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview This file was generated by the Angular template compiler. Do not edit.
+ *
+ * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride,checkTypes,extraRequire}
+ * tslint:disable
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXNlbGVjdG9yLm5nZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiJDOi9Qcm9qZWt0ZS9zaW1wbGVhbmd1bGFyY29udHJvbHMtbmcxMC9jaC5qbmV0d29yay5zYWMtY29udHJvbHMvcHJvamVjdHMvc2FjLWNvbW1vbi9zcmMvIiwic291cmNlcyI6WyJjb250cm9scy9kYXRldGltZS9kYXRlc2VsZWN0b3IubmdmYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBpMCBmcm9tICdAYW5ndWxhci9jb3JlJztcbmkwLkNvbXBvbmVudEZhY3Rvcnk7XG4iXX0=