bbj-screen-widget 2.4.62 → 2.4.63

package/esm2015/lib/date-picker/date-picker.component.js

@@ -0,0 +1,447 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Component, EventEmitter } from '@angular/core';
+import { DataOutput, Event, Method, Property, Widget, Param, Data, DataInput } from 'bbj-widget-base';
+import { addDays, startOfMonth, addMonths, startOfYear, addYears, startOfWeek, addWeeks, startOfDay, parse, } from 'date-fns';
+import { NzI18nService } from 'ng-zorro-antd/i18n';
+import { formatDate } from '@angular/common';
+import { differenceInCalendarDays } from 'date-fns/fp';
+const defaultDateEnum = [
+    { label: '当前', value: 'now' },
+    { label: '今天', value: 'today' },
+    { label: '昨天', value: 'yesterday' },
+    { label: '明天', value: 'tomorrow' },
+    { label: '本月', value: 'thisMonth' },
+    { label: '上个月', value: 'lastMonth' },
+    { label: '下个月', value: 'nextMonth' },
+    { label: '本周', value: 'thisWeek' },
+    { label: '上周', value: 'lastWeek' },
+    { label: '下周', value: 'nextWeek' },
+    { label: '今年', value: 'thisYear' },
+    { label: '去年', value: 'lastYear' },
+    { label: '明年', value: 'nextYear' },
+];
+let DatePickerComponent = class DatePickerComponent {
+    // isEnglish = false;
+    constructor(i18n) {
+        this.i18n = i18n;
+        this.font = { family: '', weight: 'normal', size: 14, space: 0, lineHeight: '' };
+        this.backImage = null;
+        this.height = 30;
+        this.dateFormat = '';
+        this.selectMode = '';
+        this.showTime = false;
+        this.timeFormat = 'HH:mm:ss';
+        this.alert = '请选择日期';
+        this.allowClear = true;
+        this.data = [];
+        this.dateChange = new EventEmitter();
+        this.endDateChange = new EventEmitter();
+        this.inputDate = new EventEmitter();
+        this.inputEndDate = new EventEmitter();
+        this.dateRange = [];
+    }
+    ngOnInit() {
+        // this.initDefaultDate();
+    }
+    /**
+     * {label: '当前', value: 'now'},
+     {label: '昨天', value: 'yesterday'},
+     {label: '明天', value: 'tomorrow'},
+     {label: '本月', value: 'thisMonth'},
+     {label: '上个月', value: 'lastMonth'},
+     {label: '下个月', value: 'nextMonth'},
+     {label: '本周', value: 'thisWeek'},
+     {label: '上个月', value: 'lastWeek'},
+     {label: '下个月', value: 'nextWeek'},
+     {label: '今年', value: 'thisYear'},
+     {label: '去年', value: 'lastYear'},
+     {label: '明年', value: 'nextYear'},
+     */
+    initDefaultDate() {
+        if (this.rangeMode) {
+            const start = this.getDefaultDate(this.defaultDate);
+            const end = this.getDefaultDate(this.defaultEndDate);
+            this.date = [start, end];
+            if (start || end) {
+                this.onChange(this.date);
+            }
+        }
+        else {
+            this.date = this.getDefaultDate(this.defaultDate);
+            if (this.date) {
+                this.onChange(this.date);
+            }
+        }
+    }
+    getDefaultDate(defaultDate) {
+        if (defaultDate) {
+            const today = new Date();
+            switch (defaultDate) {
+                case 'now':
+                    return today;
+                case 'today':
+                    return startOfDay(today);
+                case 'yesterday':
+                    return addDays(startOfDay(today), -1);
+                case 'tomorrow':
+                    return addDays(startOfDay(today), 1);
+                case 'thisMonth':
+                    return startOfMonth(today);
+                case 'lastMonth':
+                    return addMonths(startOfMonth(today), -1);
+                case 'nextMonth':
+                    return addMonths(startOfMonth(today), 1);
+                case 'thisYear':
+                    return startOfYear(today);
+                case 'lastYear':
+                    return addYears(startOfYear(today), -1);
+                case 'nextYear':
+                    return addYears(startOfYear(today), 1);
+                case 'thisWeek':
+                    return addDays(startOfWeek(addDays(today, -1)), 1);
+                case 'lastWeek':
+                    return addWeeks(addDays(startOfWeek(addDays(today, -1)), 1), -1);
+                case 'nextWeek':
+                    return addWeeks(addDays(startOfWeek(addDays(today, -1)), 1), 1);
+            }
+        }
+        return null;
+    }
+    ngOnChanges(changes) {
+        if (changes.dateFormat && !this.dateFormat) {
+            this.setDefaultFormat();
+        }
+        this.datePickerStyle = {
+            borderColor: this.borderColor,
+            backgroundColor: this.background,
+            fontSize: this.font.size + 'px',
+            fontFamily: this.font.family,
+            color: this.font.color,
+            fontWeight: this.font.weight,
+            letterSpacing: this.font.space + 'px',
+            height: this.height + 'px',
+            backgroundSize: '100% 100%',
+            lineHeight: this.font.lineHeight + 'px',
+        };
+        if (this.showTime) {
+            this.nzShowTime = {
+                nzFormat: this.timeFormat || 'HH:mm:ss',
+                nzHourStep: this.hourStep,
+                nzMinuteStep: this.minuteStep,
+                nzSecondStep: this.secondStep,
+            };
+        }
+        if (this.backImage) {
+            this.datePickerStyle.backgroundImage = 'url(' + this.backImage + ')';
+        }
+        if (changes.rangeMode || changes.defaultDate || changes.defaultEndDate) {
+            this.initDefaultDate();
+        }
+        if (changes.data) {
+            this.updateData();
+        }
+        if (changes.disabledDate) {
+            this.updateDisabledDate();
+        }
+        if (changes.value) {
+            if (!this.date) {
+                this.date = null;
+            }
+            else if (typeof this.date === 'string') {
+                this.date = parse(this.date, this.dateFormat, new Date());
+            }
+        }
+    }
+    updateDisabledDate() {
+        switch (this.disabledDate) {
+            case 'after':
+                this.nzDisabledDate = (current) => differenceInCalendarDays(current, new Date()) < 0;
+                break;
+            case 'before':
+                this.nzDisabledDate = (current) => differenceInCalendarDays(current, new Date()) > 0;
+                break;
+            default:
+                this.nzDisabledDate = null;
+        }
+    }
+    updateData() {
+        var _a;
+        if ((_a = this.data) === null || _a === void 0 ? void 0 : _a.length) {
+            const { date, endDate } = this.data[0];
+            const start = this.getDate(date);
+            if (this.rangeMode) {
+                const end = this.getDate(endDate);
+                if (start || end) {
+                    this.date = [start || this.date[0], end || this.date[1]];
+                    this.onChange(this.date);
+                }
+            }
+            else {
+                if (start) {
+                    this.date = start;
+                    this.onChange(this.date);
+                }
+            }
+        }
+    }
+    getDate(value) {
+        if (value) {
+            return new Date(value);
+        }
+        else {
+            return null;
+        }
+    }
+    onChange(result, input) {
+        if (!this.rangeMode) {
+            const date = this.format(this.date);
+            this.dateChange.emit(date);
+            if (input) {
+                this.inputDate.emit(date);
+            }
+        }
+        else {
+            // date=format(this.date[0], this.dateFormat)+'-'+format(this.date[1], this.dateFormat);
+            const start = this.format(this.date[0]);
+            const end = this.format(this.date[1]);
+            this.dateChange.emit(start);
+            this.endDateChange.emit(end);
+            if (input) {
+                this.inputDate.emit(start);
+                this.inputEndDate.emit(end);
+            }
+        }
+    }
+    format(date) {
+        if (date) {
+            return formatDate(date, this.dateFormat, this.i18n.getLocaleId());
+        }
+        else {
+            return null;
+        }
+    }
+    setDefaultFormat() {
+        switch (this.selectMode) {
+            case 'week':
+                this.dateFormat = 'yyyy-ww';
+                break;
+            case 'month':
+                // console.log(today);
+                this.dateFormat = 'yyyy-MM';
+                break;
+            case 'year':
+                this.dateFormat = 'yyyy';
+                break;
+            default:
+                if (this.showTime) {
+                    this.dateFormat = 'yyyy-MM-dd HH:mm:ss';
+                    if (this.timeFormat) {
+                        switch (this.timeFormat) {
+                            case 'HH':
+                                this.dateFormat = 'yyyy-MM-dd HH:00:00';
+                                break;
+                            case 'HH:mm':
+                                this.dateFormat = 'yyyy-MM-dd HH:mm:00';
+                                break;
+                        }
+                    }
+                }
+                else {
+                    this.dateFormat = 'yyyy-MM-dd';
+                }
+                break;
+        }
+    }
+    setValue(value) {
+        this.date = value;
+        this.onChange(value);
+    }
+    // changeLanguage(): void {
+    //   this.i18n.setLocale(this.isEnglish ? zh_CN : en_US);
+    //   this.isEnglish = !this.isEnglish;
+    // }
+    exportWord() {
+        return null;
+    }
+};
+DatePickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'sc-date-picker',
+                template: "<ng-container *ngIf=\"!rangeMode\">\n  <nz-date-picker\n    [nzDisabled]=\"disabled\"\n    [nzMode]=\"selectMode\"\n    [(ngModel)]=\"date\"\n    [nzFormat]=\"dateFormat\"\n    (ngModelChange)=\"onChange(date, true)\"\n    class=\"demo-picker\"\n    [nzPlaceHolder]=\"alert\"\n    [ngStyle]=\"datePickerStyle\"\n    [nzShowTime]=\"nzShowTime\"\n    [nzDisabledDate]=\"nzDisabledDate\"\n    [nzAllowClear]=\"allowClear !== false\"\n  >\n  </nz-date-picker>\n</ng-container>\n<ng-container *ngIf=\"rangeMode\">\n  <nz-range-picker\n    [nzDisabled]=\"disabled\"\n    [nzMode]=\"selectMode\"\n    [(ngModel)]=\"date\"\n    [nzFormat]=\"dateFormat\"\n    (ngModelChange)=\"onChange(date, true)\"\n    class=\"demo-picker\"\n    [nzPlaceHolder]=\"alert\"\n    [ngStyle]=\"datePickerStyle\"\n    [nzShowTime]=\"nzShowTime\"\n    [nzDisabledDate]=\"nzDisabledDate\"\n    [nzAllowClear]=\"allowClear !== false\"\n  >\n  </nz-range-picker>\n</ng-container>\n",
+                styles: [":host ::ng-deep .demo-picker{background-color:unset;height:32px;width:100%;color:inherit}:host ::ng-deep .ant-picker-input>input{color:inherit;font-size:inherit;font-weight:inherit}:host ::ng-deep .ant-picker-suffix{color:inherit}.ant-picker-disabled::ng-deep .ant-picker-suffix{display:none}"]
+            },] }
+];
+DatePickerComponent.ctorParameters = () => [
+    { type: NzI18nService }
+];
+__decorate([
+    Property('边框', {
+        ui: {
+            widget: 'myColor',
+            example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],
+        },
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "borderColor", void 0);
+__decorate([
+    Property('字体', { ui: { widget: 'myFont' } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "font", void 0);
+__decorate([
+    Property('填充', {
+        ui: {
+            widget: 'myColor',
+            example: ['#D0021B', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],
+        },
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "background", void 0);
+__decorate([
+    Property('背景图片', {
+        type: 'string',
+        ui: {
+            widget: 'myUpload',
+        },
+    }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "backImage", void 0);
+__decorate([
+    Property('高度'),
+    __metadata("design:type", Number)
+], DatePickerComponent.prototype, "height", void 0);
+__decorate([
+    Property('日期格式', {
+        dateFormat: {
+            type: 'string',
+            title: 'max',
+            ui: {},
+        },
+        required: ['dateFormat'],
+    }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "dateFormat", void 0);
+__decorate([
+    Property('开启区间模式'),
+    __metadata("design:type", Boolean)
+], DatePickerComponent.prototype, "rangeMode", void 0);
+__decorate([
+    Property('默认时间', {
+        type: 'string',
+        enum: defaultDateEnum,
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "defaultDate", void 0);
+__decorate([
+    Property('默认结束时间', {
+        type: 'string',
+        enum: defaultDateEnum,
+        ui: { widget: 'select', visibleIf: { rangeMode: [true] } },
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "defaultEndDate", void 0);
+__decorate([
+    Property('选择模式', {
+        type: 'string',
+        enum: [
+            { label: '默认', value: '' },
+            { label: '周', value: 'week' },
+            { label: '月份', value: 'month' },
+            { label: '年份', value: 'year' },
+        ],
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "selectMode", void 0);
+__decorate([
+    Property('显示时间', {
+        type: 'boolean',
+    }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "showTime", void 0);
+__decorate([
+    Property('时间格式', {
+        enum: [
+            { label: '时分秒', value: 'HH:mm:ss' },
+            { label: '时分', value: 'HH:mm' },
+            { label: '时', value: 'HH' },
+        ],
+        ui: { widget: 'select', visibleIf: { showTime: [true] } },
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "timeFormat", void 0);
+__decorate([
+    Property('小时间隔', { ui: { visibleIf: { showTime: [true] } } }),
+    __metadata("design:type", Number)
+], DatePickerComponent.prototype, "hourStep", void 0);
+__decorate([
+    Property('分钟间隔', { ui: { visibleIf: { timeFormat: ['HH:mm:ss', 'HH:mm'] } } }),
+    __metadata("design:type", Number)
+], DatePickerComponent.prototype, "minuteStep", void 0);
+__decorate([
+    Property('秒间隔', { ui: { visibleIf: { timeFormat: ['HH:mm:ss'] } } }),
+    __metadata("design:type", Number)
+], DatePickerComponent.prototype, "secondStep", void 0);
+__decorate([
+    Property('提示语'),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "alert", void 0);
+__decorate([
+    Property('是否禁用'),
+    __metadata("design:type", Boolean)
+], DatePickerComponent.prototype, "disabled", void 0);
+__decorate([
+    Property('不可选日期', {
+        enum: [
+            { label: '今天之后', value: 'after' },
+            { label: '今天之前', value: 'before' },
+        ],
+    }),
+    __metadata("design:type", String)
+], DatePickerComponent.prototype, "disabledDate", void 0);
+__decorate([
+    Property('清除按钮', { type: 'boolean', default: true }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "allowClear", void 0);
+__decorate([
+    Data({ properties: { date: { title: '日期', type: 'string' }, endDate: { title: '结束日期', type: 'string' } } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "data", void 0);
+__decorate([
+    DataOutput('值'),
+    Event('值改变', { params: { title: '值' } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "dateChange", void 0);
+__decorate([
+    DataOutput('结束'),
+    Event('结束值', { params: { title: '结束值' } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "endDateChange", void 0);
+__decorate([
+    Event('输入', { params: { title: '值' } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "inputDate", void 0);
+__decorate([
+    Event('输入结束时间', { params: { title: '结束值' } }),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "inputEndDate", void 0);
+__decorate([
+    DataInput('值'),
+    __metadata("design:type", Object)
+], DatePickerComponent.prototype, "date", void 0);
+__decorate([
+    Method('设置值'),
+    __param(0, Param('值')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Date]),
+    __metadata("design:returntype", void 0)
+], DatePickerComponent.prototype, "setValue", null);
+DatePickerComponent = __decorate([
+    Widget('日期选择器', {
+        group: 'component',
+        image: 'assets/img/screen/date-picker.png',
+        icon: 'riqi',
+        platform: 'pc',
+    }),
+    __metadata("design:paramtypes", [NzI18nService])
+], DatePickerComponent);
+export { DatePickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-picker.component.js","sourceRoot":"","sources":["../../../../../projects/screen-widget/src/lib/date-picker/date-picker.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAoC,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAgB,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACpH,OAAO,EAGL,OAAO,EACP,YAAY,EACZ,SAAS,EACT,WAAW,EACX,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,KAAK,GACN,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,eAAe,GAAG;IACtB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE;IAC7B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;IAC/B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;IACnC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE;IACnC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE;IACpC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE;IACpC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;IAClC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE;CACnC,CAAC;IAaW,mBAAmB,SAAnB,mBAAmB;IA6G9B,qBAAqB;IAErB,YAAoB,IAAmB;QAAnB,SAAI,GAAJ,IAAI,CAAe;QAtGvC,SAAI,GAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;QAcjF,cAAS,GAAG,IAAI,CAAC;QAEjB,WAAM,GAAW,EAAE,CAAC;QASpB,eAAU,GAAG,EAAE,CAAC;QAuBhB,eAAU,GAAW,EAAE,CAAC;QAIxB,aAAQ,GAAG,KAAK,CAAC;QASjB,eAAU,GAAW,UAAU,CAAC;QAQhC,UAAK,GAAG,OAAO,CAAC;QAWhB,eAAU,GAAG,IAAI,CAAC;QAGlB,SAAI,GAAG,EAAE,CAAC;QAGV,eAAU,GAAG,IAAI,YAAY,EAAO,CAAC;QAGrC,kBAAa,GAAG,IAAI,YAAY,EAAO,CAAC;QAExC,cAAS,GAAG,IAAI,YAAY,EAAO,CAAC;QAEpC,iBAAY,GAAG,IAAI,YAAY,EAAO,CAAC;QAGvC,cAAS,GAAG,EAAE,CAAC;IAM2B,CAAC;IAE3C,QAAQ;QACN,0BAA0B;IAC5B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,eAAe;QACb,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACpD,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACrD,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACzB,IAAI,KAAK,IAAI,GAAG,EAAE;gBAChB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC1B;SACF;aAAM;YACL,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAClD,IAAI,IAAI,CAAC,IAAI,EAAE;gBACb,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC1B;SACF;IACH,CAAC;IAED,cAAc,CAAC,WAAmB;QAChC,IAAI,WAAW,EAAE;YACf,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;YACzB,QAAQ,WAAW,EAAE;gBACnB,KAAK,KAAK;oBACR,OAAO,KAAK,CAAC;gBACf,KAAK,OAAO;oBACV,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;gBAC3B,KAAK,WAAW;oBACd,OAAO,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACxC,KAAK,UAAU;oBACb,OAAO,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBACvC,KAAK,WAAW;oBACd,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;gBAC7B,KAAK,WAAW;oBACd,OAAO,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC5C,KAAK,WAAW;oBACd,OAAO,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC3C,KAAK,UAAU;oBACb,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;gBAC5B,KAAK,UAAU;oBACb,OAAO,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC1C,KAAK,UAAU;oBACb,OAAO,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBACzC,KAAK,UAAU;oBACb,OAAO,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBACrD,KAAK,UAAU;oBACb,OAAO,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACnE,KAAK,UAAU;oBACb,OAAO,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;aACnE;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAC1C,IAAI,CAAC,gBAAgB,EAAE,CAAC;SACzB;QACD,IAAI,CAAC,eAAe,GAAG;YACrB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,eAAe,EAAE,IAAI,CAAC,UAAU;YAChC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI;YAC/B,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;YAC5B,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;YACtB,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM;YAC5B,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI;YACrC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,IAAI;YAC1B,cAAc,EAAE,WAAW;YAC3B,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI;SACxC,CAAC;QACF,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,UAAU,GAAG;gBAChB,QAAQ,EAAE,IAAI,CAAC,UAAU,IAAI,UAAU;gBACvC,UAAU,EAAE,IAAI,CAAC,QAAQ;gBACzB,YAAY,EAAE,IAAI,CAAC,UAAU;gBAC7B,YAAY,EAAE,IAAI,CAAC,UAAU;aAC9B,CAAC;SACH;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;SACtE;QACD,IAAI,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,cAAc,EAAE;YACtE,IAAI,CAAC,eAAe,EAAE,CAAC;SACxB;QACD,IAAI,OAAO,CAAC,IAAI,EAAE;YAChB,IAAI,CAAC,UAAU,EAAE,CAAC;SACnB;QACD,IAAI,OAAO,CAAC,YAAY,EAAE;YACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;QACD,IAAI,OAAO,CAAC,KAAK,EAAE;YACjB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;gBACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;aAClB;iBAAM,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;gBACxC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;aAC3D;SACF;IACH,CAAC;IAED,kBAAkB;QAChB,QAAQ,IAAI,CAAC,YAAY,EAAE;YACzB,KAAK,OAAO;gBACV,IAAI,CAAC,cAAc,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,wBAAwB,CAAC,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;gBACrF,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,cAAc,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,wBAAwB,CAAC,OAAO,EAAE,IAAI,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;gBACrF,MAAM;YACR;gBACE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;SAC9B;IACH,CAAC;IAED,UAAU;;QACR,UAAI,IAAI,CAAC,IAAI,0CAAE,MAAM,EAAE;YACrB,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACvC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACjC,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBAClC,IAAI,KAAK,IAAI,GAAG,EAAE;oBAChB,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC1B;aACF;iBAAM;gBACL,IAAI,KAAK,EAAE;oBACT,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;oBAClB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBAC1B;aACF;SACF;IACH,CAAC;IAED,OAAO,CAAC,KAAU;QAChB,IAAI,KAAK,EAAE;YACT,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;SACxB;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,QAAQ,CAAC,MAAY,EAAE,KAAe;QACpC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,KAAK,EAAE;gBACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC3B;SACF;aAAM;YACL,wFAAwF;YACxF,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACxC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACtC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC7B,IAAI,KAAK,EAAE;gBACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC7B;SACF;IACH,CAAC;IAED,MAAM,CAAC,IAAU;QACf,IAAI,IAAI,EAAE;YACR,OAAO,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;SACnE;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,gBAAgB;QACd,QAAQ,IAAI,CAAC,UAAU,EAAE;YACvB,KAAK,MAAM;gBACT,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;gBAC5B,MAAM;YACR,KAAK,OAAO;gBACV,sBAAsB;gBACtB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;gBAC5B,MAAM;YACR,KAAK,MAAM;gBACT,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;gBACzB,MAAM;YACR;gBACE,IAAI,IAAI,CAAC,QAAQ,EAAE;oBACjB,IAAI,CAAC,UAAU,GAAG,qBAAqB,CAAC;oBACxC,IAAI,IAAI,CAAC,UAAU,EAAE;wBACnB,QAAQ,IAAI,CAAC,UAAU,EAAE;4BACvB,KAAK,IAAI;gCACP,IAAI,CAAC,UAAU,GAAG,qBAAqB,CAAC;gCACxC,MAAM;4BACR,KAAK,OAAO;gCACV,IAAI,CAAC,UAAU,GAAG,qBAAqB,CAAC;gCACxC,MAAM;yBACT;qBACF;iBACF;qBAAM;oBACL,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC;iBAChC;gBACD,MAAM;SACT;IACH,CAAC;IAED,QAAQ,CAAa,KAAW;QAC9B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,2BAA2B;IAC3B,yDAAyD;IACzD,sCAAsC;IACtC,IAAI;IAEJ,UAAU;QACR,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAA;;YA/VA,SAAS,SAAC;gBACT,QAAQ,EAAE,gBAAgB;gBAC1B,i8BAA2C;;aAE5C;;;YAzBQ,aAAa;;AAuCpB;IANC,QAAQ,CAAC,IAAI,EAAE;QACd,EAAE,EAAE;YACF,MAAM,EAAE,SAAS;YACjB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC;SAC7F;KACF,CAAC;;wDACkB;AAEpB;IADC,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;;iDACoC;AAOjF;IANC,QAAQ,CAAC,IAAI,EAAE;QACd,EAAE,EAAE;YACF,MAAM,EAAE,SAAS;YACjB,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC;SAC7F;KACF,CAAC;;uDACiB;AAOnB;IANC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,QAAQ;QACd,EAAE,EAAE;YACF,MAAM,EAAE,UAAU;SACnB;KACF,CAAC;;sDACe;AAEjB;IADC,QAAQ,CAAC,IAAI,CAAC;;mDACK;AASpB;IARC,QAAQ,CAAC,MAAM,EAAE;QAChB,UAAU,EAAE;YACV,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,KAAK;YACZ,EAAE,EAAE,EAA0B;SAC/B;QACD,QAAQ,EAAE,CAAC,YAAY,CAAC;KACzB,CAAC;;uDACc;AAEhB;IADC,QAAQ,CAAC,QAAQ,CAAC;;sDACA;AAKnB;IAJC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE,eAAe;KACtB,CAAC;;wDACkB;AAMpB;IALC,QAAQ,CAAC,QAAQ,EAAE;QAClB,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE,eAAe;QACrB,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE;KAC3D,CAAC;;2DACqB;AAUvB;IATC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE;YACJ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE;YAC1B,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE;YAC7B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;YAC/B,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;SAC/B;KACF,CAAC;;uDACsB;AAIxB;IAHC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,SAAS;KAChB,CAAC;;qDACe;AASjB;IARC,QAAQ,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE;YACJ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE;YACnC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;YAC/B,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE;SAC5B;QACD,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE;KAC1D,CAAC;;uDAC8B;AAEhC;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;;qDAC7C;AAEjB;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;;uDAC5D;AAEnB;IADC,QAAQ,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;;uDAClD;AAEnB;IADC,QAAQ,CAAC,KAAK,CAAC;;kDACA;AAEhB;IADC,QAAQ,CAAC,MAAM,CAAC;;qDACC;AAOlB;IANC,QAAQ,CAAC,OAAO,EAAE;QACjB,IAAI,EAAE;YACJ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE;YACjC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE;SACnC;KACF,CAAC;;yDACmB;AAErB;IADC,QAAQ,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;;uDACnC;AAGlB;IADC,IAAI,CAAC,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;;iDAClG;AAGV;IAFC,UAAU,CAAC,GAAG,CAAC;IACf,KAAK,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;;uDACJ;AAGrC;IAFC,UAAU,CAAC,IAAI,CAAC;IAChB,KAAK,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;;0DACH;AAExC;IADC,KAAK,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;;sDACJ;AAEpC;IADC,KAAK,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;;yDACP;AAEvC;IADC,SAAS,CAAC,GAAG,CAAC;;iDACL;AA+NV;IADC,MAAM,CAAC,KAAK,CAAC;IACJ,WAAA,KAAK,CAAC,GAAG,CAAC,CAAA;;qCAAQ,IAAI;;mDAG/B;AA1UU,mBAAmB;IAN/B,MAAM,CAAC,OAAO,EAAE;QACf,KAAK,EAAE,WAAW;QAClB,KAAK,EAAE,mCAAmC;QAC1C,IAAI,EAAE,MAAM;QACZ,QAAQ,EAAE,IAAI;KACf,CAAC;qCAgH0B,aAAa;GA/G5B,mBAAmB,CAoV/B;SApVY,mBAAmB","sourcesContent":["import { Component, OnInit, OnChanges, SimpleChanges, EventEmitter } from '@angular/core';\nimport { DataOutput, Event, Method, Property, Widget, Param, Data, CustomExport, DataInput } from 'bbj-widget-base';\nimport {\n  compareAsc,\n  format,\n  addDays,\n  startOfMonth,\n  addMonths,\n  startOfYear,\n  addYears,\n  startOfWeek,\n  addWeeks,\n  startOfDay,\n  parse,\n} from 'date-fns';\nimport { SFStringWidgetSchema } from '@delon/form';\nimport { NzI18nService } from 'ng-zorro-antd/i18n';\nimport { formatDate } from '@angular/common';\nimport { DisabledDateFn, SupportTimeOptions } from 'ng-zorro-antd/date-picker';\nimport { differenceInCalendarDays } from 'date-fns/fp';\n\nconst defaultDateEnum = [\n  { label: '当前', value: 'now' },\n  { label: '今天', value: 'today' },\n  { label: '昨天', value: 'yesterday' },\n  { label: '明天', value: 'tomorrow' },\n  { label: '本月', value: 'thisMonth' },\n  { label: '上个月', value: 'lastMonth' },\n  { label: '下个月', value: 'nextMonth' },\n  { label: '本周', value: 'thisWeek' },\n  { label: '上周', value: 'lastWeek' },\n  { label: '下周', value: 'nextWeek' },\n  { label: '今年', value: 'thisYear' },\n  { label: '去年', value: 'lastYear' },\n  { label: '明年', value: 'nextYear' },\n];\n\n@Component({\n  selector: 'sc-date-picker',\n  templateUrl: './date-picker.component.html',\n  styleUrls: ['./date-picker.component.less'],\n})\n@Widget('日期选择器', {\n  group: 'component',\n  image: 'assets/img/screen/date-picker.png',\n  icon: 'riqi',\n  platform: 'pc',\n})\nexport class DatePickerComponent implements OnInit, OnChanges, CustomExport {\n  @Property('边框', {\n    ui: {\n      widget: 'myColor',\n      example: ['#ffffff', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],\n    },\n  })\n  borderColor: string;\n  @Property('字体', { ui: { widget: 'myFont' } })\n  font: any = { family: '', weight: 'normal', size: 14, space: 0, lineHeight: '' };\n  @Property('填充', {\n    ui: {\n      widget: 'myColor',\n      example: ['#D0021B', '#F5A623', '#F8E71C', '#50E3C2', '#3285FF', '#B45FFF', '#9B9B9B', null],\n    },\n  })\n  background: string;\n  @Property('背景图片', {\n    type: 'string',\n    ui: {\n      widget: 'myUpload',\n    },\n  })\n  backImage = null;\n  @Property('高度')\n  height: number = 30;\n  @Property('日期格式', {\n    dateFormat: {\n      type: 'string',\n      title: 'max',\n      ui: {} as SFStringWidgetSchema,\n    },\n    required: ['dateFormat'],\n  })\n  dateFormat = '';\n  @Property('开启区间模式')\n  rangeMode: boolean;\n  @Property('默认时间', {\n    type: 'string',\n    enum: defaultDateEnum,\n  })\n  defaultDate: string;\n  @Property('默认结束时间', {\n    type: 'string',\n    enum: defaultDateEnum,\n    ui: { widget: 'select', visibleIf: { rangeMode: [true] } },\n  })\n  defaultEndDate: string;\n  @Property('选择模式', {\n    type: 'string',\n    enum: [\n      { label: '默认', value: '' },\n      { label: '周', value: 'week' },\n      { label: '月份', value: 'month' },\n      { label: '年份', value: 'year' },\n    ],\n  })\n  selectMode: string = '';\n  @Property('显示时间', {\n    type: 'boolean',\n  })\n  showTime = false;\n  @Property('时间格式', {\n    enum: [\n      { label: '时分秒', value: 'HH:mm:ss' },\n      { label: '时分', value: 'HH:mm' },\n      { label: '时', value: 'HH' },\n    ],\n    ui: { widget: 'select', visibleIf: { showTime: [true] } },\n  })\n  timeFormat: string = 'HH:mm:ss';\n  @Property('小时间隔', { ui: { visibleIf: { showTime: [true] } } })\n  hourStep: number;\n  @Property('分钟间隔', { ui: { visibleIf: { timeFormat: ['HH:mm:ss', 'HH:mm'] } } })\n  minuteStep: number;\n  @Property('秒间隔', { ui: { visibleIf: { timeFormat: ['HH:mm:ss'] } } })\n  secondStep: number;\n  @Property('提示语')\n  alert = '请选择日期';\n  @Property('是否禁用')\n  disabled: boolean;\n  @Property('不可选日期', {\n    enum: [\n      { label: '今天之后', value: 'after' },\n      { label: '今天之前', value: 'before' },\n    ],\n  })\n  disabledDate: string;\n  @Property('清除按钮', { type: 'boolean', default: true })\n  allowClear = true;\n\n  @Data({ properties: { date: { title: '日期', type: 'string' }, endDate: { title: '结束日期', type: 'string' } } })\n  data = [];\n  @DataOutput('值')\n  @Event('值改变', { params: { title: '值' } })\n  dateChange = new EventEmitter<any>();\n  @DataOutput('结束')\n  @Event('结束值', { params: { title: '结束值' } })\n  endDateChange = new EventEmitter<any>();\n  @Event('输入', { params: { title: '值' } })\n  inputDate = new EventEmitter<any>();\n  @Event('输入结束时间', { params: { title: '结束值' } })\n  inputEndDate = new EventEmitter<any>();\n  @DataInput('值')\n  date: any;\n  dateRange = [];\n  datePickerStyle: any;\n  nzShowTime: SupportTimeOptions;\n  nzDisabledDate: DisabledDateFn;\n  // isEnglish = false;\n\n  constructor(private i18n: NzI18nService) {}\n\n  ngOnInit(): void {\n    // this.initDefaultDate();\n  }\n\n  /**\n   * {label: '当前', value: 'now'},\n   {label: '昨天', value: 'yesterday'},\n   {label: '明天', value: 'tomorrow'},\n   {label: '本月', value: 'thisMonth'},\n   {label: '上个月', value: 'lastMonth'},\n   {label: '下个月', value: 'nextMonth'},\n   {label: '本周', value: 'thisWeek'},\n   {label: '上个月', value: 'lastWeek'},\n   {label: '下个月', value: 'nextWeek'},\n   {label: '今年', value: 'thisYear'},\n   {label: '去年', value: 'lastYear'},\n   {label: '明年', value: 'nextYear'},\n   */\n  initDefaultDate() {\n    if (this.rangeMode) {\n      const start = this.getDefaultDate(this.defaultDate);\n      const end = this.getDefaultDate(this.defaultEndDate);\n      this.date = [start, end];\n      if (start || end) {\n        this.onChange(this.date);\n      }\n    } else {\n      this.date = this.getDefaultDate(this.defaultDate);\n      if (this.date) {\n        this.onChange(this.date);\n      }\n    }\n  }\n\n  getDefaultDate(defaultDate: string) {\n    if (defaultDate) {\n      const today = new Date();\n      switch (defaultDate) {\n        case 'now':\n          return today;\n        case 'today':\n          return startOfDay(today);\n        case 'yesterday':\n          return addDays(startOfDay(today), -1);\n        case 'tomorrow':\n          return addDays(startOfDay(today), 1);\n        case 'thisMonth':\n          return startOfMonth(today);\n        case 'lastMonth':\n          return addMonths(startOfMonth(today), -1);\n        case 'nextMonth':\n          return addMonths(startOfMonth(today), 1);\n        case 'thisYear':\n          return startOfYear(today);\n        case 'lastYear':\n          return addYears(startOfYear(today), -1);\n        case 'nextYear':\n          return addYears(startOfYear(today), 1);\n        case 'thisWeek':\n          return addDays(startOfWeek(addDays(today, -1)), 1);\n        case 'lastWeek':\n          return addWeeks(addDays(startOfWeek(addDays(today, -1)), 1), -1);\n        case 'nextWeek':\n          return addWeeks(addDays(startOfWeek(addDays(today, -1)), 1), 1);\n      }\n    }\n    return null;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.dateFormat && !this.dateFormat) {\n      this.setDefaultFormat();\n    }\n    this.datePickerStyle = {\n      borderColor: this.borderColor,\n      backgroundColor: this.background,\n      fontSize: this.font.size + 'px',\n      fontFamily: this.font.family,\n      color: this.font.color,\n      fontWeight: this.font.weight,\n      letterSpacing: this.font.space + 'px',\n      height: this.height + 'px',\n      backgroundSize: '100% 100%',\n      lineHeight: this.font.lineHeight + 'px',\n    };\n    if (this.showTime) {\n      this.nzShowTime = {\n        nzFormat: this.timeFormat || 'HH:mm:ss',\n        nzHourStep: this.hourStep,\n        nzMinuteStep: this.minuteStep,\n        nzSecondStep: this.secondStep,\n      };\n    }\n    if (this.backImage) {\n      this.datePickerStyle.backgroundImage = 'url(' + this.backImage + ')';\n    }\n    if (changes.rangeMode || changes.defaultDate || changes.defaultEndDate) {\n      this.initDefaultDate();\n    }\n    if (changes.data) {\n      this.updateData();\n    }\n    if (changes.disabledDate) {\n      this.updateDisabledDate();\n    }\n    if (changes.value) {\n      if (!this.date) {\n        this.date = null;\n      } else if (typeof this.date === 'string') {\n        this.date = parse(this.date, this.dateFormat, new Date());\n      }\n    }\n  }\n\n  updateDisabledDate() {\n    switch (this.disabledDate) {\n      case 'after':\n        this.nzDisabledDate = (current) => differenceInCalendarDays(current, new Date()) < 0;\n        break;\n      case 'before':\n        this.nzDisabledDate = (current) => differenceInCalendarDays(current, new Date()) > 0;\n        break;\n      default:\n        this.nzDisabledDate = null;\n    }\n  }\n\n  updateData() {\n    if (this.data?.length) {\n      const { date, endDate } = this.data[0];\n      const start = this.getDate(date);\n      if (this.rangeMode) {\n        const end = this.getDate(endDate);\n        if (start || end) {\n          this.date = [start || this.date[0], end || this.date[1]];\n          this.onChange(this.date);\n        }\n      } else {\n        if (start) {\n          this.date = start;\n          this.onChange(this.date);\n        }\n      }\n    }\n  }\n\n  getDate(value: any) {\n    if (value) {\n      return new Date(value);\n    } else {\n      return null;\n    }\n  }\n\n  onChange(result: Date, input?: boolean): void {\n    if (!this.rangeMode) {\n      const date = this.format(this.date);\n      this.dateChange.emit(date);\n      if (input) {\n        this.inputDate.emit(date);\n      }\n    } else {\n      // date=format(this.date[0], this.dateFormat)+'-'+format(this.date[1], this.dateFormat);\n      const start = this.format(this.date[0]);\n      const end = this.format(this.date[1]);\n      this.dateChange.emit(start);\n      this.endDateChange.emit(end);\n      if (input) {\n        this.inputDate.emit(start);\n        this.inputEndDate.emit(end);\n      }\n    }\n  }\n\n  format(date: Date) {\n    if (date) {\n      return formatDate(date, this.dateFormat, this.i18n.getLocaleId());\n    } else {\n      return null;\n    }\n  }\n\n  setDefaultFormat() {\n    switch (this.selectMode) {\n      case 'week':\n        this.dateFormat = 'yyyy-ww';\n        break;\n      case 'month':\n        // console.log(today);\n        this.dateFormat = 'yyyy-MM';\n        break;\n      case 'year':\n        this.dateFormat = 'yyyy';\n        break;\n      default:\n        if (this.showTime) {\n          this.dateFormat = 'yyyy-MM-dd HH:mm:ss';\n          if (this.timeFormat) {\n            switch (this.timeFormat) {\n              case 'HH':\n                this.dateFormat = 'yyyy-MM-dd HH:00:00';\n                break;\n              case 'HH:mm':\n                this.dateFormat = 'yyyy-MM-dd HH:mm:00';\n                break;\n            }\n          }\n        } else {\n          this.dateFormat = 'yyyy-MM-dd';\n        }\n        break;\n    }\n  }\n  @Method('设置值')\n  setValue(@Param('值') value: Date) {\n    this.date = value;\n    this.onChange(value);\n  }\n\n  // changeLanguage(): void {\n  //   this.i18n.setLocale(this.isEnglish ? zh_CN : en_US);\n  //   this.isEnglish = !this.isEnglish;\n  // }\n\n  exportWord() {\n    return null;\n  }\n}\n"]}

package/esm2015/lib/date-picker/date-picker.module.js

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DatePickerComponent } from './date-picker.component';
+import { WidgetBaseModule, WidgetService } from 'bbj-widget-base';
+import { NzDatePickerModule } from 'ng-zorro-antd/date-picker';
+import { FormsModule } from '@angular/forms';
+export class DatePickerModule {
+    constructor(widgetService) {
+        widgetService.register(DatePickerComponent);
+    }
+}
+DatePickerModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [DatePickerComponent],
+                imports: [CommonModule, WidgetBaseModule, NzDatePickerModule, FormsModule],
+                exports: [DatePickerComponent]
+            },] }
+];
+DatePickerModule.ctorParameters = () => [
+    { type: WidgetService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1waWNrZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2NyZWVuLXdpZGdldC9zcmMvbGliL2RhdGUtcGlja2VyL2RhdGUtcGlja2VyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUUsYUFBYSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDaEUsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7QUFDN0QsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBUTNDLE1BQU0sT0FBTyxnQkFBZ0I7SUFDM0IsWUFBWSxhQUE0QjtRQUN0QyxhQUFhLENBQUMsUUFBUSxDQUFDLG1CQUFtQixDQUFDLENBQUM7SUFDOUMsQ0FBQzs7O1lBUkYsUUFBUSxTQUFDO2dCQUNSLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO2dCQUNuQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsa0JBQWtCLEVBQUUsV0FBVyxDQUFDO2dCQUMxRSxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQzthQUMvQjs7O1lBVHlCLGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtEYXRlUGlja2VyQ29tcG9uZW50fSBmcm9tICcuL2RhdGUtcGlja2VyLmNvbXBvbmVudCc7XG5pbXBvcnQge1dpZGdldEJhc2VNb2R1bGUsIFdpZGdldFNlcnZpY2V9IGZyb20gJ2Jiai13aWRnZXQtYmFzZSc7XG5pbXBvcnQge056RGF0ZVBpY2tlck1vZHVsZX0gZnJvbSAnbmctem9ycm8tYW50ZC9kYXRlLXBpY2tlcic7XG5pbXBvcnQge0Zvcm1zTW9kdWxlfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbRGF0ZVBpY2tlckNvbXBvbmVudF0sXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFdpZGdldEJhc2VNb2R1bGUsIE56RGF0ZVBpY2tlck1vZHVsZSwgRm9ybXNNb2R1bGVdLFxuICBleHBvcnRzOiBbRGF0ZVBpY2tlckNvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgRGF0ZVBpY2tlck1vZHVsZSB7XG4gIGNvbnN0cnVjdG9yKHdpZGdldFNlcnZpY2U6IFdpZGdldFNlcnZpY2UpIHtcbiAgICB3aWRnZXRTZXJ2aWNlLnJlZ2lzdGVyKERhdGVQaWNrZXJDb21wb25lbnQpO1xuICB9XG59XG4iXX0=