@datarailsshared/datarailsshared 1.4.569 → 1.5.1

package/esm2022/lib/dr-inputs/date-pickers/services/dr-date-picker.service.mjs

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, distinctUntilChanged, Subject } from 'rxjs';
+import { DateFromats, DateTags, TimeframeOption } from '../../../models/datePicker';
+import { DrSharedUtils } from '../../../utils/dr-shared-utils';
+import * as _ from 'lodash';
+import * as i0 from "@angular/core";
+export class DrDatePickerService {
+    constructor() {
+        this.isTimeframeSelectionEnabled = false;
+        this._timeframe$ = new BehaviorSubject(TimeframeOption.DAY);
+        this.timeframe$ = this._timeframe$.asObservable().pipe(distinctUntilChanged());
+        // TODO: here we can have inconsistency between format and timeframe
+        // we need to get rid of a separate subject and use pipe from timeframe$ for it
+        // making @Input() format in component just setting the timeframe
+        this.format$ = new BehaviorSubject(DateFromats.MAT_DEFAULT_DATE_FORMAT);
+        this.updatedQuarter$ = new Subject();
+        this.weekSelectionChange$ = new Subject();
+        this.updatedDateAndClose$ = new Subject();
+        this.presetTag$ = new BehaviorSubject('');
+        this.onSameDaySelectedInCalendar$ = new Subject();
+        this.keepPresetTag = false;
+        this.isValueUpdating = false;
+        this.availableTimeframes = [
+            TimeframeOption.DAY,
+            TimeframeOption.WEEK,
+            TimeframeOption.MONTH,
+            TimeframeOption.QUARTER,
+            TimeframeOption.YEAR,
+        ];
+        this.formatConfig = {
+            day: DateFromats.MAT_DEFAULT_DATE_FORMAT,
+            month: DateFromats.MONTH_YEAR_FORMAT,
+            year: DateFromats.YEAR_FORMAT,
+            quarter: DateFromats.QUARTER_FORMAT,
+            week: DateFromats.WEEK_FORMAT,
+        };
+        this.fiscalYearMonthsModifier = 0;
+        this.fiscalYearBack = false;
+        this._innerValue$ = new BehaviorSubject(null);
+        this.innerValue$ = this._innerValue$.asObservable();
+    }
+    get timeframe() {
+        return this._timeframe$.getValue();
+    }
+    set timeframe(value) {
+        this._timeframe$.next(value);
+    }
+    set innerValue(value) {
+        this._innerValue$.next(value);
+    }
+    get innerValue() {
+        return this._innerValue$.getValue();
+    }
+    getDisplayPrefix() {
+        const formatCached = this.getConfiguredFormat(this.timeframe);
+        switch (true) {
+            case formatCached?.includes('Q'):
+                return 'Q';
+            case formatCached?.includes('W'):
+                return 'W';
+            default:
+                return '';
+        }
+    }
+    getTimeframe(format) {
+        return DrSharedUtils.getTimeframeByDateFormat(format);
+    }
+    getConfiguredFormat(timeframe) {
+        return this.formatConfig[timeframe];
+    }
+    updateTimeframeAndFormat(format) {
+        const normalizedFormat = this.normalizeValue(format || this.format$.getValue());
+        this.timeframe = this.getTimeframe(normalizedFormat);
+        this.format$.next(this.getConfiguredFormat(this.timeframe));
+    }
+    normalizeValue(value) {
+        return value.replace(/d/g, 'D');
+    }
+    /**
+     * Get quarter number for date according to fiscal year
+     *
+     * @param date
+     */
+    getQuarterAccordingToFiscalYear(date) {
+        let fiscalMonth = this.fiscalYearMonthsModifier;
+        const dateMonth = date.month();
+        if (dateMonth < fiscalMonth) {
+            fiscalMonth -= 12;
+        }
+        return Math.trunc((date.month() - fiscalMonth) / 3) + 1;
+    }
+    /**
+     * Sets date to end of quarter in FY by passed quarter number
+     *
+     * @param date
+     * @param quarterNumber
+     */
+    setEndOfQuarter(date, quarterNumber) {
+        date.subtract(this.fiscalYearMonthsModifier, 'M')
+            .startOf('year')
+            .add(this.fiscalYearMonthsModifier + quarterNumber * 3 - 1, 'M')
+            .endOf('month');
+    }
+    /**
+     * Sets date to start of quarter in FY by passed quarter number
+     *
+     * @param date
+     * @param quarterNumber
+     */
+    setStartOfQuarter(date, quarterNumber) {
+        date.subtract(this.fiscalYearMonthsModifier, 'M')
+            .startOf('year')
+            .add(this.fiscalYearMonthsModifier + (quarterNumber - 1) * 3, 'M');
+    }
+    /**
+     * Sets date to end of current quarter (in which date is located) according to FY
+     *
+     * @param date
+     */
+    setEndOfCurrentQuarter(date) {
+        this.setEndOfQuarter(date, this.getQuarterAccordingToFiscalYear(date));
+    }
+    /**
+     * Sets date to start of current quarter (in which date is located) according to FY
+     *
+     * @param date
+     */
+    setStartOfCurrentQuarter(date) {
+        this.setStartOfQuarter(date, this.getQuarterAccordingToFiscalYear(date));
+    }
+    /**
+     * If date selection on this timeframe depends on Fiscal Year
+     *
+     * @param timeframe
+     */
+    isTimeframeDependingOnFY(timeframe) {
+        return _.includes([TimeframeOption.QUARTER, TimeframeOption.YEAR], timeframe);
+    }
+    /**
+     * Subtract from date fiscal year shift months count
+     *
+     * @param date
+     */
+    subtractFiscalYearMonthsFromDate(date) {
+        return this.getDateModifiedByFiscalMonths(date, true);
+    }
+    /**
+     * Add to date fiscal year shift months count
+     *
+     * @param date
+     */
+    addFiscalYearMonthsToDate(date) {
+        return this.getDateModifiedByFiscalMonths(date);
+    }
+    applyFiscalYearShiftForYear(momentDate, isSubtract = false) {
+        if (this.fiscalYearBack || !this.fiscalYearMonthsModifier)
+            return;
+        return momentDate[isSubtract ? 'subtract' : 'add'](1, 'year');
+    }
+    addFiscalYearShiftForYear(momentDate) {
+        return this.applyFiscalYearShiftForYear(momentDate);
+    }
+    subtractFiscalYearShiftForYear(momentDate) {
+        return this.applyFiscalYearShiftForYear(momentDate, true);
+    }
+    /**
+     * Add or subtract depending on isRevert paremeter Fiscal year month shift
+     *
+     * @param date
+     * @param isSubtract
+     */
+    getDateModifiedByFiscalMonths(date, isSubtract = false) {
+        return date ? _.cloneDeep(date)[isSubtract ? 'subtract' : 'add'](this.fiscalYearMonthsModifier, 'month') : date;
+    }
+    updateDatePickerByPreset(tag, calender) {
+        this.keepPresetTag = true;
+        let date = null;
+        if (tag) {
+            date = DrSharedUtils.getDateByTag(tag);
+            switch (tag) {
+                case DateTags.TODAY:
+                    this.updateTimeframeAndFormat(DateFromats.MAT_DEFAULT_DATE_FORMAT);
+                    break;
+                case DateTags.YESTERDAY:
+                    this.updateTimeframeAndFormat(DateFromats.MAT_DEFAULT_DATE_FORMAT);
+                    break;
+                case DateTags.THIS_MONTH:
+                    this.updateTimeframeAndFormat(DateFromats.MONTH_YEAR_FORMAT);
+                    this.selectDateInCalendarMonthView(date, calender);
+                    break;
+                case DateTags.PREV_MONTH:
+                    this.updateTimeframeAndFormat(DateFromats.MONTH_YEAR_FORMAT);
+                    this.selectDateInCalendarMonthView(date, calender);
+                    break;
+            }
+        }
+        this.presetTag$.next(tag);
+        this.updatedDateAndClose$.next(date);
+    }
+    selectDateInCalendarMonthView(date, calender) {
+        setTimeout(() => {
+            const monthView = calender.monthView;
+            if (monthView) {
+                monthView._activeDate = date;
+                monthView._selected = date;
+                monthView._init();
+            }
+        });
+    }
+    resetPresetTag() {
+        if (!this.keepPresetTag) {
+            this.presetTag$.next(null);
+        }
+        else {
+            this.keepPresetTag = false;
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = function DrDatePickerService_Factory(t) { return new (t || DrDatePickerService)(); }; }
+    /** @nocollapse */ static { this.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: DrDatePickerService, factory: DrDatePickerService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrDatePickerService, [{
+        type: Injectable
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dr-date-picker.service.js","sourceRoot":"","sources":["../../../../../../../projects/datarailsshared/src/lib/dr-inputs/date-pickers/services/dr-date-picker.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MatCalendar, MatDatepicker } from '@angular/material/datepicker';\nimport { Moment } from 'moment';\nimport { BehaviorSubject, distinctUntilChanged, Subject } from 'rxjs';\nimport { DateFromats, DateTags, IDatePickerFormatConfig, TimeframeOption, TTimeframeOption } from '../../../models/datePicker';\nimport { DrSharedUtils } from '../../../utils/dr-shared-utils';\nimport * as _ from 'lodash';\nimport { WeekInfo } from '../week-selector/week-selector.component';\n\n@Injectable()\nexport class DrDatePickerService {\n    isTimeframeSelectionEnabled = false;\n    private readonly _timeframe$: BehaviorSubject<TTimeframeOption> = new BehaviorSubject(TimeframeOption.DAY);\n    public readonly timeframe$ = this._timeframe$.asObservable().pipe(distinctUntilChanged());\n\n    public get timeframe(): TTimeframeOption {\n        return this._timeframe$.getValue();\n    }\n\n    public set timeframe(value: TTimeframeOption) {\n        this._timeframe$.next(value);\n    }\n\n    // TODO: here we can have inconsistency between format and timeframe\n    // we need to get rid of a separate subject and use pipe from timeframe$ for it\n    // making @Input() format in component just setting the timeframe\n    format$ = new BehaviorSubject<string>(DateFromats.MAT_DEFAULT_DATE_FORMAT);\n\n    updatedQuarter$ = new Subject<Moment>();\n    readonly weekSelectionChange$ = new Subject<WeekInfo>();\n    updatedDateAndClose$ = new Subject<Moment>();\n    datePickerInstance: MatDatepicker<any>;\n    isUsingDateTagPresets: boolean;\n    presetTag$ = new BehaviorSubject<DateTags>('' as DateTags);\n    onSameDaySelectedInCalendar$ = new Subject<Moment>();\n    keepPresetTag = false;\n    isValueUpdating = false;\n    availableTimeframes = [\n        TimeframeOption.DAY,\n        TimeframeOption.WEEK,\n        TimeframeOption.MONTH,\n        TimeframeOption.QUARTER,\n        TimeframeOption.YEAR,\n    ];\n\n    public formatConfig: IDatePickerFormatConfig = {\n        day: DateFromats.MAT_DEFAULT_DATE_FORMAT,\n        month: DateFromats.MONTH_YEAR_FORMAT,\n        year: DateFromats.YEAR_FORMAT,\n        quarter: DateFromats.QUARTER_FORMAT,\n        week: DateFromats.WEEK_FORMAT,\n    };\n    public calendarInstance: MatCalendar<any>;\n\n    public fiscalYearMonthsModifier = 0;\n    public fiscalYearBack = false;\n    public datepickerFilter: (moment: Moment) => boolean;\n\n    private readonly _innerValue$ = new BehaviorSubject<Moment>(null);\n    public readonly innerValue$ = this._innerValue$.asObservable();\n\n    public set innerValue(value: Moment) {\n        this._innerValue$.next(value);\n    }\n    public get innerValue(): Moment {\n        return this._innerValue$.getValue();\n    }\n\n    getDisplayPrefix() {\n        const formatCached = this.getConfiguredFormat(this.timeframe);\n        switch (true) {\n            case formatCached?.includes('Q'):\n                return 'Q';\n            case formatCached?.includes('W'):\n                return 'W';\n            default:\n                return '';\n        }\n    }\n\n    getTimeframe(format: string) {\n        return DrSharedUtils.getTimeframeByDateFormat(format);\n    }\n\n    getConfiguredFormat(timeframe: TTimeframeOption): string {\n        return this.formatConfig[timeframe];\n    }\n\n    updateTimeframeAndFormat(format: string): void {\n        const normalizedFormat = this.normalizeValue(format || this.format$.getValue());\n        this.timeframe = this.getTimeframe(normalizedFormat);\n        this.format$.next(this.getConfiguredFormat(this.timeframe));\n    }\n\n    normalizeValue(value: string): string {\n        return value.replace(/d/g, 'D');\n    }\n\n    /**\n     * Get quarter number for date according to fiscal year\n     *\n     * @param date\n     */\n    public getQuarterAccordingToFiscalYear(date: Moment): number {\n        let fiscalMonth = this.fiscalYearMonthsModifier;\n        const dateMonth = date.month();\n        if (dateMonth < fiscalMonth) {\n            fiscalMonth -= 12;\n        }\n        return Math.trunc((date.month() - fiscalMonth) / 3) + 1;\n    }\n\n    /**\n     * Sets date to end of quarter in FY by passed quarter number\n     *\n     * @param date\n     * @param quarterNumber\n     */\n    public setEndOfQuarter(date: Moment, quarterNumber: number): void {\n        date.subtract(this.fiscalYearMonthsModifier, 'M')\n            .startOf('year')\n            .add(this.fiscalYearMonthsModifier + quarterNumber * 3 - 1, 'M')\n            .endOf('month');\n    }\n\n    /**\n     * Sets date to start of quarter in FY by passed quarter number\n     *\n     * @param date\n     * @param quarterNumber\n     */\n    public setStartOfQuarter(date: Moment, quarterNumber: number): void {\n        date.subtract(this.fiscalYearMonthsModifier, 'M')\n            .startOf('year')\n            .add(this.fiscalYearMonthsModifier + (quarterNumber - 1) * 3, 'M');\n    }\n\n    /**\n     * Sets date to end of current quarter (in which date is located) according to FY\n     *\n     * @param date\n     */\n    public setEndOfCurrentQuarter(date: Moment): void {\n        this.setEndOfQuarter(date, this.getQuarterAccordingToFiscalYear(date));\n    }\n\n    /**\n     * Sets date to start of current quarter (in which date is located) according to FY\n     *\n     * @param date\n     */\n    public setStartOfCurrentQuarter(date: Moment): void {\n        this.setStartOfQuarter(date, this.getQuarterAccordingToFiscalYear(date));\n    }\n\n    /**\n     * If date selection on this timeframe depends on Fiscal Year\n     *\n     * @param timeframe\n     */\n    public isTimeframeDependingOnFY(timeframe: TimeframeOption) {\n        return _.includes([TimeframeOption.QUARTER, TimeframeOption.YEAR], timeframe);\n    }\n\n    /**\n     * Subtract from date fiscal year shift months count\n     *\n     * @param date\n     */\n    public subtractFiscalYearMonthsFromDate(date: Moment): Moment {\n        return this.getDateModifiedByFiscalMonths(date, true);\n    }\n\n    /**\n     * Add to date fiscal year shift months count\n     *\n     * @param date\n     */\n    public addFiscalYearMonthsToDate(date: Moment): Moment {\n        return this.getDateModifiedByFiscalMonths(date);\n    }\n\n    private applyFiscalYearShiftForYear(momentDate: Moment, isSubtract: boolean = false): Moment | undefined {\n        if (this.fiscalYearBack || !this.fiscalYearMonthsModifier) return;\n        return momentDate[isSubtract ? 'subtract' : 'add'](1, 'year');\n    }\n\n    public addFiscalYearShiftForYear(momentDate: Moment): Moment | undefined {\n        return this.applyFiscalYearShiftForYear(momentDate);\n    }\n\n    public subtractFiscalYearShiftForYear(momentDate: Moment): Moment | undefined {\n        return this.applyFiscalYearShiftForYear(momentDate, true);\n    }\n\n    /**\n     * Add or subtract depending on isRevert paremeter Fiscal year month shift\n     *\n     * @param date\n     * @param isSubtract\n     */\n    private getDateModifiedByFiscalMonths(date: Moment, isSubtract = false): Moment {\n        return date ? _.cloneDeep(date)[isSubtract ? 'subtract' : 'add'](this.fiscalYearMonthsModifier, 'month') : date;\n    }\n\n    public updateDatePickerByPreset(tag: DateTags, calender: any) {\n        this.keepPresetTag = true;\n        let date = null;\n        if (tag) {\n            date = DrSharedUtils.getDateByTag(tag);\n            switch (tag) {\n                case DateTags.TODAY:\n                    this.updateTimeframeAndFormat(DateFromats.MAT_DEFAULT_DATE_FORMAT);\n                    break;\n                case DateTags.YESTERDAY:\n                    this.updateTimeframeAndFormat(DateFromats.MAT_DEFAULT_DATE_FORMAT);\n                    break;\n                case DateTags.THIS_MONTH:\n                    this.updateTimeframeAndFormat(DateFromats.MONTH_YEAR_FORMAT);\n                    this.selectDateInCalendarMonthView(date, calender);\n                    break;\n                case DateTags.PREV_MONTH:\n                    this.updateTimeframeAndFormat(DateFromats.MONTH_YEAR_FORMAT);\n                    this.selectDateInCalendarMonthView(date, calender);\n                    break;\n            }\n        }\n        this.presetTag$.next(tag);\n        this.updatedDateAndClose$.next(date);\n    }\n\n    public selectDateInCalendarMonthView(date: Moment, calender: any): void {\n        setTimeout(() => {\n            const monthView = calender.monthView as any;\n            if (monthView) {\n                monthView._activeDate = date;\n                monthView._selected = date;\n                monthView._init();\n            }\n        });\n    }\n\n    public resetPresetTag() {\n        if (!this.keepPresetTag) {\n            this.presetTag$.next(null);\n        } else {\n            this.keepPresetTag = false;\n        }\n    }\n}\n"]}

package/esm2022/lib/dr-inputs/date-pickers/services/week-selection-strategy.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { DateAdapter } from '@angular/material/core';
+import { DateRange } from '@angular/material/datepicker';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+export class WeekSelectionStrategy {
+    constructor(_dateAdapter) {
+        this._dateAdapter = _dateAdapter;
+    }
+    selectionFinished(date) {
+        return this._createWeekRange(date);
+    }
+    createPreview(activeDate) {
+        return this._createWeekRange(activeDate);
+    }
+    _createWeekRange(date) {
+        if (!date) {
+            return new DateRange(null, null);
+        }
+        // ISO week
+        const startDays = moment(date).diff(moment(date).startOf('isoWeek'), 'days');
+        const endDays = moment(date).diff(moment(date).endOf('isoWeek'), 'days');
+        const start = this._dateAdapter.addCalendarDays(date, -Math.abs(startDays));
+        const end = this._dateAdapter.addCalendarDays(date, Math.abs(endDays));
+        return new DateRange(start, end);
+    }
+    /** @nocollapse */ static { this.ɵfac = function WeekSelectionStrategy_Factory(t) { return new (t || WeekSelectionStrategy)(i0.ɵɵinject(i1.DateAdapter)); }; }
+    /** @nocollapse */ static { this.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: WeekSelectionStrategy, factory: WeekSelectionStrategy.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WeekSelectionStrategy, [{
+        type: Injectable
+    }], function () { return [{ type: i1.DateAdapter }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/dr-inputs/date-pickers/week-selector/week-selector.component.mjs

@@ -0,0 +1,91 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatCalendar } from '@angular/material/datepicker';
+import { startWith, Subject, takeUntil } from 'rxjs';
+import { DrDatePickerService } from '../services/dr-date-picker.service';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+function WeekSelectorComponent_div_4_Template(rf, ctx) { if (rf & 1) {
+    const _r3 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 5);
+    i0.ɵɵlistener("click", function WeekSelectorComponent_div_4_Template_div_click_0_listener() { const restoredCtx = i0.ɵɵrestoreView(_r3); const week_r1 = restoredCtx.$implicit; const ctx_r2 = i0.ɵɵnextContext(); ctx_r2.service.datePickerInstance.close(); return i0.ɵɵresetView(ctx_r2.service.weekSelectionChange$.next(week_r1)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const week_r1 = ctx.$implicit;
+    i0.ɵɵclassProp("selected", week_r1.selected);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" W", week_r1.yearWeekNumber, " ");
+} }
+export class WeekSelectorComponent {
+    constructor() {
+        this.service = inject(DrDatePickerService);
+        this.calendar = inject(MatCalendar);
+        this.cdr = inject(ChangeDetectorRef);
+        this.destroy$ = new Subject();
+        this.currentMonthWeeks = [];
+        inject(DestroyRef, { skipSelf: true }).onDestroy(() => {
+            this.destroy$.next();
+            this.destroy$.complete();
+        });
+        this.calendar.stateChanges.pipe(startWith(null), takeUntil(this.destroy$)).subscribe(() => {
+            setTimeout(() => {
+                const activeDate = moment(this.calendar.activeDate);
+                const selectedRange = this.calendar.selected;
+                this.currentMonthWeeks = this.getWeeksInMonth(activeDate, selectedRange);
+                this.cdr.detectChanges();
+            });
+        });
+    }
+    getWeeksInMonth(date, selectedRange) {
+        const weeks = [];
+        const firstDay = moment(date).startOf('month');
+        const lastDay = moment(date).endOf('month');
+        const firstWeekStart = moment(firstDay).startOf('isoWeek');
+        const lastWeekEnd = moment(lastDay).endOf('isoWeek');
+        let currentWeekStart = moment(firstWeekStart);
+        let weekNumber = 1;
+        while (currentWeekStart.isSameOrBefore(lastWeekEnd)) {
+            const weekEnd = moment(currentWeekStart).endOf('isoWeek');
+            const days = [];
+            for (let i = 0; i < 7; i++) {
+                days.push(moment(currentWeekStart).add(i, 'days'));
+            }
+            const isPartial = days.some((day) => !day.isSame(date, 'month'));
+            const selected = days.some((day) => day.isSame(selectedRange.start, 'day'));
+            // isoWeek() returns the ISO week number (1-53)
+            const yearWeekNumber = moment(currentWeekStart).isoWeek();
+            weeks.push({
+                weekNumber,
+                yearWeekNumber,
+                start: moment(currentWeekStart),
+                end: moment(weekEnd),
+                days,
+                isPartial,
+                selected,
+            });
+            currentWeekStart.add(1, 'week');
+            weekNumber++;
+        }
+        return weeks;
+    }
+    /** @nocollapse */ static { this.ɵfac = function WeekSelectorComponent_Factory(t) { return new (t || WeekSelectorComponent)(); }; }
+    /** @nocollapse */ static { this.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: WeekSelectorComponent, selectors: [["dr-week-selector"]], standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 6, vars: 1, consts: [[1, "weeks"], [1, "header"], [1, "weeks__container"], ["class", "btn", 3, "selected", "click", 4, "ngFor", "ngForOf"], [1, "weeks-border"], [1, "btn", 3, "click"]], template: function WeekSelectorComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "div", 1);
+            i0.ɵɵtext(2, "Week");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(3, "div", 2);
+            i0.ɵɵtemplate(4, WeekSelectorComponent_div_4_Template, 2, 3, "div", 3);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelement(5, "div", 4);
+        } if (rf & 2) {
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngForOf", ctx.currentMonthWeeks);
+        } }, dependencies: [CommonModule, i1.NgForOf], styles: ["[_nghost-%COMP%]{font-size:14px;font-weight:400;line-height:22px;text-align:center;color:#333;display:flex}[_nghost-%COMP%]   .weeks[_ngcontent-%COMP%]{height:100%;flex-direction:column;display:flex}[_nghost-%COMP%]   .weeks-border[_ngcontent-%COMP%]{height:100%;width:1px;background-color:#dfe0e3;margin:0 4px}[_nghost-%COMP%]   .weeks__container[_ngcontent-%COMP%]{display:flex;flex-direction:column;justify-content:space-between;height:100%}[_nghost-%COMP%]   .weeks[_ngcontent-%COMP%]   .header[_ngcontent-%COMP%]{font-weight:600;color:#19181a;padding-bottom:8px;line-height:16px}[_nghost-%COMP%]   .weeks[_ngcontent-%COMP%]   .btn[_ngcontent-%COMP%]{padding:9px 16px;border-radius:40px;cursor:pointer}[_nghost-%COMP%]   .weeks[_ngcontent-%COMP%]   .btn[_ngcontent-%COMP%]:hover{font-weight:600;background-color:#f2f2fb;color:#4646ce}[_nghost-%COMP%]   .weeks[_ngcontent-%COMP%]   .btn.selected[_ngcontent-%COMP%]{font-weight:600;background-color:#4646ce;color:#fff}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WeekSelectorComponent, [{
+        type: Component,
+        args: [{ selector: 'dr-week-selector', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"weeks\">\n    <div class=\"header\">Week</div>\n\n    <div class=\"weeks__container\">\n        <div\n            (click)=\"service.datePickerInstance.close(); service.weekSelectionChange$.next(week)\"\n            class=\"btn\"\n            [class.selected]=\"week.selected\"\n            *ngFor=\"let week of currentMonthWeeks\">\n            W{{ week.yearWeekNumber }}\n        </div>\n    </div>\n</div>\n<div class=\"weeks-border\"></div>\n", styles: [":host{font-size:14px;font-weight:400;line-height:22px;text-align:center;color:#333;display:flex}:host .weeks{height:100%;flex-direction:column;display:flex}:host .weeks-border{height:100%;width:1px;background-color:#dfe0e3;margin:0 4px}:host .weeks__container{display:flex;flex-direction:column;justify-content:space-between;height:100%}:host .weeks .header{font-weight:600;color:#19181a;padding-bottom:8px;line-height:16px}:host .weeks .btn{padding:9px 16px;border-radius:40px;cursor:pointer}:host .weeks .btn:hover{font-weight:600;background-color:#f2f2fb;color:#4646ce}:host .weeks .btn.selected{font-weight:600;background-color:#4646ce;color:#fff}\n"] }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"week-selector.component.js","sourceRoot":"","sources":["../../../../../../../projects/datarailsshared/src/lib/dr-inputs/date-pickers/week-selector/week-selector.component.ts","../../../../../../../projects/datarailsshared/src/lib/dr-inputs/date-pickers/week-selector/week-selector.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, inject } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { DateRange, MatCalendar } from '@angular/material/datepicker';\nimport { startWith, Subject, takeUntil } from 'rxjs';\nimport { DrDatePickerService } from '../services/dr-date-picker.service';\nimport moment, { Moment } from 'moment';\n\nexport interface WeekInfo {\n    weekNumber: number;\n    yearWeekNumber: number;\n    start: Moment;\n    end: Moment;\n    days: Moment[];\n    isPartial: boolean;\n    selected: boolean;\n}\n\n@Component({\n    selector: 'dr-week-selector',\n    standalone: true,\n    imports: [CommonModule],\n    templateUrl: './week-selector.component.html',\n    styleUrls: ['./week-selector.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class WeekSelectorComponent {\n    readonly service = inject(DrDatePickerService);\n    private readonly calendar = inject(MatCalendar);\n    private readonly cdr = inject(ChangeDetectorRef);\n    private readonly destroy$ = new Subject<void>();\n\n    currentMonthWeeks: WeekInfo[] = [];\n\n    constructor() {\n        inject(DestroyRef, { skipSelf: true }).onDestroy(() => {\n            this.destroy$.next();\n            this.destroy$.complete();\n        });\n\n        this.calendar.stateChanges.pipe(startWith(null), takeUntil(this.destroy$)).subscribe(() => {\n            setTimeout(() => {\n                const activeDate = moment(this.calendar.activeDate);\n                const selectedRange: DateRange<Moment> = this.calendar.selected;\n                this.currentMonthWeeks = this.getWeeksInMonth(activeDate, selectedRange);\n                this.cdr.detectChanges();\n            });\n        });\n    }\n\n    private getWeeksInMonth(date: Moment, selectedRange: DateRange<Moment>): WeekInfo[] {\n        const weeks: WeekInfo[] = [];\n        const firstDay = moment(date).startOf('month');\n        const lastDay = moment(date).endOf('month');\n\n        const firstWeekStart = moment(firstDay).startOf('isoWeek');\n        const lastWeekEnd = moment(lastDay).endOf('isoWeek');\n\n        let currentWeekStart = moment(firstWeekStart);\n        let weekNumber = 1;\n\n        while (currentWeekStart.isSameOrBefore(lastWeekEnd)) {\n            const weekEnd = moment(currentWeekStart).endOf('isoWeek');\n            const days: Moment[] = [];\n\n            for (let i = 0; i < 7; i++) {\n                days.push(moment(currentWeekStart).add(i, 'days'));\n            }\n\n            const isPartial = days.some((day) => !day.isSame(date, 'month'));\n            const selected = days.some((day) => day.isSame(selectedRange.start, 'day'));\n\n            // isoWeek() returns the ISO week number (1-53)\n            const yearWeekNumber = moment(currentWeekStart).isoWeek();\n\n            weeks.push({\n                weekNumber,\n                yearWeekNumber,\n                start: moment(currentWeekStart),\n                end: moment(weekEnd),\n                days,\n                isPartial,\n                selected,\n            });\n\n            currentWeekStart.add(1, 'week');\n            weekNumber++;\n        }\n\n        return weeks;\n    }\n}\n","<div class=\"weeks\">\n    <div class=\"header\">Week</div>\n\n    <div class=\"weeks__container\">\n        <div\n            (click)=\"service.datePickerInstance.close(); service.weekSelectionChange$.next(week)\"\n            class=\"btn\"\n            [class.selected]=\"week.selected\"\n            *ngFor=\"let week of currentMonthWeeks\">\n            W{{ week.yearWeekNumber }}\n        </div>\n    </div>\n</div>\n<div class=\"weeks-border\"></div>\n"]}