@dereekb/dbx-form 9.17.2 → 9.18.0

package/esm2020/calendar/lib/calendar.schedule.selection.popover.component.mjs

@@ -0,0 +1,37 @@
+import { Component } from '@angular/core';
+import { AbstractPopoverDirective } from '@dereekb/dbx-web';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-web";
+import * as i2 from "./calendar.schedule.selection.popover.content.component";
+export const DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY = 'calendarselection';
+export class DbxScheduleSelectionCalendarDatePopoverComponent extends AbstractPopoverDirective {
+    static openPopover(popoverService, { origin, injector }, popoverKey) {
+        return popoverService.open({
+            key: popoverKey ?? DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY,
+            origin,
+            componentClass: DbxScheduleSelectionCalendarDatePopoverComponent,
+            injector
+        });
+    }
+}
+DbxScheduleSelectionCalendarDatePopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDatePopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDatePopoverComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <dbx-popover-content>
+      <dbx-popover-scroll-content>
+        <dbx-schedule-selection-calendar-date-popover-content (close)="close()"></dbx-schedule-selection-calendar-date-popover-content>
+      </dbx-popover-scroll-content>
+    </dbx-popover-content>
+  `, isInline: true, dependencies: [{ kind: "component", type: i1.DbxPopoverContentComponent, selector: "dbx-popover-content" }, { kind: "component", type: i1.DbxPopoverScrollContentComponent, selector: "dbx-popover-scroll-content" }, { kind: "component", type: i2.DbxScheduleSelectionCalendarDatePopoverContentComponent, selector: "dbx-schedule-selection-calendar-date-popover-content" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-popover-content>
+      <dbx-popover-scroll-content>
+        <dbx-schedule-selection-calendar-date-popover-content (close)="close()"></dbx-schedule-selection-calendar-date-popover-content>
+      </dbx-popover-scroll-content>
+    </dbx-popover-content>
+  `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXIuc2NoZWR1bGUuc2VsZWN0aW9uLnBvcG92ZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vY2FsZW5kYXIvc3JjL2xpYi9jYWxlbmRhci5zY2hlZHVsZS5zZWxlY3Rpb24ucG9wb3Zlci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBd0IsTUFBTSxlQUFlLENBQUM7QUFDaEUsT0FBTyxFQUFpQix3QkFBd0IsRUFBcUIsTUFBTSxrQkFBa0IsQ0FBQzs7OztBQUc5RixNQUFNLENBQUMsTUFBTSxvREFBb0QsR0FBRyxtQkFBbUIsQ0FBQztBQWdCeEYsTUFBTSxPQUFPLGdEQUFpRCxTQUFRLHdCQUE4QjtJQUNsRyxNQUFNLENBQUMsV0FBVyxDQUFDLGNBQWlDLEVBQUUsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFpRCxFQUFFLFVBQTBCO1FBQ25KLE9BQU8sY0FBYyxDQUFDLElBQUksQ0FBQztZQUN6QixHQUFHLEVBQUUsVUFBVSxJQUFJLG9EQUFvRDtZQUN2RSxNQUFNO1lBQ04sY0FBYyxFQUFFLGdEQUFnRDtZQUNoRSxRQUFRO1NBQ1QsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7OElBUlUsZ0RBQWdEO2tJQUFoRCxnREFBZ0QsMkVBUmpEOzs7Ozs7R0FNVDs0RkFFVSxnREFBZ0Q7a0JBVDVELFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOzs7Ozs7R0FNVDtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgRWxlbWVudFJlZiwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERieFBvcG92ZXJLZXksIEFic3RyYWN0UG9wb3ZlckRpcmVjdGl2ZSwgRGJ4UG9wb3ZlclNlcnZpY2UgfSBmcm9tICdAZGVyZWVrYi9kYngtd2ViJztcbmltcG9ydCB7IE5nUG9wb3ZlclJlZiB9IGZyb20gJ25nLW92ZXJsYXktY29udGFpbmVyJztcblxuZXhwb3J0IGNvbnN0IERFRkFVTFRfU0NIRURVTEVfU0VMRUNUSU9OX0NBTEVOREFSX0RBVEVfUE9QT1ZFUl9LRVkgPSAnY2FsZW5kYXJzZWxlY3Rpb24nO1xuXG5leHBvcnQgaW50ZXJmYWNlIERieFNjaGVkdWxlU2VsZWN0aW9uQ2FsZW5kYXJEYXRlUG9wb3ZlckNvbmZpZyB7XG4gIG9yaWdpbjogRWxlbWVudFJlZjtcbiAgaW5qZWN0b3I6IEluamVjdG9yO1xufVxuXG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBcbiAgICA8ZGJ4LXBvcG92ZXItY29udGVudD5cbiAgICAgIDxkYngtcG9wb3Zlci1zY3JvbGwtY29udGVudD5cbiAgICAgICAgPGRieC1zY2hlZHVsZS1zZWxlY3Rpb24tY2FsZW5kYXItZGF0ZS1wb3BvdmVyLWNvbnRlbnQgKGNsb3NlKT1cImNsb3NlKClcIj48L2RieC1zY2hlZHVsZS1zZWxlY3Rpb24tY2FsZW5kYXItZGF0ZS1wb3BvdmVyLWNvbnRlbnQ+XG4gICAgICA8L2RieC1wb3BvdmVyLXNjcm9sbC1jb250ZW50PlxuICAgIDwvZGJ4LXBvcG92ZXItY29udGVudD5cbiAgYFxufSlcbmV4cG9ydCBjbGFzcyBEYnhTY2hlZHVsZVNlbGVjdGlvbkNhbGVuZGFyRGF0ZVBvcG92ZXJDb21wb25lbnQgZXh0ZW5kcyBBYnN0cmFjdFBvcG92ZXJEaXJlY3RpdmU8dm9pZD4ge1xuICBzdGF0aWMgb3BlblBvcG92ZXIocG9wb3ZlclNlcnZpY2U6IERieFBvcG92ZXJTZXJ2aWNlLCB7IG9yaWdpbiwgaW5qZWN0b3IgfTogRGJ4U2NoZWR1bGVTZWxlY3Rpb25DYWxlbmRhckRhdGVQb3BvdmVyQ29uZmlnLCBwb3BvdmVyS2V5PzogRGJ4UG9wb3ZlcktleSk6IE5nUG9wb3ZlclJlZjxhbnksIG51bWJlcj4ge1xuICAgIHJldHVybiBwb3BvdmVyU2VydmljZS5vcGVuKHtcbiAgICAgIGtleTogcG9wb3ZlcktleSA/PyBERUZBVUxUX1NDSEVEVUxFX1NFTEVDVElPTl9DQUxFTkRBUl9EQVRFX1BPUE9WRVJfS0VZLFxuICAgICAgb3JpZ2luLFxuICAgICAgY29tcG9uZW50Q2xhc3M6IERieFNjaGVkdWxlU2VsZWN0aW9uQ2FsZW5kYXJEYXRlUG9wb3ZlckNvbXBvbmVudCxcbiAgICAgIGluamVjdG9yXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/calendar/lib/calendar.schedule.selection.popover.content.component.mjs

@@ -0,0 +1,27 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./calendar.schedule.selection.days.component";
+import * as i2 from "./calendar.schedule.selection.range.component";
+export class DbxScheduleSelectionCalendarDatePopoverContentComponent {
+    ngOnDestroy() { }
+}
+DbxScheduleSelectionCalendarDatePopoverContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDatePopoverContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDatePopoverContentComponent, selector: "dbx-schedule-selection-calendar-date-popover-content", ngImport: i0, template: `
+    <div>
+      <dbx-schedule-selection-calendar-date-range></dbx-schedule-selection-calendar-date-range>
+      <dbx-schedule-selection-calendar-date-days></dbx-schedule-selection-calendar-date-days>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: i1.DbxScheduleSelectionCalendarDateDaysComponent, selector: "dbx-schedule-selection-calendar-date-days" }, { kind: "component", type: i2.DbxScheduleSelectionCalendarDateRangeComponent, selector: "dbx-schedule-selection-calendar-date-range", inputs: ["required", "appearance", "label", "hint", "disabled", "showCustomize"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-date-popover-content',
+                    template: `
+    <div>
+      <dbx-schedule-selection-calendar-date-range></dbx-schedule-selection-calendar-date-range>
+      <dbx-schedule-selection-calendar-date-days></dbx-schedule-selection-calendar-date-days>
+    </div>
+  `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXIuc2NoZWR1bGUuc2VsZWN0aW9uLnBvcG92ZXIuY29udGVudC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9jYWxlbmRhci9zcmMvbGliL2NhbGVuZGFyLnNjaGVkdWxlLnNlbGVjdGlvbi5wb3BvdmVyLmNvbnRlbnQuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWEsTUFBTSxlQUFlLENBQUM7Ozs7QUFXckQsTUFBTSxPQUFPLHVEQUF1RDtJQUNsRSxXQUFXLEtBQVUsQ0FBQzs7cUpBRFgsdURBQXVEO3lJQUF2RCx1REFBdUQsNEZBUHhEOzs7OztHQUtUOzRGQUVVLHVEQUF1RDtrQkFUbkUsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsc0RBQXNEO29CQUNoRSxRQUFRLEVBQUU7Ozs7O0dBS1Q7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdkYngtc2NoZWR1bGUtc2VsZWN0aW9uLWNhbGVuZGFyLWRhdGUtcG9wb3Zlci1jb250ZW50JyxcbiAgdGVtcGxhdGU6IGBcbiAgICA8ZGl2PlxuICAgICAgPGRieC1zY2hlZHVsZS1zZWxlY3Rpb24tY2FsZW5kYXItZGF0ZS1yYW5nZT48L2RieC1zY2hlZHVsZS1zZWxlY3Rpb24tY2FsZW5kYXItZGF0ZS1yYW5nZT5cbiAgICAgIDxkYngtc2NoZWR1bGUtc2VsZWN0aW9uLWNhbGVuZGFyLWRhdGUtZGF5cz48L2RieC1zY2hlZHVsZS1zZWxlY3Rpb24tY2FsZW5kYXItZGF0ZS1kYXlzPlxuICAgIDwvZGl2PlxuICBgXG59KVxuZXhwb3J0IGNsYXNzIERieFNjaGVkdWxlU2VsZWN0aW9uQ2FsZW5kYXJEYXRlUG9wb3ZlckNvbnRlbnRDb21wb25lbnQgaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICBuZ09uRGVzdHJveSgpOiB2b2lkIHt9XG59XG4iXX0=

package/esm2020/calendar/lib/calendar.schedule.selection.range.component.mjs

@@ -0,0 +1,99 @@
+import { switchMap, throttleTime } from 'rxjs/operators';
+import { SubscriptionObject } from '@dereekb/rxjs';
+import { Component, Input } from '@angular/core';
+import { DbxCalendarScheduleSelectionStore } from './calendar.schedule.selection.store';
+import { DbxCalendarStore } from '@dereekb/dbx-web/calendar';
+import { FormGroup, FormControl } from '@angular/forms';
+import { randomNumberFactory } from '@dereekb/util';
+import { distinctUntilChanged, filter, BehaviorSubject, startWith, of } from 'rxjs';
+import { isSameDateDay } from '@dereekb/date';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-web/calendar";
+import * as i2 from "./calendar.schedule.selection.store";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@dereekb/dbx-web";
+import * as i7 from "@angular/material/datepicker";
+export class DbxScheduleSelectionCalendarDateRangeComponent {
+    constructor(dbxCalendarStore, dbxCalendarScheduleSelectionStore) {
+        this.dbxCalendarStore = dbxCalendarStore;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.appearance = 'fill';
+        this.label = 'Enter a date range';
+        this.showCustomize = false;
+        this.random = randomNumberFactory(10000)();
+        this._pickerOpened = new BehaviorSubject(false);
+        this._syncSub = new SubscriptionObject();
+        this._valueSub = new SubscriptionObject();
+        this.range = new FormGroup({
+            start: new FormControl(null),
+            end: new FormControl(null)
+        });
+        this.minDate$ = this.dbxCalendarScheduleSelectionStore.minDate$;
+        this.maxDate$ = this.dbxCalendarScheduleSelectionStore.maxDate$;
+        this.isCustomized$ = this.dbxCalendarScheduleSelectionStore.isCustomized$;
+        this.pickerOpened$ = this._pickerOpened.asObservable();
+    }
+    set disabled(disabled) {
+        if (disabled) {
+            this.range.disable();
+        }
+        else {
+            this.range.enable();
+        }
+    }
+    ngOnInit() {
+        this._syncSub.subscription = this.dbxCalendarScheduleSelectionStore.inputRange$.subscribe((x) => {
+            this.range.setValue({
+                start: x.inputStart ?? null,
+                end: x.inputEnd ?? null
+            });
+        });
+        this._valueSub.subscription = this._pickerOpened
+            .pipe(distinctUntilChanged(), switchMap((opened) => {
+            let obs;
+            if (opened) {
+                obs = of({});
+            }
+            else {
+                obs = this.range.valueChanges.pipe(startWith(this.range.value));
+            }
+            return obs;
+        }), filter((x) => Boolean(x.start && x.end)), distinctUntilChanged((a, b) => isSameDateDay(a.start, b.start) && isSameDateDay(a.end, b.end)), throttleTime(100, undefined, { trailing: true }))
+            .subscribe((x) => {
+            if (x.start && x.end) {
+                this.dbxCalendarScheduleSelectionStore.setInputRange({ inputStart: x.start, inputEnd: x.end });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._syncSub.destroy();
+        this._valueSub.destroy();
+    }
+    pickerOpened() {
+        this._pickerOpened.next(true);
+    }
+    pickerClosed() {
+        this._pickerOpened.next(false);
+    }
+}
+DbxScheduleSelectionCalendarDateRangeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateRangeComponent, deps: [{ token: i1.DbxCalendarStore }, { token: i2.DbxCalendarScheduleSelectionStore }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateRangeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateRangeComponent, selector: "dbx-schedule-selection-calendar-date-range", inputs: { required: "required", appearance: "appearance", label: "label", hint: "hint", disabled: "disabled", showCustomize: "showCustomize" }, ngImport: i0, template: "<mat-form-field class=\"dbx-schedule-selection-calendar-date-range-field\" [appearance]=\"appearance\">\n  <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n  <div *ngIf=\"showCustomize && (isCustomized$ | async)\" class=\"date-range-field-customized\">\n    <span class=\"dbx-accent-bg date-range-field-customized-text\">Custom</span>\n  </div>\n  <mat-date-range-input [required]=\"required\" [min]=\"minDate$ | async\" [max]=\"maxDate$ | async\" [formGroup]=\"range\" [rangePicker]=\"picker\">\n    <input matStartDate formControlName=\"start\" placeholder=\"Start date\" />\n    <input matEndDate formControlName=\"end\" placeholder=\"End date\" />\n  </mat-date-range-input>\n  <mat-datepicker-toggle matIconSuffix [for]=\"picker\"></mat-datepicker-toggle>\n  <div *ngIf=\"showCustomize\">\n    <dbx-button-spacer></dbx-button-spacer>\n    <ng-content select=\"[customizeButton]\"></ng-content>\n  </div>\n  <mat-date-range-picker #picker (opened)=\"pickerOpened()\" (closed)=\"pickerClosed()\"></mat-date-range-picker>\n  <mat-error *ngIf=\"range.controls.start.hasError('matStartDateInvalid')\">Invalid start date</mat-error>\n  <mat-error *ngIf=\"range.controls.end.hasError('matEndDateInvalid')\">Invalid end date</mat-error>\n</mat-form-field>\n", dependencies: [{ kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.MatError, selector: "mat-error", inputs: ["id"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatLabel, selector: "mat-label" }, { kind: "directive", type: i6.DbxButtonSpacerDirective, selector: "dbx-button-spacer,[dbxButtonSpacer]" }, { kind: "component", type: i7.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "component", type: i7.MatDateRangeInput, selector: "mat-date-range-input", inputs: ["rangePicker", "required", "dateFilter", "min", "max", "disabled", "separator", "comparisonStart", "comparisonEnd"], exportAs: ["matDateRangeInput"] }, { kind: "directive", type: i7.MatStartDate, selector: "input[matStartDate]", inputs: ["errorStateMatcher"], outputs: ["dateChange", "dateInput"] }, { kind: "directive", type: i7.MatEndDate, selector: "input[matEndDate]", inputs: ["errorStateMatcher"], outputs: ["dateChange", "dateInput"] }, { kind: "component", type: i7.MatDateRangePicker, selector: "mat-date-range-picker", exportAs: ["matDateRangePicker"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateRangeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dbx-schedule-selection-calendar-date-range', template: "<mat-form-field class=\"dbx-schedule-selection-calendar-date-range-field\" [appearance]=\"appearance\">\n  <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n  <div *ngIf=\"showCustomize && (isCustomized$ | async)\" class=\"date-range-field-customized\">\n    <span class=\"dbx-accent-bg date-range-field-customized-text\">Custom</span>\n  </div>\n  <mat-date-range-input [required]=\"required\" [min]=\"minDate$ | async\" [max]=\"maxDate$ | async\" [formGroup]=\"range\" [rangePicker]=\"picker\">\n    <input matStartDate formControlName=\"start\" placeholder=\"Start date\" />\n    <input matEndDate formControlName=\"end\" placeholder=\"End date\" />\n  </mat-date-range-input>\n  <mat-datepicker-toggle matIconSuffix [for]=\"picker\"></mat-datepicker-toggle>\n  <div *ngIf=\"showCustomize\">\n    <dbx-button-spacer></dbx-button-spacer>\n    <ng-content select=\"[customizeButton]\"></ng-content>\n  </div>\n  <mat-date-range-picker #picker (opened)=\"pickerOpened()\" (closed)=\"pickerClosed()\"></mat-date-range-picker>\n  <mat-error *ngIf=\"range.controls.start.hasError('matStartDateInvalid')\">Invalid start date</mat-error>\n  <mat-error *ngIf=\"range.controls.end.hasError('matEndDateInvalid')\">Invalid end date</mat-error>\n</mat-form-field>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DbxCalendarStore }, { type: i2.DbxCalendarScheduleSelectionStore }]; }, propDecorators: { required: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], showCustomize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.schedule.selection.range.component.js","sourceRoot":"","sources":["../../../../../../packages/dbx-form/calendar/src/lib/calendar.schedule.selection.range.component.ts","../../../../../../packages/dbx-form/calendar/src/lib/calendar.schedule.selection.range.component.html"],"names":[],"mappings":"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","sourcesContent":["import { switchMap, throttleTime } from 'rxjs/operators';\nimport { SubscriptionObject } from '@dereekb/rxjs';\nimport { Component, Input, OnDestroy } from '@angular/core';\nimport { DbxCalendarScheduleSelectionStore } from './calendar.schedule.selection.store';\nimport { DbxCalendarStore } from '@dereekb/dbx-web/calendar';\nimport { FormGroup, FormControl } from '@angular/forms';\nimport { Maybe, randomNumberFactory } from '@dereekb/util';\nimport { distinctUntilChanged, filter, BehaviorSubject, startWith, Observable, of } from 'rxjs';\nimport { isSameDateDay } from '@dereekb/date';\nimport { MatFormFieldAppearance } from '@angular/material/form-field';\n\n@Component({\n  selector: 'dbx-schedule-selection-calendar-date-range',\n  templateUrl: './calendar.schedule.selection.range.component.html'\n})\nexport class DbxScheduleSelectionCalendarDateRangeComponent implements OnDestroy {\n  @Input()\n  required?: boolean;\n\n  @Input()\n  appearance: MatFormFieldAppearance = 'fill';\n\n  @Input()\n  label?: Maybe<string> = 'Enter a date range';\n\n  @Input()\n  hint?: Maybe<string>;\n\n  @Input()\n  set disabled(disabled: Maybe<boolean>) {\n    if (disabled) {\n      this.range.disable();\n    } else {\n      this.range.enable();\n    }\n  }\n\n  @Input()\n  showCustomize = false;\n\n  readonly random = randomNumberFactory(10000)();\n\n  private _pickerOpened = new BehaviorSubject<boolean>(false);\n\n  private _syncSub = new SubscriptionObject();\n  private _valueSub = new SubscriptionObject();\n\n  readonly range = new FormGroup({\n    start: new FormControl<Maybe<Date>>(null),\n    end: new FormControl<Maybe<Date>>(null)\n  });\n\n  readonly minDate$ = this.dbxCalendarScheduleSelectionStore.minDate$;\n  readonly maxDate$ = this.dbxCalendarScheduleSelectionStore.maxDate$;\n  readonly isCustomized$ = this.dbxCalendarScheduleSelectionStore.isCustomized$;\n\n  readonly pickerOpened$ = this._pickerOpened.asObservable();\n\n  constructor(readonly dbxCalendarStore: DbxCalendarStore, readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore) {}\n\n  ngOnInit(): void {\n    this._syncSub.subscription = this.dbxCalendarScheduleSelectionStore.inputRange$.subscribe((x) => {\n      this.range.setValue({\n        start: x.inputStart ?? null,\n        end: x.inputEnd ?? null\n      });\n    });\n\n    this._valueSub.subscription = this._pickerOpened\n      .pipe(\n        distinctUntilChanged(),\n        switchMap((opened) => {\n          let obs: Observable<{ start?: Maybe<Date>; end?: Maybe<Date> }>;\n\n          if (opened) {\n            obs = of({});\n          } else {\n            obs = this.range.valueChanges.pipe(startWith(this.range.value));\n          }\n\n          return obs;\n        }),\n        filter((x) => Boolean(x.start && x.end)),\n        distinctUntilChanged((a, b) => isSameDateDay(a.start, b.start) && isSameDateDay(a.end, b.end)),\n        throttleTime(100, undefined, { trailing: true })\n      )\n      .subscribe((x) => {\n        if (x.start && x.end) {\n          this.dbxCalendarScheduleSelectionStore.setInputRange({ inputStart: x.start, inputEnd: x.end });\n        }\n      });\n  }\n\n  ngOnDestroy(): void {\n    this._syncSub.destroy();\n    this._valueSub.destroy();\n  }\n\n  pickerOpened() {\n    this._pickerOpened.next(true);\n  }\n\n  pickerClosed() {\n    this._pickerOpened.next(false);\n  }\n}\n","<mat-form-field class=\"dbx-schedule-selection-calendar-date-range-field\" [appearance]=\"appearance\">\n  <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n  <div *ngIf=\"showCustomize && (isCustomized$ | async)\" class=\"date-range-field-customized\">\n    <span class=\"dbx-accent-bg date-range-field-customized-text\">Custom</span>\n  </div>\n  <mat-date-range-input [required]=\"required\" [min]=\"minDate$ | async\" [max]=\"maxDate$ | async\" [formGroup]=\"range\" [rangePicker]=\"picker\">\n    <input matStartDate formControlName=\"start\" placeholder=\"Start date\" />\n    <input matEndDate formControlName=\"end\" placeholder=\"End date\" />\n  </mat-date-range-input>\n  <mat-datepicker-toggle matIconSuffix [for]=\"picker\"></mat-datepicker-toggle>\n  <div *ngIf=\"showCustomize\">\n    <dbx-button-spacer></dbx-button-spacer>\n    <ng-content select=\"[customizeButton]\"></ng-content>\n  </div>\n  <mat-date-range-picker #picker (opened)=\"pickerOpened()\" (closed)=\"pickerClosed()\"></mat-date-range-picker>\n  <mat-error *ngIf=\"range.controls.start.hasError('matStartDateInvalid')\">Invalid start date</mat-error>\n  <mat-error *ngIf=\"range.controls.end.hasError('matEndDateInvalid')\">Invalid end date</mat-error>\n</mat-form-field>\n"]}

package/esm2020/calendar/lib/calendar.schedule.selection.store.mjs

@@ -0,0 +1,294 @@
+import { Injectable } from '@angular/core';
+import { dateBlockDayOfWeekFactory, dateBlockTimingDateFactory, dateScheduleDateFilter, DateScheduleDayCode, dateScheduleDayCodes, dateScheduleEncodedWeek, dateTimingRelativeIndexFactory, expandDateScheduleDayCodesToDayOfWeekSet, findMaxDate, findMinDate, isDateInDateRangeFunction, isDateWithinDateBlockRangeFunction, isSameDate, isSameDateDay, isSameDateRange, isSameDateScheduleRange } from '@dereekb/date';
+import { filterMaybe } from '@dereekb/rxjs';
+import { iterableToArray, addToSet, toggleInSet, isIndexNumberInIndexRangeFunction, minAndMaxNumber, setsAreEquivalent, range } from '@dereekb/util';
+import { ComponentStore } from '@ngrx/component-store';
+import { addYears, startOfDay, startOfYear } from 'date-fns';
+import { distinctUntilChanged, map, shareReplay } from 'rxjs';
+import { defaultCalendarScheduleSelectionCellContentFactory } from './calendar.schedule.selection';
+import * as i0 from "@angular/core";
+export function initialCalendarScheduleSelectionState() {
+    const start = startOfDay(new Date());
+    const scheduleDays = new Set([DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);
+    const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));
+    const indexFactory = dateTimingRelativeIndexFactory({ start });
+    const indexDayOfWeek = dateBlockDayOfWeekFactory(start);
+    return {
+        start,
+        indexFactory,
+        selectedIndexes: new Set(),
+        scheduleDays,
+        allowedDaysOfWeek,
+        indexDayOfWeek,
+        isEnabledFilterDay: () => true,
+        isEnabledDay: () => false,
+        minDate: new Date(0),
+        maxDate: startOfYear(addYears(new Date(), 100)),
+        cellContentFactory: defaultCalendarScheduleSelectionCellContentFactory
+    };
+}
+export class DbxCalendarScheduleSelectionStore extends ComponentStore {
+    constructor() {
+        super(initialCalendarScheduleSelectionState());
+        // MARK: Accessors
+        this.filter$ = this.state$.pipe(map((x) => x.filter), distinctUntilChanged(), shareReplay(1));
+        this.inputStart$ = this.state$.pipe(map((x) => x.inputStart), distinctUntilChanged(isSameDate), shareReplay(1));
+        this.inputEnd$ = this.state$.pipe(map((x) => x.inputEnd), distinctUntilChanged(isSameDate), shareReplay(1));
+        this.currentInputRange$ = this.state$.pipe(map(({ inputStart, inputEnd }) => ({ inputStart, inputEnd })), distinctUntilChanged((a, b) => isSameDate(a.inputStart, b.inputStart) && isSameDate(a.inputEnd, b.inputEnd)), map((x) => {
+            if (x.inputStart && x.inputEnd) {
+                return x;
+            }
+            else {
+                return undefined;
+            }
+        }), shareReplay(1));
+        this.inputRange$ = this.currentInputRange$.pipe(filterMaybe(), shareReplay(1));
+        this.selectedDates$ = this.state$.pipe(map((x) => x.selectedIndexes), distinctUntilChanged(), shareReplay(1));
+        this.isEnabledFilterDayFunction$ = this.state$.pipe(map((x) => x.isEnabledFilterDay), shareReplay(1));
+        this.isEnabledDayFunction$ = this.state$.pipe(map((x) => x.isEnabledDay), shareReplay(1));
+        this.currentDateRange$ = this.state$.pipe(map(computeCalendarScheduleSelectionRange), distinctUntilChanged((a, b) => isSameDateRange(a, b)), shareReplay(1));
+        this.dateRange$ = this.currentDateRange$.pipe(filterMaybe(), shareReplay(1));
+        this.scheduleDays$ = this.state$.pipe(map((x) => x.scheduleDays), distinctUntilChanged(setsAreEquivalent), shareReplay(1));
+        this.currentSelectionValue$ = this.state$.pipe(map((x) => x.currentSelectionValue), shareReplay(1));
+        this.selectionValue$ = this.currentSelectionValue$.pipe(filterMaybe(), shareReplay(1));
+        this.currentDateScheduleRangeValue$ = this.currentSelectionValue$.pipe(map((x) => x?.dateScheduleRange), distinctUntilChanged(isSameDateScheduleRange), shareReplay(1));
+        this.dateScheduleRangeValue$ = this.currentDateScheduleRangeValue$.pipe(filterMaybe(), shareReplay(1));
+        this.minDate$ = this.state$.pipe(map((x) => findMaxDate([x.filter?.start, x.minDate])), distinctUntilChanged(isSameDateDay), shareReplay(1));
+        this.maxDate$ = this.state$.pipe(map((x) => findMinDate([x.filter?.end, x.maxDate])), distinctUntilChanged(isSameDateDay), shareReplay(1));
+        this.cellContentFactory$ = this.state$.pipe(map((x) => x.cellContentFactory), distinctUntilChanged(), shareReplay(1));
+        this.isCustomized$ = this.state$.pipe(map((x) => x.selectedIndexes.size > 0), distinctUntilChanged(), shareReplay(1));
+        // MARK: State Changes
+        this.setFilter = this.updater((state, filter) => updateStateWithFilter(state, filter));
+        this.clearFilter = this.updater((state) => updateStateWithFilter(state, undefined));
+        this.setTimezone = this.updater((state, timezone) => ({ ...state, timezone }));
+        this.setInputRange = this.updater((state, range) => updateStateWithChangedRange(state, range));
+        this.toggleSelectedDates = this.updater((state, toggle) => updateStateWithChangedDates(state, { toggle }));
+        this.addSelectedDates = this.updater((state, add) => updateStateWithChangedDates(state, { add }));
+        this.removeSelectedDates = this.updater((state, remove) => updateStateWithChangedDates(state, { remove }));
+        this.setSelectedDates = this.updater((state, set) => updateStateWithChangedDates(state, { set }));
+        this.setScheduleDays = this.updater((state, scheduleDays) => updateStateWithChangedScheduleDays(state, scheduleDays));
+        this.setAllowAllScheduleDays = this.updater((state) => updateStateWithChangedScheduleDays(state, null));
+        this.setDateScheduleRangeValue = this.updater((state, value) => updateStateWithDateScheduleRangeValue(state, value));
+        this.setCellContentFactory = this.updater((state, cellContentFactory) => ({ ...state, cellContentFactory }));
+    }
+}
+DbxCalendarScheduleSelectionStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DbxCalendarScheduleSelectionStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+export function updateStateWithFilter(state, filter) {
+    let isEnabledFilterDay = () => true;
+    if (filter) {
+        isEnabledFilterDay = dateScheduleDateFilter(filter);
+    }
+    return { ...state, filter, isEnabledFilterDay };
+}
+export function updateStateWithDateScheduleRangeValue(state, change) {
+    const isSameValue = isSameDateScheduleRange(state.currentSelectionValue?.dateScheduleRange, change);
+    if (isSameValue) {
+        return state;
+    }
+    else {
+        if (change != null) {
+            const nextState = { ...state, inputStart: change.start, inputEnd: change.end, selectedIndexes: new Set(change.ex) };
+            return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), dateScheduleDayCodes(change.w));
+        }
+        else {
+            return noSelectionCalendarScheduleSelectionState(state); // clear selection, retain disabled days
+        }
+    }
+}
+export function updateStateWithChangedScheduleDays(state, change) {
+    const { scheduleDays: currentScheduleDays } = state;
+    const scheduleDays = new Set(change || [DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);
+    if (setsAreEquivalent(currentScheduleDays, scheduleDays)) {
+        return state; // no change
+    }
+    else {
+        const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));
+        const nextState = { ...state, scheduleDays, allowedDaysOfWeek };
+        return finalizeNewCalendarScheduleSelectionState(nextState);
+    }
+}
+export function updateStateWithChangedDates(state, change) {
+    const { indexFactory, allowedDaysOfWeek, indexDayOfWeek } = state;
+    let selectedIndexes;
+    if (change.set) {
+        selectedIndexes = new Set(iterableToArray(change.set).map(indexFactory));
+    }
+    else {
+        selectedIndexes = new Set(state.selectedIndexes);
+        if (change.toggle) {
+            const allowedToToggle = iterableToArray(change.toggle)
+                .map(indexFactory)
+                .filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+            toggleInSet(selectedIndexes, allowedToToggle);
+        }
+        if (change.add) {
+            addToSet(selectedIndexes, iterableToArray(change.add).map(indexFactory));
+        }
+        if (change.remove) {
+            addToSet(selectedIndexes, iterableToArray(change.remove).map(indexFactory));
+        }
+    }
+    const nextState = { ...state, selectedIndexes };
+    nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
+    // Recalculate the range and simplified to exclusions
+    const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);
+    if (rangeAndExclusion) {
+        return finalizeNewCalendarScheduleSelectionState({ ...nextState, selectedIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });
+    }
+    else {
+        // no selected days
+        return noSelectionCalendarScheduleSelectionState(state);
+    }
+}
+export function noSelectionCalendarScheduleSelectionState(state) {
+    return finalizeNewCalendarScheduleSelectionState({ ...state, selectedIndexes: new Set(), inputStart: null, inputEnd: null });
+}
+export function updateStateWithChangedRange(state, change) {
+    const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory, minDate, maxDate } = state;
+    const inputStart = startOfDay(change.inputStart);
+    const inputEnd = startOfDay(change.inputEnd);
+    const isValidRange = minDate != null || maxDate != null ? isDateInDateRangeFunction({ start: minDate ?? undefined, end: maxDate ?? undefined }) : () => true;
+    if (!isValidRange(inputStart) || !isValidRange(inputEnd) || (isSameDateDay(inputStart, currentInputStart) && isSameDateDay(inputEnd, currentInputEnd))) {
+        return state; // if no change, return the current state.
+    }
+    // retain all indexes that are within the new range
+    const minIndex = indexFactory(inputStart);
+    const maxIndex = indexFactory(inputEnd) + 1;
+    const currentIndexes = Array.from(state.selectedIndexes);
+    const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });
+    const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);
+    const nextState = { ...state, excludedIndexesInNewRange, inputStart, inputEnd };
+    return finalizeNewCalendarScheduleSelectionState(nextState);
+}
+export function finalizeNewCalendarScheduleSelectionState(nextState) {
+    nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
+    nextState.currentSelectionValue = computeScheduleSelectionValue(nextState);
+    return nextState;
+}
+export function isEnabledDayInCalendarScheduleSelectionState(state) {
+    const { indexFactory, inputStart, inputEnd, indexDayOfWeek, allowedDaysOfWeek } = state;
+    let isInStartAndEndRange;
+    if (inputStart && inputEnd) {
+        isInStartAndEndRange = isDateWithinDateBlockRangeFunction({ start: state.start, range: { start: inputStart, end: inputEnd } });
+    }
+    else {
+        isInStartAndEndRange = () => false;
+    }
+    return (input) => {
+        const index = indexFactory(input);
+        const dayOfWeek = indexDayOfWeek(index);
+        const isInSelectedRange = isInStartAndEndRange(input);
+        const isSelected = state.selectedIndexes.has(index);
+        const isAllowedDayOfWeek = allowedDaysOfWeek.has(dayOfWeek);
+        const result = isAllowedDayOfWeek && ((isInSelectedRange && !isSelected) || (isSelected && !isInSelectedRange));
+        return result;
+    };
+}
+export function computeScheduleSelectionValue(state) {
+    const { scheduleDays, allowedDaysOfWeek, indexDayOfWeek } = state;
+    const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(state);
+    if (rangeAndExclusion == null) {
+        return null;
+    }
+    const { start, end, excluded, dateBlockRange } = rangeAndExclusion;
+    const indexOffset = dateBlockRange.i;
+    const ex = excluded
+        .filter((x) => {
+        const isExcludedIndex = allowedDaysOfWeek.has(indexDayOfWeek(x));
+        return isExcludedIndex;
+    })
+        .map((x) => x - indexOffset); // set to the proper offset
+    const w = dateScheduleEncodedWeek(scheduleDays);
+    const d = []; // "included" blocks are never used/calculated.
+    const dateScheduleRange = {
+        start,
+        end,
+        w,
+        d,
+        ex
+    };
+    return {
+        dateScheduleRange,
+        minMaxRange: { start, end }
+    };
+}
+export function computeScheduleSelectionRangeAndExclusion(state) {
+    const { isEnabledDay } = state;
+    const dateFactory = dateBlockTimingDateFactory(state);
+    const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);
+    if (dateBlockRange == null) {
+        return null; // returns null if no items are selected.
+    }
+    const start = dateFactory(dateBlockRange.i);
+    const end = dateFactory(dateBlockRange.to);
+    const excluded = range(dateBlockRange.i, dateBlockRange.to + 1).filter((x) => {
+        const isExcludedIndex = !isEnabledDay(x);
+        return isExcludedIndex;
+    });
+    const result = {
+        dateBlockRange,
+        start,
+        end,
+        excluded
+    };
+    return result;
+}
+export function computeCalendarScheduleSelectionRange(state) {
+    const dateFactory = dateBlockTimingDateFactory(state);
+    const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);
+    if (dateBlockRange != null) {
+        return { start: dateFactory(dateBlockRange.i), end: dateFactory(dateBlockRange.to) };
+    }
+    else {
+        return undefined;
+    }
+}
+export function computeCalendarScheduleSelectionDateBlockRange(state) {
+    const { indexFactory, inputStart, inputEnd, allowedDaysOfWeek, indexDayOfWeek, isEnabledDay, isEnabledFilterDay } = state;
+    const enabledSelectedIndexes = Array.from(state.selectedIndexes).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+    const minAndMaxSelectedValues = minAndMaxNumber(enabledSelectedIndexes);
+    let startRange;
+    let endRange;
+    if (minAndMaxSelectedValues) {
+        startRange = minAndMaxSelectedValues.min;
+        endRange = minAndMaxSelectedValues.max;
+    }
+    if (inputStart != null && inputEnd != null) {
+        const inputStartIndex = indexFactory(inputStart);
+        const inputEndIndex = indexFactory(inputEnd);
+        startRange = startRange != null ? Math.min(inputStartIndex, startRange) : inputStartIndex;
+        endRange = endRange != null ? Math.max(inputEndIndex, endRange) : inputEndIndex;
+    }
+    if (startRange != null && endRange != null) {
+        const scanStartIndex = startRange;
+        const scanEndIndex = endRange;
+        // clear start and end
+        startRange = undefined;
+        endRange = undefined;
+        // if the min is equal to the start index, then we are in the range and need to iterate dates until we find one that is not selected/excluded.
+        for (let i = scanStartIndex; i <= scanEndIndex; i += 1) {
+            if (isEnabledFilterDay(i) && isEnabledDay(i)) {
+                startRange = i;
+                break;
+            }
+        }
+        // same with the max
+        for (let i = scanEndIndex; i >= scanStartIndex; i -= 1) {
+            if (isEnabledFilterDay(i) && isEnabledDay(i)) {
+                endRange = i;
+                break;
+            }
+        }
+    }
+    if (startRange != null && endRange != null) {
+        return { i: startRange, to: endRange };
+    }
+    else {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.schedule.selection.store.js","sourceRoot":"","sources":["../../../../../../packages/dbx-form/calendar/src/lib/calendar.schedule.selection.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  DateBlockDayOfWeekFactory,\n  dateBlockDayOfWeekFactory,\n  DateBlockIndex,\n  DateBlockRangeWithRange,\n  dateBlockTimingDateFactory,\n  DateOrDateBlockIndex,\n  DateRange,\n  dateScheduleDateFilter,\n  DateScheduleDateFilterConfig,\n  DateScheduleDayCode,\n  dateScheduleDayCodes,\n  dateScheduleEncodedWeek,\n  DateScheduleEncodedWeek,\n  DateScheduleRange,\n  DateTimingRelativeIndexFactory,\n  dateTimingRelativeIndexFactory,\n  expandDateScheduleDayCodesToDayOfWeekSet,\n  findMaxDate,\n  findMinDate,\n  isDateInDateRangeFunction,\n  IsDateWithinDateBlockRangeFunction,\n  isDateWithinDateBlockRangeFunction,\n  isSameDate,\n  isSameDateDay,\n  isSameDateRange,\n  isSameDateScheduleRange\n} from '@dereekb/date';\nimport { filterMaybe } from '@dereekb/rxjs';\nimport { Maybe, TimezoneString, DecisionFunction, IterableOrValue, iterableToArray, addToSet, toggleInSet, isIndexNumberInIndexRangeFunction, MaybeMap, minAndMaxNumber, setsAreEquivalent, DayOfWeek, range } from '@dereekb/util';\nimport { ComponentStore } from '@ngrx/component-store';\nimport { addYears, startOfDay, startOfYear } from 'date-fns';\nimport { Observable, distinctUntilChanged, map, shareReplay } from 'rxjs';\nimport { CalendarScheduleSelectionCellContentFactory, CalendarScheduleSelectionValue, defaultCalendarScheduleSelectionCellContentFactory } from './calendar.schedule.selection';\n\nexport interface CalendarScheduleSelectionInputDateRange {\n  /**\n   * Input Start Date\n   */\n  inputStart: Date;\n  /**\n   * Input End Date\n   */\n  inputEnd: Date;\n}\n\nexport type PartialCalendarScheduleSelectionInputDateRange = Partial<MaybeMap<CalendarScheduleSelectionInputDateRange>>;\n\nexport interface CalendarScheduleSelectionState extends PartialCalendarScheduleSelectionInputDateRange {\n  /**\n   * Filters the days of the schedule to only allow selecting days in the schedule.\n   */\n  filter?: Maybe<DateScheduleDateFilterConfig>;\n  /**\n   * Minimum date allowed if no filter is set. If a filter is set, the greater of the two dates is used as the minimum.\n   */\n  minDate?: Maybe<Date>;\n  /**\n   * Maximum date allowed if no fitler is set. If a filter is set, the lesser of the two dates is used as the maximum.\n   */\n  maxDate?: Maybe<Date>;\n  /**\n   * Start date. Is updated as the inputStart is modified or filter is provided that provides the start date.\n   *\n   * Defaults to today and the current timezone.\n   */\n  start: Date;\n  /**\n   * DateTimingRelativeIndexFactory\n   */\n  indexFactory: DateTimingRelativeIndexFactory;\n  /**\n   * Array of manually selected dates.\n   *\n   * Values that exist outside of the \"input\" range are considered toggled on, while those\n   * that are selected within the range are considered toggled off.\n   *\n   * If dates are selected, and then a range is selected, then those dates within the range that fall\n   * within the range are cleared from selection.\n   *\n   * These indexes are relative to the start date.\n   */\n  selectedIndexes: Set<DateBlockIndex>;\n  /**\n   * Days of the schedule that are allowed to be picked.\n   */\n  scheduleDays: Set<DateScheduleDayCode>;\n  /**\n   * Set of the days of week that are allowed.\n   */\n  allowedDaysOfWeek: Set<DayOfWeek>;\n  /**\n   *\n   */\n  indexDayOfWeek: DateBlockDayOfWeekFactory;\n  /**\n   * Decision function that returns true if a value is enabled given the current filter.\n   */\n  isEnabledFilterDay: DecisionFunction<DateOrDateBlockIndex>;\n  /**\n   * Decision function that returns true if a value is enabled.\n   *\n   * This function does not take the current filter into account.\n   */\n  isEnabledDay: DecisionFunction<DateOrDateBlockIndex>;\n  /**\n   * CalendarScheduleSelectionCellContentFactory for the view.\n   */\n  cellContentFactory: CalendarScheduleSelectionCellContentFactory;\n  /**\n   * Current selection value.\n   */\n  currentSelectionValue?: Maybe<CalendarScheduleSelectionValue>;\n}\n\nexport function initialCalendarScheduleSelectionState(): CalendarScheduleSelectionState {\n  const start = startOfDay(new Date());\n  const scheduleDays = new Set([DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);\n  const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));\n  const indexFactory = dateTimingRelativeIndexFactory({ start });\n  const indexDayOfWeek = dateBlockDayOfWeekFactory(start);\n\n  return {\n    start,\n    indexFactory,\n    selectedIndexes: new Set(),\n    scheduleDays,\n    allowedDaysOfWeek,\n    indexDayOfWeek,\n    isEnabledFilterDay: () => true,\n    isEnabledDay: () => false,\n    minDate: new Date(0),\n    maxDate: startOfYear(addYears(new Date(), 100)),\n    cellContentFactory: defaultCalendarScheduleSelectionCellContentFactory\n  };\n}\n\n@Injectable()\nexport class DbxCalendarScheduleSelectionStore extends ComponentStore<CalendarScheduleSelectionState> {\n  constructor() {\n    super(initialCalendarScheduleSelectionState());\n  }\n\n  // MARK: Accessors\n  readonly filter$ = this.state$.pipe(\n    map((x) => x.filter),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputStart$ = this.state$.pipe(\n    map((x) => x.inputStart),\n    distinctUntilChanged(isSameDate),\n    shareReplay(1)\n  );\n\n  readonly inputEnd$ = this.state$.pipe(\n    map((x) => x.inputEnd),\n    distinctUntilChanged(isSameDate),\n    shareReplay(1)\n  );\n\n  readonly currentInputRange$: Observable<Maybe<CalendarScheduleSelectionInputDateRange>> = this.state$.pipe(\n    map(({ inputStart, inputEnd }) => ({ inputStart, inputEnd })),\n    distinctUntilChanged((a, b) => isSameDate(a.inputStart, b.inputStart) && isSameDate(a.inputEnd, b.inputEnd)),\n    map((x) => {\n      if (x.inputStart && x.inputEnd) {\n        return x as CalendarScheduleSelectionInputDateRange;\n      } else {\n        return undefined;\n      }\n    }),\n    shareReplay(1)\n  );\n\n  readonly inputRange$: Observable<CalendarScheduleSelectionInputDateRange> = this.currentInputRange$.pipe(filterMaybe(), shareReplay(1));\n\n  readonly selectedDates$: Observable<Set<DateBlockIndex>> = this.state$.pipe(\n    map((x) => x.selectedIndexes),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly isEnabledFilterDayFunction$: Observable<DecisionFunction<DateOrDateBlockIndex>> = this.state$.pipe(\n    map((x) => x.isEnabledFilterDay),\n    shareReplay(1)\n  );\n\n  readonly isEnabledDayFunction$: Observable<DecisionFunction<DateOrDateBlockIndex>> = this.state$.pipe(\n    map((x) => x.isEnabledDay),\n    shareReplay(1)\n  );\n\n  readonly currentDateRange$: Observable<Maybe<DateRange>> = this.state$.pipe(\n    map(computeCalendarScheduleSelectionRange),\n    distinctUntilChanged((a, b) => isSameDateRange(a, b)),\n    shareReplay(1)\n  );\n\n  readonly dateRange$: Observable<DateRange> = this.currentDateRange$.pipe(filterMaybe(), shareReplay(1));\n\n  readonly scheduleDays$: Observable<Set<DateScheduleDayCode>> = this.state$.pipe(\n    map((x) => x.scheduleDays),\n    distinctUntilChanged(setsAreEquivalent),\n    shareReplay(1)\n  );\n\n  readonly currentSelectionValue$ = this.state$.pipe(\n    map((x) => x.currentSelectionValue),\n    shareReplay(1)\n  );\n  readonly selectionValue$ = this.currentSelectionValue$.pipe(filterMaybe(), shareReplay(1));\n\n  readonly currentDateScheduleRangeValue$ = this.currentSelectionValue$.pipe(\n    map((x) => x?.dateScheduleRange),\n    distinctUntilChanged(isSameDateScheduleRange),\n    shareReplay(1)\n  );\n  readonly dateScheduleRangeValue$ = this.currentDateScheduleRangeValue$.pipe(filterMaybe(), shareReplay(1));\n\n  readonly minDate$ = this.state$.pipe(\n    map((x) => findMaxDate([x.filter?.start, x.minDate])),\n    distinctUntilChanged(isSameDateDay),\n    shareReplay(1)\n  );\n\n  readonly maxDate$ = this.state$.pipe(\n    map((x) => findMinDate([x.filter?.end, x.maxDate])),\n    distinctUntilChanged(isSameDateDay),\n    shareReplay(1)\n  );\n\n  readonly cellContentFactory$ = this.state$.pipe(\n    map((x) => x.cellContentFactory),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly isCustomized$ = this.state$.pipe(\n    map((x) => x.selectedIndexes.size > 0),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  // MARK: State Changes\n  readonly setFilter = this.updater((state, filter: Maybe<DateScheduleDateFilterConfig>) => updateStateWithFilter(state, filter));\n  readonly clearFilter = this.updater((state) => updateStateWithFilter(state, undefined));\n\n  readonly setTimezone = this.updater((state, timezone: Maybe<TimezoneString>) => ({ ...state, timezone }));\n  readonly setInputRange = this.updater((state, range: CalendarScheduleSelectionInputDateRange) => updateStateWithChangedRange(state, range));\n\n  readonly toggleSelectedDates = this.updater((state, toggle: IterableOrValue<DateOrDateBlockIndex>) => updateStateWithChangedDates(state, { toggle }));\n  readonly addSelectedDates = this.updater((state, add: IterableOrValue<DateOrDateBlockIndex>) => updateStateWithChangedDates(state, { add }));\n  readonly removeSelectedDates = this.updater((state, remove: IterableOrValue<DateOrDateBlockIndex>) => updateStateWithChangedDates(state, { remove }));\n  readonly setSelectedDates = this.updater((state, set: IterableOrValue<DateOrDateBlockIndex>) => updateStateWithChangedDates(state, { set }));\n\n  readonly setScheduleDays = this.updater((state, scheduleDays: Iterable<DateScheduleDayCode>) => updateStateWithChangedScheduleDays(state, scheduleDays));\n  readonly setAllowAllScheduleDays = this.updater((state) => updateStateWithChangedScheduleDays(state, null));\n\n  readonly setDateScheduleRangeValue = this.updater((state, value: Maybe<DateScheduleRange>) => updateStateWithDateScheduleRangeValue(state, value));\n  readonly setCellContentFactory = this.updater((state, cellContentFactory: CalendarScheduleSelectionCellContentFactory) => ({ ...state, cellContentFactory }));\n}\n\nexport function updateStateWithFilter(state: CalendarScheduleSelectionState, filter: Maybe<DateScheduleDateFilterConfig>): CalendarScheduleSelectionState {\n  let isEnabledFilterDay: Maybe<DecisionFunction<DateOrDateBlockIndex>> = () => true;\n\n  if (filter) {\n    isEnabledFilterDay = dateScheduleDateFilter(filter);\n  }\n\n  return { ...state, filter, isEnabledFilterDay };\n}\n\nexport function updateStateWithDateScheduleRangeValue(state: CalendarScheduleSelectionState, change: Maybe<DateScheduleRange>): CalendarScheduleSelectionState {\n  const isSameValue = isSameDateScheduleRange(state.currentSelectionValue?.dateScheduleRange, change);\n\n  if (isSameValue) {\n    return state;\n  } else {\n    if (change != null) {\n      const nextState: CalendarScheduleSelectionState = { ...state, inputStart: change.start, inputEnd: change.end, selectedIndexes: new Set(change.ex) };\n      return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), dateScheduleDayCodes(change.w));\n    } else {\n      return noSelectionCalendarScheduleSelectionState(state); // clear selection, retain disabled days\n    }\n  }\n}\n\nexport function updateStateWithChangedScheduleDays(state: CalendarScheduleSelectionState, change: Maybe<Iterable<DateScheduleDayCode>>): CalendarScheduleSelectionState {\n  const { scheduleDays: currentScheduleDays } = state;\n  const scheduleDays = new Set(change || [DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);\n\n  if (setsAreEquivalent(currentScheduleDays, scheduleDays)) {\n    return state; // no change\n  } else {\n    const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));\n    const nextState = { ...state, scheduleDays, allowedDaysOfWeek };\n    return finalizeNewCalendarScheduleSelectionState(nextState);\n  }\n}\n\nexport interface CalendarScheduleSelectionStateDatesChange {\n  toggle?: IterableOrValue<DateOrDateBlockIndex>;\n  add?: IterableOrValue<DateOrDateBlockIndex>;\n  remove?: IterableOrValue<DateOrDateBlockIndex>;\n  set?: IterableOrValue<DateOrDateBlockIndex>;\n}\n\nexport function updateStateWithChangedDates(state: CalendarScheduleSelectionState, change: CalendarScheduleSelectionStateDatesChange): CalendarScheduleSelectionState {\n  const { indexFactory, allowedDaysOfWeek, indexDayOfWeek } = state;\n  let selectedIndexes: Set<DateBlockIndex>;\n\n  if (change.set) {\n    selectedIndexes = new Set(iterableToArray(change.set).map(indexFactory));\n  } else {\n    selectedIndexes = new Set(state.selectedIndexes);\n\n    if (change.toggle) {\n      const allowedToToggle = iterableToArray(change.toggle)\n        .map(indexFactory)\n        .filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));\n      toggleInSet(selectedIndexes, allowedToToggle);\n    }\n\n    if (change.add) {\n      addToSet(selectedIndexes, iterableToArray(change.add).map(indexFactory));\n    }\n\n    if (change.remove) {\n      addToSet(selectedIndexes, iterableToArray(change.remove).map(indexFactory));\n    }\n  }\n\n  const nextState = { ...state, selectedIndexes };\n  nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);\n\n  // Recalculate the range and simplified to exclusions\n  const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);\n\n  if (rangeAndExclusion) {\n    return finalizeNewCalendarScheduleSelectionState({ ...nextState, selectedIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });\n  } else {\n    // no selected days\n    return noSelectionCalendarScheduleSelectionState(state);\n  }\n}\n\nexport function noSelectionCalendarScheduleSelectionState(state: CalendarScheduleSelectionState): CalendarScheduleSelectionState {\n  return finalizeNewCalendarScheduleSelectionState({ ...state, selectedIndexes: new Set(), inputStart: null, inputEnd: null });\n}\n\nexport function updateStateWithChangedRange(state: CalendarScheduleSelectionState, change: CalendarScheduleSelectionInputDateRange): CalendarScheduleSelectionState {\n  const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory, minDate, maxDate } = state;\n\n  const inputStart = startOfDay(change.inputStart);\n  const inputEnd = startOfDay(change.inputEnd);\n\n  const isValidRange = minDate != null || maxDate != null ? isDateInDateRangeFunction({ start: minDate ?? undefined, end: maxDate ?? undefined }) : () => true;\n\n  if (!isValidRange(inputStart) || !isValidRange(inputEnd) || (isSameDateDay(inputStart, currentInputStart) && isSameDateDay(inputEnd, currentInputEnd))) {\n    return state; // if no change, return the current state.\n  }\n\n  // retain all indexes that are within the new range\n  const minIndex = indexFactory(inputStart);\n  const maxIndex = indexFactory(inputEnd) + 1;\n\n  const currentIndexes: DateBlockIndex[] = Array.from(state.selectedIndexes);\n  const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });\n  const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);\n\n  const nextState = { ...state, excludedIndexesInNewRange, inputStart, inputEnd };\n  return finalizeNewCalendarScheduleSelectionState(nextState);\n}\n\nexport function finalizeNewCalendarScheduleSelectionState(nextState: CalendarScheduleSelectionState): CalendarScheduleSelectionState {\n  nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);\n  nextState.currentSelectionValue = computeScheduleSelectionValue(nextState);\n  return nextState;\n}\n\nexport function isEnabledDayInCalendarScheduleSelectionState(state: CalendarScheduleSelectionState): DecisionFunction<DateOrDateBlockIndex> {\n  const { indexFactory, inputStart, inputEnd, indexDayOfWeek, allowedDaysOfWeek } = state;\n\n  let isInStartAndEndRange: IsDateWithinDateBlockRangeFunction;\n\n  if (inputStart && inputEnd) {\n    isInStartAndEndRange = isDateWithinDateBlockRangeFunction({ start: state.start, range: { start: inputStart, end: inputEnd } });\n  } else {\n    isInStartAndEndRange = () => false;\n  }\n\n  return (input: DateOrDateBlockIndex) => {\n    const index = indexFactory(input);\n    const dayOfWeek = indexDayOfWeek(index);\n\n    const isInSelectedRange = isInStartAndEndRange(input);\n    const isSelected = state.selectedIndexes.has(index);\n    const isAllowedDayOfWeek = allowedDaysOfWeek.has(dayOfWeek);\n\n    const result = isAllowedDayOfWeek && ((isInSelectedRange && !isSelected) || (isSelected && !isInSelectedRange));\n    return result;\n  };\n}\n\nexport function computeScheduleSelectionValue(state: CalendarScheduleSelectionState): Maybe<CalendarScheduleSelectionValue> {\n  const { scheduleDays, allowedDaysOfWeek, indexDayOfWeek } = state;\n  const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(state);\n\n  if (rangeAndExclusion == null) {\n    return null;\n  }\n\n  const { start, end, excluded, dateBlockRange } = rangeAndExclusion;\n  const indexOffset = dateBlockRange.i;\n\n  const ex: DateBlockIndex[] = excluded\n    .filter((x) => {\n      const isExcludedIndex = allowedDaysOfWeek.has(indexDayOfWeek(x));\n      return isExcludedIndex;\n    })\n    .map((x) => x - indexOffset); // set to the proper offset\n\n  const w: DateScheduleEncodedWeek = dateScheduleEncodedWeek(scheduleDays);\n  const d: DateBlockIndex[] = []; // \"included\" blocks are never used/calculated.\n\n  const dateScheduleRange: DateScheduleRange = {\n    start,\n    end,\n    w,\n    d,\n    ex\n  };\n\n  return {\n    dateScheduleRange,\n    minMaxRange: { start, end }\n  };\n}\n\nexport interface CalendarScheduleSelectionRangeAndExclusion extends DateRange {\n  dateBlockRange: DateBlockRangeWithRange;\n  excluded: DateBlockIndex[];\n}\n\nexport function computeScheduleSelectionRangeAndExclusion(state: CalendarScheduleSelectionState): Maybe<CalendarScheduleSelectionRangeAndExclusion> {\n  const { isEnabledDay } = state;\n  const dateFactory = dateBlockTimingDateFactory(state);\n  const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);\n\n  if (dateBlockRange == null) {\n    return null; // returns null if no items are selected.\n  }\n\n  const start = dateFactory(dateBlockRange.i);\n  const end = dateFactory(dateBlockRange.to);\n\n  const excluded: DateBlockIndex[] = range(dateBlockRange.i, dateBlockRange.to + 1).filter((x) => {\n    const isExcludedIndex = !isEnabledDay(x);\n    return isExcludedIndex;\n  });\n\n  const result: CalendarScheduleSelectionRangeAndExclusion = {\n    dateBlockRange,\n    start,\n    end,\n    excluded\n  };\n\n  return result;\n}\n\nexport function computeCalendarScheduleSelectionRange(state: CalendarScheduleSelectionState): Maybe<DateRange> {\n  const dateFactory = dateBlockTimingDateFactory(state);\n  const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);\n\n  if (dateBlockRange != null) {\n    return { start: dateFactory(dateBlockRange.i), end: dateFactory(dateBlockRange.to as number) };\n  } else {\n    return undefined;\n  }\n}\n\nexport function computeCalendarScheduleSelectionDateBlockRange(state: CalendarScheduleSelectionState): Maybe<DateBlockRangeWithRange> {\n  const { indexFactory, inputStart, inputEnd, allowedDaysOfWeek, indexDayOfWeek, isEnabledDay, isEnabledFilterDay } = state;\n  const enabledSelectedIndexes = Array.from(state.selectedIndexes).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));\n  const minAndMaxSelectedValues = minAndMaxNumber(enabledSelectedIndexes);\n\n  let startRange: Maybe<DateBlockIndex>;\n  let endRange: Maybe<DateBlockIndex>;\n\n  if (minAndMaxSelectedValues) {\n    startRange = minAndMaxSelectedValues.min;\n    endRange = minAndMaxSelectedValues.max;\n  }\n\n  if (inputStart != null && inputEnd != null) {\n    const inputStartIndex = indexFactory(inputStart);\n    const inputEndIndex = indexFactory(inputEnd);\n\n    startRange = startRange != null ? Math.min(inputStartIndex, startRange) : inputStartIndex;\n    endRange = endRange != null ? Math.max(inputEndIndex, endRange) : inputEndIndex;\n  }\n\n  if (startRange != null && endRange != null) {\n    const scanStartIndex = startRange;\n    const scanEndIndex = endRange;\n\n    // clear start and end\n    startRange = undefined;\n    endRange = undefined;\n\n    // if the min is equal to the start index, then we are in the range and need to iterate dates until we find one that is not selected/excluded.\n    for (let i = scanStartIndex; i <= scanEndIndex; i += 1) {\n      if (isEnabledFilterDay(i) && isEnabledDay(i)) {\n        startRange = i;\n        break;\n      }\n    }\n\n    // same with the max\n    for (let i = scanEndIndex; i >= scanStartIndex; i -= 1) {\n      if (isEnabledFilterDay(i) && isEnabledDay(i)) {\n        endRange = i;\n        break;\n      }\n    }\n  }\n\n  if (startRange != null && endRange != null) {\n    return { i: startRange, to: endRange };\n  } else {\n    return undefined;\n  }\n}\n"]}