@tetacom/ng-components 1.0.24 → 1.0.25

package/dist/esm2020/component/date-picker/time-part-control/time-part-control.component.mjs

@@ -0,0 +1,73 @@
+import { ChangeDetectionStrategy, Component, forwardRef, Input, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../button/button/button.component";
+import * as i2 from "../../icon/icon/icon.component";
+import * as i3 from "../../../pipe/prepend-zero/prepend-zero.pipe";
+export const TIME_PART_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => TimePartControlComponent),
+    multi: true,
+};
+export class TimePartControlComponent {
+    constructor(_cdr) {
+        this._cdr = _cdr;
+        this.min = 0;
+        this.max = 59;
+        this.scroll = (e) => {
+            const delta = e?.deltaY ?? e;
+            if (e instanceof WheelEvent) {
+                e.preventDefault();
+            }
+            if (delta > 0) {
+                this.down();
+            }
+            else {
+                this.up();
+            }
+        };
+    }
+    set value(value) {
+        this._value = value;
+        this.onChange(this._value);
+    }
+    get value() {
+        return this._value;
+    }
+    up() {
+        this.value = this.value < this.max ? this.value + 1 : this.min;
+    }
+    down() {
+        this.value = this.value > this.min ? this.value - 1 : this.max;
+    }
+    ngOnInit() { }
+    writeValue(model) {
+        this._value = model;
+        this._cdr.markForCheck();
+    }
+    onChange(_) { }
+    onTouched() { }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this._cdr.markForCheck();
+    }
+}
+TimePartControlComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: TimePartControlComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TimePartControlComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: TimePartControlComponent, selector: "teta-time-part-control", inputs: { min: "min", max: "max", disabled: "disabled" }, providers: [TIME_PART_CONTROL_VALUE_ACCESSOR], ngImport: i0, template: "<button teta-button [square]=\"true\" (click)=\"up()\" [palette]=\"'text'\" [view]=\"'ghost'\">\n  <teta-icon [name]=\"'arrowUpKey'\"></teta-icon>\n</button>\n<div (wheel)=\"scroll($event);\" class=\"row row_auto font-body-3 height-6 width-6 align-center justify-content-center\">\n  {{value | tetaPrependZero: 2}}\n</div>\n<button teta-button [square]=\"true\" (click)=\"down()\" [palette]=\"'text'\" [view]=\"'ghost'\">\n  <teta-icon [name]=\"'arrowDownKey'\"></teta-icon>\n</button>\n", styles: [":host{display:flex;flex-direction:column}\n"], components: [{ type: i1.ButtonComponent, selector: "button[teta-button], teta-button", inputs: ["palette", "class", "view", "square"] }, { type: i2.IconComponent, selector: "teta-icon", inputs: ["name", "size", "palette", "class"] }], pipes: { "tetaPrependZero": i3.PrependZeroPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: TimePartControlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-time-part-control', providers: [TIME_PART_CONTROL_VALUE_ACCESSOR], changeDetection: ChangeDetectionStrategy.OnPush, template: "<button teta-button [square]=\"true\" (click)=\"up()\" [palette]=\"'text'\" [view]=\"'ghost'\">\n  <teta-icon [name]=\"'arrowUpKey'\"></teta-icon>\n</button>\n<div (wheel)=\"scroll($event);\" class=\"row row_auto font-body-3 height-6 width-6 align-center justify-content-center\">\n  {{value | tetaPrependZero: 2}}\n</div>\n<button teta-button [square]=\"true\" (click)=\"down()\" [palette]=\"'text'\" [view]=\"'ghost'\">\n  <teta-icon [name]=\"'arrowDownKey'\"></teta-icon>\n</button>\n", styles: [":host{display:flex;flex-direction:column}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/component/date-picker/util/date-picker-util.mjs

@@ -0,0 +1,142 @@
+import { DayModel } from '../model/day-model';
+export class DatePickerUtil {
+    static getFirstDay(month, year, firstDayOfWeek) {
+        const lastDay = new Date(year, month, 0);
+        const lastDayIndex = lastDay.getDay() >= firstDayOfWeek
+            ? lastDay.getDay() - firstDayOfWeek
+            : lastDay.getDay() + 7 - firstDayOfWeek;
+        return new Date(year, month - 1, lastDay.getDate() - lastDayIndex);
+    }
+    static getPickerDays(date, firstDayOfWeek, minDate, maxDate, disabledDates, disabledDays, disabledPeriods) {
+        const days = [];
+        const firstDay = DatePickerUtil.getFirstDay(date.getMonth(), date.getFullYear(), firstDayOfWeek);
+        for (let i = 0; i < 6 * 7; i++) {
+            const dat = new Date(firstDay);
+            dat.setDate(dat.getDate() + i);
+            days.push(new DayModel({
+                date: dat,
+                disabled: DatePickerUtil.isDateInvalid(dat, minDate, maxDate, disabledDates, disabledDays, disabledPeriods),
+                today: DatePickerUtil.isToday(dat),
+                isCurrentMonth: dat.getMonth() === date.getMonth(),
+                selected: dat.getFullYear() === date.getFullYear() &&
+                    dat.getMonth() === date.getMonth() &&
+                    dat.getDate() === date.getDate(),
+                weekend: dat.getDay() === 0 || dat.getDay() === 6,
+            }));
+        }
+        return days;
+    }
+    static isDateInvalid(dat, minDate, maxDate, disabledDates, disabledDays, disabledPeriods) {
+        return (DatePickerUtil.isDayDisabled(dat, disabledDays) ||
+            DatePickerUtil.isDateDisabled(dat, disabledDates) ||
+            DatePickerUtil.isDateInDisabledPeriod(dat, disabledPeriods) ||
+            DatePickerUtil.isMaxInvalid(dat, maxDate) ||
+            DatePickerUtil.isMinInvalid(dat, minDate));
+    }
+    static isDayDisabled(dat, disabledDays) {
+        if (dat === null ||
+            dat === undefined ||
+            disabledDays === null ||
+            disabledDays === undefined ||
+            disabledDays.length < 1) {
+            return false;
+        }
+        return disabledDays.indexOf(dat.getDay()) >= 0;
+    }
+    static isMinInvalid(dat, minDate) {
+        if (dat === null ||
+            dat === undefined ||
+            minDate === null ||
+            minDate === undefined) {
+            return false;
+        }
+        return minDate.getTime() > dat.getTime();
+    }
+    static isMaxInvalid(dat, maxDate) {
+        if (dat === null ||
+            dat === undefined ||
+            maxDate === null ||
+            maxDate === undefined) {
+            return false;
+        }
+        return maxDate.getTime() < dat.getTime();
+    }
+    static isDateInDisabledPeriod(dat, disabledPeriods) {
+        if (dat === null ||
+            dat === undefined ||
+            disabledPeriods === null ||
+            disabledPeriods === undefined ||
+            disabledPeriods.length < 1) {
+            return false;
+        }
+        return disabledPeriods.some((d) => d !== null &&
+            d !== undefined &&
+            d.start !== null &&
+            d.start !== undefined &&
+            d.end !== null &&
+            d.end !== undefined &&
+            d.start.getTime() <= dat.getTime() &&
+            d.end.getTime() >= dat.getTime());
+    }
+    static isDateDisabled(dat, disabledDates) {
+        if (disabledDates === null ||
+            disabledDates === undefined ||
+            disabledDates.length < 1 ||
+            dat === null ||
+            dat === undefined) {
+            return false;
+        }
+        return disabledDates.some((d) => d !== null &&
+            d !== undefined &&
+            d.getFullYear() === dat.getFullYear() &&
+            d.getMonth() === dat.getMonth() &&
+            d.getDate() === dat.getDate());
+    }
+    static isToday(dat) {
+        if (dat === null || dat === undefined) {
+            return false;
+        }
+        const today = new Date();
+        return (dat.getFullYear() === today.getFullYear() &&
+            dat.getMonth() === today.getMonth() &&
+            dat.getDate() === today.getDate());
+    }
+    static scrollMonth(delta, date) {
+        const res = new Date(date);
+        let month = date.getMonth();
+        let year = date.getFullYear();
+        if (delta > 0) {
+            if (month === 11) {
+                month = 0;
+                year++;
+            }
+            else {
+                month++;
+            }
+        }
+        else {
+            if (month === 0) {
+                month = 11;
+                year--;
+            }
+            else {
+                month--;
+            }
+        }
+        res.setFullYear(year, month);
+        return res;
+    }
+    static scrollYear(delta, date) {
+        const res = new Date(date);
+        let year = date.getFullYear();
+        if (delta > 0) {
+            year++;
+        }
+        else {
+            year--;
+        }
+        res.setFullYear(year);
+        return res;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-picker-util.js","sourceRoot":"","sources":["../../../../../src/component/date-picker/util/date-picker-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePeriod } from '../model/date-period';\nimport { DayModel } from '../model/day-model';\n\nexport class DatePickerUtil {\n  static getFirstDay(\n    month: number,\n    year: number,\n    firstDayOfWeek: number\n  ): Date {\n    const lastDay = new Date(year, month, 0);\n    const lastDayIndex =\n      lastDay.getDay() >= firstDayOfWeek\n        ? lastDay.getDay() - firstDayOfWeek\n        : lastDay.getDay() + 7 - firstDayOfWeek;\n    return new Date(year, month - 1, lastDay.getDate() - lastDayIndex);\n  }\n\n  static getPickerDays(\n    date: Date,\n    firstDayOfWeek: number,\n    minDate: Date,\n    maxDate: Date,\n    disabledDates: Date[],\n    disabledDays: number[],\n    disabledPeriods: DatePeriod[]\n  ): DayModel[] {\n    const days = [];\n    const firstDay = DatePickerUtil.getFirstDay(\n      date.getMonth(),\n      date.getFullYear(),\n      firstDayOfWeek\n    );\n    for (let i = 0; i < 6 * 7; i++) {\n      const dat = new Date(firstDay);\n      dat.setDate(dat.getDate() + i);\n      days.push(\n        new DayModel({\n          date: dat,\n          disabled: DatePickerUtil.isDateInvalid(\n            dat,\n            minDate,\n            maxDate,\n            disabledDates,\n            disabledDays,\n            disabledPeriods\n          ),\n          today: DatePickerUtil.isToday(dat),\n          isCurrentMonth: dat.getMonth() === date.getMonth(),\n          selected:\n            dat.getFullYear() === date.getFullYear() &&\n            dat.getMonth() === date.getMonth() &&\n            dat.getDate() === date.getDate(),\n          weekend: dat.getDay() === 0 || dat.getDay() === 6,\n        })\n      );\n    }\n    return days;\n  }\n\n  static isDateInvalid(\n    dat: Date,\n    minDate: Date,\n    maxDate: Date,\n    disabledDates: Date[],\n    disabledDays: number[],\n    disabledPeriods: DatePeriod[]\n  ): boolean {\n    return (\n      DatePickerUtil.isDayDisabled(dat, disabledDays) ||\n      DatePickerUtil.isDateDisabled(dat, disabledDates) ||\n      DatePickerUtil.isDateInDisabledPeriod(dat, disabledPeriods) ||\n      DatePickerUtil.isMaxInvalid(dat, maxDate) ||\n      DatePickerUtil.isMinInvalid(dat, minDate)\n    );\n  }\n\n  static isDayDisabled(dat: Date, disabledDays: number[]): boolean {\n    if (\n      dat === null ||\n      dat === undefined ||\n      disabledDays === null ||\n      disabledDays === undefined ||\n      disabledDays.length < 1\n    ) {\n      return false;\n    }\n    return disabledDays.indexOf(dat.getDay()) >= 0;\n  }\n\n  static isMinInvalid(dat: Date, minDate: Date): boolean {\n    if (\n      dat === null ||\n      dat === undefined ||\n      minDate === null ||\n      minDate === undefined\n    ) {\n      return false;\n    }\n    return minDate.getTime() > dat.getTime();\n  }\n\n  static isMaxInvalid(dat: Date, maxDate: Date): boolean {\n    if (\n      dat === null ||\n      dat === undefined ||\n      maxDate === null ||\n      maxDate === undefined\n    ) {\n      return false;\n    }\n    return maxDate.getTime() < dat.getTime();\n  }\n\n  static isDateInDisabledPeriod(\n    dat: Date,\n    disabledPeriods: DatePeriod[]\n  ): boolean {\n    if (\n      dat === null ||\n      dat === undefined ||\n      disabledPeriods === null ||\n      disabledPeriods === undefined ||\n      disabledPeriods.length < 1\n    ) {\n      return false;\n    }\n    return disabledPeriods.some(\n      (d: DatePeriod) =>\n        d !== null &&\n        d !== undefined &&\n        d.start !== null &&\n        d.start !== undefined &&\n        d.end !== null &&\n        d.end !== undefined &&\n        d.start.getTime() <= dat.getTime() &&\n        d.end.getTime() >= dat.getTime()\n    );\n  }\n\n  static isDateDisabled(dat: Date, disabledDates: Date[]): boolean {\n    if (\n      disabledDates === null ||\n      disabledDates === undefined ||\n      disabledDates.length < 1 ||\n      dat === null ||\n      dat === undefined\n    ) {\n      return false;\n    }\n    return disabledDates.some(\n      (d: Date) =>\n        d !== null &&\n        d !== undefined &&\n        d.getFullYear() === dat.getFullYear() &&\n        d.getMonth() === dat.getMonth() &&\n        d.getDate() === dat.getDate()\n    );\n  }\n\n  static isToday(dat: Date): boolean {\n    if (dat === null || dat === undefined) {\n      return false;\n    }\n    const today = new Date();\n    return (\n      dat.getFullYear() === today.getFullYear() &&\n      dat.getMonth() === today.getMonth() &&\n      dat.getDate() === today.getDate()\n    );\n  }\n\n  static scrollMonth(delta: number, date: Date) {\n    const res = new Date(date);\n    let month = date.getMonth();\n    let year = date.getFullYear();\n    if (delta > 0) {\n      if (month === 11) {\n        month = 0;\n        year++;\n      } else {\n        month++;\n      }\n    } else {\n      if (month === 0) {\n        month = 11;\n        year--;\n      } else {\n        month--;\n      }\n    }\n    res.setFullYear(year, month);\n    return res;\n  }\n\n  static scrollYear(delta: number, date: Date) {\n    const res = new Date(date);\n    let year = date.getFullYear();\n    if (delta > 0) {\n      year++;\n    } else {\n      year--;\n    }\n    res.setFullYear(year);\n    return res;\n  }\n\n  // static isSelected(date: Date, selectedDate: Date): boolean {\n  //   if (date === null || date === undefined || selectedDate === null || selectedDate === undefined) {\n  //     return false;\n  //   }\n  //   return date.getFullYear() === selectedDate.getFullYear()\n  //     && date.getMonth() === selectedDate.getMonth()\n  //     && date.getDate() === selectedDate.getDate();\n  // }\n\n  // static nextMonth(date: Date): Date {\n  //   const dt = new Date(date);\n  //   dt.setMonth(dt.getMonth() + 1);\n  //   return dt;\n  // }\n\n  // static prevMonth(date: Date): Date {\n  //   const dt = new Date(date);\n  //   dt.setMonth(dt.getMonth() - 1);\n  //   return dt;\n  // }\n}\n"]}

package/dist/esm2020/component/date-picker/year-select/year-select.component.mjs

@@ -0,0 +1,189 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { takeWhile, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../service/picker-touch.service";
+import * as i2 from "@angular/common";
+export class YearSelectComponent {
+    constructor(_cdr, _pickerTouchService, _elementRef) {
+        this._cdr = _cdr;
+        this._pickerTouchService = _pickerTouchService;
+        this._elementRef = _elementRef;
+        this.size = 8;
+        this.allowableRange = [1900, 2100];
+        this.yearSelected = new EventEmitter();
+        this.yearApplied = new EventEmitter();
+        this._alive = true;
+        this.scrollYearSelector = (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            const step = e.deltaY > 0 ? 1 : -1;
+            this.shiftYearSelector(step);
+        };
+        this.setYear = (e, year) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (!this.isYearDisabled(year)) {
+                this.yearSelected.emit(year);
+            }
+        };
+        this.applyYear = (e, year) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (!this.isYearDisabled(year)) {
+                this.yearApplied.emit(year);
+            }
+        };
+        this.initYearSelector = (year) => {
+            if (!year) {
+                year = this.today.getFullYear();
+            }
+            this.years = [year];
+            let direction = false;
+            for (let i = 1; i < this.size; i++) {
+                if (direction) {
+                    this.years.unshift(this.years[0] - 1);
+                }
+                else {
+                    this.years.push(this.years[this.years.length - 1] + 1);
+                }
+                direction = !direction;
+            }
+            this.checkRanges();
+        };
+        this.initMinYearList = () => {
+            this.minYearList = [this.minYearDate.getFullYear()];
+            for (let i = 1; i < this.size; i++) {
+                this.minYearList.push(this.minYearList[this.minYearList.length - 1] + 1);
+            }
+        };
+        this.initMaxYearList = () => {
+            this.maxYearList = [this.maxYearDate.getFullYear()];
+            for (let i = 1; i < this.size; i++) {
+                this.maxYearList.unshift(this.maxYearList[0] - 1);
+            }
+        };
+        this.checkRanges = () => {
+            if (this.years.some((year) => {
+                const dat = new Date(year, 0, 1);
+                return this.isMinYear(dat);
+            })) {
+                this.years = this.minYearList;
+            }
+            if (this.years.some((year) => {
+                const dat = new Date(year, 0, 1);
+                return this.isMaxYear(dat);
+            })) {
+                this.years = this.maxYearList;
+            }
+        };
+        this.shiftYearSelector = (step = 0) => {
+            this.years = this.years.map((year) => year + step);
+            this.checkRanges();
+        };
+        this.decreaseYearSelector = (step = 3) => {
+            const dat = new Date(this.years[0] - step, 0, 1);
+            if (this.isMinYear(dat)) {
+                this.years = this.minYearList;
+                return;
+            }
+            this.years = this.years.map((year) => year - step);
+        };
+        this.increaseYearSelector = (step = 3) => {
+            const dat = new Date(this.years[this.years.length - 1] + step, 0, 1);
+            if (this.isMaxYear(dat)) {
+                this.years = this.maxYearList;
+                return;
+            }
+            this.years = this.years.map((year) => year + step);
+        };
+        // stopLongDecrease = () => {
+        //   window.clearInterval(this.decreaseInterval);
+        // };
+        //
+        // stopLongIncrease = () => {
+        //   window.clearInterval(this.increaseInterval);
+        // };
+        this.isMinYear = (dat) => {
+            if (!this.minYearDate || !(this.minYearDate instanceof Date) || !dat) {
+                return false;
+            }
+            return this.minYearDate.getFullYear() > dat.getFullYear();
+        };
+        this.isMaxYear = (dat) => {
+            if (!this.maxYearDate || !(this.maxYearDate instanceof Date) || !dat) {
+                return false;
+            }
+            return this.maxYearDate.getFullYear() < dat.getFullYear();
+        };
+        this.isYearDisabled = (year) => {
+            if (year) {
+                const dat = new Date(year, 0, 1);
+                return this.isMaxInvalid(dat) || this.isMinInvalid(dat);
+            }
+            return false;
+        };
+        this.isMinInvalid = (dat) => {
+            if (!this.minDate || !(this.minDate instanceof Date) || !dat) {
+                return false;
+            }
+            return this.minDate.getFullYear() > dat.getFullYear();
+        };
+        this.isMaxInvalid = (dat) => {
+            if (!this.maxDate || !(this.maxDate instanceof Date) || !dat) {
+                return false;
+            }
+            return this.maxDate.getFullYear() < dat.getFullYear();
+        };
+    }
+    ngOnInit() {
+        const [minRange, maxRange] = this.allowableRange;
+        this.minYearDate = new Date(minRange, 0, 1);
+        this.maxYearDate = new Date(maxRange, 11, 31);
+        this.initMinYearList();
+        this.initMaxYearList();
+        this.initYearSelector(this.currentYear);
+    }
+    ngAfterViewInit() {
+        const touchMove$ = fromEvent(this._elementRef.nativeElement.parentElement, 'touchmove');
+        touchMove$
+            .pipe(takeWhile((_) => this._alive), tap((e) => {
+            this._pickerTouchService.onTouchMove(e);
+        }))
+            .subscribe();
+        this._pickerTouchService.step
+            .pipe(takeWhile((_) => this._alive), tap((_) => {
+            this.shiftYearSelector(_);
+            this._cdr.detectChanges();
+        }))
+            .subscribe();
+    }
+    ngOnDestroy() {
+        window.clearInterval(this.decreaseInterval);
+        window.clearInterval(this.increaseInterval);
+        this._alive = false;
+    }
+}
+YearSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: YearSelectComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.PickerTouchService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+YearSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: YearSelectComponent, selector: "teta-year-select", inputs: { currentYear: "currentYear", today: "today", size: "size", minDate: "minDate", maxDate: "maxDate", allowableRange: "allowableRange" }, outputs: { yearSelected: "yearSelected", yearApplied: "yearApplied" }, ngImport: i0, template: "<div class=\"list row_auto margin-top-2\"\n     (wheel)=\"scrollYearSelector($event);\">\n  <div class=\"list-item list-item_interactive\"\n       [class.list-item_active]=\"year === currentYear\"\n       [class.list-item_disabled]=\"isYearDisabled(year)\"\n       (click)=\"setYear($event, year)\"\n       (dblclick)=\"applyYear($event, year)\"\n       *ngFor=\"let year of years\">\n    {{year}}\n  </div>\n</div>\n", styles: [":host{display:flex}\n"], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: YearSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-year-select', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"list row_auto margin-top-2\"\n     (wheel)=\"scrollYearSelector($event);\">\n  <div class=\"list-item list-item_interactive\"\n       [class.list-item_active]=\"year === currentYear\"\n       [class.list-item_disabled]=\"isYearDisabled(year)\"\n       (click)=\"setYear($event, year)\"\n       (dblclick)=\"applyYear($event, year)\"\n       *ngFor=\"let year of years\">\n    {{year}}\n  </div>\n</div>\n", styles: [":host{display:flex}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.PickerTouchService }, { type: i0.ElementRef }]; }, propDecorators: { currentYear: [{
+                type: Input
+            }], today: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], allowableRange: [{
+                type: Input
+            }], yearSelected: [{
+                type: Output
+            }], yearApplied: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"year-select.component.js","sourceRoot":"","sources":["../../../../../src/component/date-picker/year-select/year-select.component.ts","../../../../../src/component/date-picker/year-select/year-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\nimport { fromEvent } from 'rxjs';\nimport { takeWhile, tap } from 'rxjs/operators';\nimport { PickerTouchService } from '../service/picker-touch.service';\n\n@Component({\n  selector: 'teta-year-select',\n  templateUrl: './year-select.component.html',\n  styleUrls: ['./year-select.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class YearSelectComponent implements OnInit, OnDestroy, AfterViewInit {\n  @Input() currentYear: number;\n  @Input() today: Date;\n  @Input() size = 8;\n  @Input() minDate: Date;\n  @Input() maxDate: Date;\n  @Input() allowableRange: number[] = [1900, 2100];\n  @Output() yearSelected = new EventEmitter<number>();\n  @Output() yearApplied = new EventEmitter<number>();\n\n  minYearDate: Date;\n  maxYearDate: Date;\n  years: number[];\n  minYearList: number[];\n  maxYearList: number[];\n  decreaseInterval: number;\n  increaseInterval: number;\n  private _alive = true;\n\n  constructor(\n    private _cdr: ChangeDetectorRef,\n    private _pickerTouchService: PickerTouchService,\n    private _elementRef: ElementRef\n  ) {}\n\n  ngOnInit() {\n    const [minRange, maxRange] = this.allowableRange;\n    this.minYearDate = new Date(minRange, 0, 1);\n    this.maxYearDate = new Date(maxRange, 11, 31);\n    this.initMinYearList();\n    this.initMaxYearList();\n    this.initYearSelector(this.currentYear);\n  }\n\n  ngAfterViewInit() {\n    const touchMove$ = fromEvent(\n      this._elementRef.nativeElement.parentElement,\n      'touchmove'\n    );\n\n    touchMove$\n      .pipe(\n        takeWhile((_) => this._alive),\n        tap((e: TouchEvent) => {\n          this._pickerTouchService.onTouchMove(e);\n        })\n      )\n      .subscribe();\n\n    this._pickerTouchService.step\n      .pipe(\n        takeWhile((_) => this._alive),\n        tap((_) => {\n          this.shiftYearSelector(_);\n          this._cdr.detectChanges();\n        })\n      )\n      .subscribe();\n  }\n\n  ngOnDestroy() {\n    window.clearInterval(this.decreaseInterval);\n    window.clearInterval(this.increaseInterval);\n    this._alive = false;\n  }\n\n  scrollYearSelector = (e: WheelEvent) => {\n    e.preventDefault();\n    e.stopPropagation();\n    const step = e.deltaY > 0 ? 1 : -1;\n    this.shiftYearSelector(step);\n  };\n\n  setYear = (e: any, year: number) => {\n    e.preventDefault();\n    e.stopPropagation();\n    if (!this.isYearDisabled(year)) {\n      this.yearSelected.emit(year);\n    }\n  };\n\n  applyYear = (e: any, year: number) => {\n    e.preventDefault();\n    e.stopPropagation();\n    if (!this.isYearDisabled(year)) {\n      this.yearApplied.emit(year);\n    }\n  };\n\n  initYearSelector = (year: number) => {\n    if (!year) {\n      year = this.today.getFullYear();\n    }\n    this.years = [year];\n    let direction = false;\n    for (let i = 1; i < this.size; i++) {\n      if (direction) {\n        this.years.unshift(this.years[0] - 1);\n      } else {\n        this.years.push(this.years[this.years.length - 1] + 1);\n      }\n      direction = !direction;\n    }\n    this.checkRanges();\n  };\n\n  initMinYearList = () => {\n    this.minYearList = [this.minYearDate.getFullYear()];\n    for (let i = 1; i < this.size; i++) {\n      this.minYearList.push(this.minYearList[this.minYearList.length - 1] + 1);\n    }\n  };\n\n  initMaxYearList = () => {\n    this.maxYearList = [this.maxYearDate.getFullYear()];\n    for (let i = 1; i < this.size; i++) {\n      this.maxYearList.unshift(this.maxYearList[0] - 1);\n    }\n  };\n\n  checkRanges = () => {\n    if (\n      this.years.some((year) => {\n        const dat = new Date(year, 0, 1);\n        return this.isMinYear(dat);\n      })\n    ) {\n      this.years = this.minYearList;\n    }\n    if (\n      this.years.some((year) => {\n        const dat = new Date(year, 0, 1);\n        return this.isMaxYear(dat);\n      })\n    ) {\n      this.years = this.maxYearList;\n    }\n  };\n\n  shiftYearSelector = (step: number = 0) => {\n    this.years = this.years.map((year) => year + step);\n    this.checkRanges();\n  };\n\n  decreaseYearSelector = (step: number = 3) => {\n    const dat = new Date(this.years[0] - step, 0, 1);\n    if (this.isMinYear(dat)) {\n      this.years = this.minYearList;\n      return;\n    }\n\n    this.years = this.years.map((year) => year - step);\n  };\n\n  increaseYearSelector = (step: number = 3) => {\n    const dat = new Date(this.years[this.years.length - 1] + step, 0, 1);\n    if (this.isMaxYear(dat)) {\n      this.years = this.maxYearList;\n      return;\n    }\n    this.years = this.years.map((year) => year + step);\n  };\n\n  // stopLongDecrease = () => {\n  //   window.clearInterval(this.decreaseInterval);\n  // };\n  //\n  // stopLongIncrease = () => {\n  //   window.clearInterval(this.increaseInterval);\n  // };\n\n  isMinYear = (dat: Date): boolean => {\n    if (!this.minYearDate || !(this.minYearDate instanceof Date) || !dat) {\n      return false;\n    }\n    return this.minYearDate.getFullYear() > dat.getFullYear();\n  };\n\n  isMaxYear = (dat: Date): boolean => {\n    if (!this.maxYearDate || !(this.maxYearDate instanceof Date) || !dat) {\n      return false;\n    }\n    return this.maxYearDate.getFullYear() < dat.getFullYear();\n  };\n\n  isYearDisabled = (year: number) => {\n    if (year) {\n      const dat = new Date(year, 0, 1);\n      return this.isMaxInvalid(dat) || this.isMinInvalid(dat);\n    }\n    return false;\n  };\n\n  isMinInvalid = (dat: Date): boolean => {\n    if (!this.minDate || !(this.minDate instanceof Date) || !dat) {\n      return false;\n    }\n    return this.minDate.getFullYear() > dat.getFullYear();\n  };\n\n  isMaxInvalid = (dat: Date): boolean => {\n    if (!this.maxDate || !(this.maxDate instanceof Date) || !dat) {\n      return false;\n    }\n    return this.maxDate.getFullYear() < dat.getFullYear();\n  };\n}\n","<div class=\"list row_auto margin-top-2\"\n     (wheel)=\"scrollYearSelector($event);\">\n  <div class=\"list-item list-item_interactive\"\n       [class.list-item_active]=\"year === currentYear\"\n       [class.list-item_disabled]=\"isYearDisabled(year)\"\n       (click)=\"setYear($event, year)\"\n       (dblclick)=\"applyYear($event, year)\"\n       *ngFor=\"let year of years\">\n    {{year}}\n  </div>\n</div>\n"]}

package/dist/esm2020/component/delimiter/delimiter/delimiter.component.mjs

@@ -0,0 +1,63 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DelimiterComponent {
+    constructor() {
+        this.direction = 'vertical';
+        this.palette = 'text';
+        this.height = 32;
+        this.verticalMargin = 4;
+        this.horizontalMargin = 8;
+    }
+    get getClass() {
+        return [
+            this.class,
+            'delimiter',
+            this.getBgColor(),
+            this.direction === 'horizontal' ? 'display-flex' : 'display-inline-flex',
+        ].join(' ');
+    }
+    get getHeight() {
+        return this.direction === 'vertical' ? '' : '1px';
+    }
+    get getWidth() {
+        return this.direction === 'horizontal' ? '' : '1px';
+    }
+    get getMargin() {
+        return this.direction === 'horizontal' ? '8px' : '0';
+    }
+    getBgColor() {
+        return this.palette ? `bg-${this.palette}-10` : '';
+    }
+    ngOnInit() { }
+}
+DelimiterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DelimiterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: DelimiterComponent, selector: "teta-delimiter", inputs: { direction: "direction", palette: "palette", height: "height", verticalMargin: "verticalMargin", horizontalMargin: "horizontalMargin", class: "class" }, host: { properties: { "class": "this.getClass", "style.height": "this.getHeight", "style.width": "this.getWidth", "style.margin": "this.getMargin" } }, ngImport: i0, template: "", styles: [":host.delimiter{flex-shrink:0}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-delimiter', changeDetection: ChangeDetectionStrategy.OnPush, template: "", styles: [":host.delimiter{flex-shrink:0}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { direction: [{
+                type: Input
+            }], palette: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], verticalMargin: [{
+                type: Input
+            }], horizontalMargin: [{
+                type: Input
+            }], class: [{
+                type: Input
+            }], getClass: [{
+                type: HostBinding,
+                args: ['class']
+            }], getHeight: [{
+                type: HostBinding,
+                args: ['style.height']
+            }], getWidth: [{
+                type: HostBinding,
+                args: ['style.width']
+            }], getMargin: [{
+                type: HostBinding,
+                args: ['style.margin']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/component/delimiter/delimiter.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DelimiterComponent } from './delimiter/delimiter.component';
+import * as i0 from "@angular/core";
+export class DelimiterModule {
+}
+DelimiterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DelimiterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterModule, declarations: [DelimiterComponent], imports: [CommonModule], exports: [DelimiterComponent] });
+DelimiterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DelimiterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DelimiterComponent],
+                    exports: [DelimiterComponent],
+                    imports: [
+                        CommonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsaW1pdGVyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnQvZGVsaW1pdGVyL2RlbGltaXRlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0saUNBQWlDLENBQUM7O0FBU25FLE1BQU0sT0FBTyxlQUFlOzs0R0FBZixlQUFlOzZHQUFmLGVBQWUsaUJBTlgsa0JBQWtCLGFBRy9CLFlBQVksYUFGSixrQkFBa0I7NkdBS2pCLGVBQWUsWUFKakI7WUFDUCxZQUFZO1NBQ2I7MkZBRVUsZUFBZTtrQkFQM0IsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztvQkFDbEMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7b0JBQzdCLE9BQU8sRUFBRTt3QkFDUCxZQUFZO3FCQUNiO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7RGVsaW1pdGVyQ29tcG9uZW50fSBmcm9tICcuL2RlbGltaXRlci9kZWxpbWl0ZXIuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbRGVsaW1pdGVyQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW0RlbGltaXRlckNvbXBvbmVudF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGVcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBEZWxpbWl0ZXJNb2R1bGUge1xufVxuIl19

package/dist/esm2020/component/delimiter/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './delimiter.module';
+export * from './delimiter/delimiter.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb21wb25lbnQvZGVsaW1pdGVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kZWxpbWl0ZXIubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZGVsaW1pdGVyL2RlbGltaXRlci5jb21wb25lbnQnO1xuIl19

package/dist/esm2020/component/dropdown/dropdown/dropdown.component.mjs

@@ -0,0 +1,29 @@
+import { ChangeDetectionStrategy, Component, Inject, } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { DropdownBase } from '../dropdown-base';
+import * as i0 from "@angular/core";
+export class DropdownComponent extends DropdownBase {
+    constructor(_cdr, _document, _elementRef, _zone, _renderer) {
+        super(_cdr, _document, _elementRef, _zone, _renderer);
+        this._cdr = _cdr;
+        this._document = _document;
+        this._elementRef = _elementRef;
+        this._zone = _zone;
+        this._renderer = _renderer;
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        this.closeDropdown();
+        this._alive = false;
+    }
+}
+DropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DropdownComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: DOCUMENT }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+DropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.1", type: DropdownComponent, selector: "teta-dropdown", usesInheritance: true, ngImport: i0, template: "<ng-content select=\"[tetaDropdownHead]\"></ng-content>\n", styles: [""], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'teta-dropdown', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content select=\"[tetaDropdownHead]\"></ng-content>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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