@updevs/components 1.0.0-alpha.3 → 1.0.0-alpha.30

package/calendar/components/calendar-body/calendar-body.component.d.ts

@@ -0,0 +1,263 @@
+import { EventEmitter, SimpleChanges, OnChanges, AfterViewChecked, OnDestroy } from '@angular/core';
+import { OptionalType } from '@updevs/sdk/types';
+import { CalendarCellModel } from '../../models/calendar-cell.model';
+import { CalendarUserEventModel } from '../../models/calendar-user-event.model';
+import * as i0 from "@angular/core";
+export declare class CalendarBodyComponent implements OnChanges, AfterViewChecked, OnDestroy {
+    /**
+     * The label for the table. (e.g. "Jan 2017").
+     */
+    label: string;
+    /**
+     * The cells to display in the table.
+     */
+    rows: CalendarCellModel[][];
+    /**
+     * The value in the table that corresponds to today.
+     */
+    todayValue?: number;
+    /**
+     * Start value of the selected date range.
+     */
+    startValue?: number;
+    /**
+     * End value of the selected date range.
+     */
+    endValue?: number;
+    /**
+     * The minimum number of free cells needed to fit the label in the first row.
+     */
+    labelMinRequiredCells: number;
+    /**
+     * The number of columns in the table.
+     */
+    numCols: number;
+    /**
+     * The cell number of the active cell in the table.
+     */
+    activeCell: number;
+    /**
+     * Whether a range is being selected.
+     */
+    isRange: boolean;
+    /**
+     * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be
+     * maintained even as the table resizes.
+     */
+    cellAspectRatio: number;
+    /**
+     * Start of the comparison range.
+     */
+    comparisonStart?: number;
+    /**
+     * End of the comparison range.
+     */
+    comparisonEnd?: number;
+    /**
+     * Start of the preview range.
+     */
+    previewStart?: number;
+    /**
+     * End of the preview range.
+     */
+    previewEnd?: number;
+    /**
+     * ARIA Accessible name of the `<input updStartDate/>`
+     */
+    startDateAccessibleName?: string;
+    /**
+     * ARIA Accessible name of the `<input updEndDate/>`
+     */
+    endDateAccessibleName?: string;
+    /**
+     * Emits when a new value is selected.
+     */
+    readonly selectedValueChange: EventEmitter<CalendarUserEventModel<number>>;
+    /**
+     * Emits when the preview has changed as a result of a user action.
+     */
+    readonly previewChange: EventEmitter<CalendarUserEventModel<OptionalType<CalendarCellModel>>>;
+    /**
+     * Emits the date at the possible start of a drag event.
+     */
+    readonly dragStarted: EventEmitter<CalendarUserEventModel<Date>>;
+    /**
+     * Emits the date at the conclusion of a drag, or null if mouse was not released on a date.
+     */
+    readonly dragEnded: EventEmitter<CalendarUserEventModel<OptionalType<Date>>>;
+    /**
+     * The number of blank cells to put at the beginning for the first row.
+     */
+    firstRowOffset: number;
+    /**
+     * Padding for the individual date cells.
+     */
+    cellPadding: string;
+    /**
+     * Width of an individual cell.
+     */
+    cellWidth: string;
+    hoveredDate?: string;
+    get startDateLabelId(): string;
+    get endDateLabelId(): string;
+    get colspanClass(): string;
+    private didDragSinceMouseDown;
+    private id;
+    /**
+     * Used to skip the next focus event when rendering the preview range.
+     * We need a flag like this, because some browsers fire focus events asynchronously.
+     */
+    private skipNextFocus?;
+    /**
+     * Used to focus the active cell after change detection has run.
+     */
+    private focusActiveCellAfterViewChecked;
+    private readonly injector;
+    private readonly elementRef;
+    private readonly ngZone;
+    private readonly calendarSignalsService;
+    private readonly dateService;
+    constructor();
+    ngAfterViewChecked(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    getIndex(colIndex: number, rowIndex: number): string;
+    onDateEnter(index: string): void;
+    onDateLeave(): void;
+    /**
+     * Tracking function for rows based on their identity. Ideally we would use some sort of
+     * key on the row, but that would require a breaking change for the `rows` input. We don't
+     * use the built-in identity tracking, because it logs warnings.
+     */
+    trackRow: (row: CalendarCellModel[]) => CalendarCellModel[];
+    /**
+     * Called when a cell is clicked.
+     * @param cell
+     * @param event
+     */
+    cellClicked(cell: CalendarCellModel, event: MouseEvent): void;
+    emitActiveDateChange(cell: CalendarCellModel): void;
+    /**
+     * Returns whether a cell should be marked as selected.
+     * @param value
+     */
+    isSelected(value: number): boolean;
+    /**
+     * Returns whether a cell is active.
+     * @param rowIndex
+     * @param colIndex
+     */
+    isActiveCell(rowIndex: number, colIndex: number): boolean;
+    /**
+     * Focuses the active cell after the microtask queue is empty.
+     *
+     * Adding a 0ms setTimeout seems to fix Voiceover losing focus when pressing PageUp/PageDown
+     * (issue #24330).
+     *
+     * Determined a 0ms by gradually increasing duration from 0 and testing two use cases with screen
+     * reader enabled:
+     *
+     * 1. Pressing PageUp/PageDown repeatedly with pausing between each key press.
+     * 2. Pressing and holding the PageDown key with repeated keys enabled.
+     *
+     * Test 1 worked roughly 95-99% of the time with 0ms and got a little bit better as the duration
+     * increased. Test 2 got slightly better until the duration was long enough to interfere with
+     * repeated keys. If the repeated key speed was faster than the timeout duration, then pressing
+     * and holding pagedown caused the entire page to scroll.
+     *
+     * Since repeated key speed can verify across machines, determined that any duration could
+     * potentially interfere with repeated keys. 0ms would be best because it almost entirely
+     * eliminates the focus being lost in Voiceover (#24330) without causing unintended side effects.
+     * Adding delay also complicates writing tests.
+     */
+    focusActiveCell(movePreview?: boolean): void;
+    /**
+     * Focuses the active cell after change detection has run and the microtask queue is empty.
+     */
+    scheduleFocusActiveCellAfterViewChecked(): void;
+    /**
+     * Gets whether a value is the start of the main range.
+     * @param value
+     */
+    isRangeStart(value: number): boolean;
+    /** Gets whether a value is the end of the main range. */
+    isRangeEnd(value: number): boolean;
+    /** Gets whether a value is within the currently-selected range. */
+    isInRange(value: number): boolean;
+    /** Gets whether a value is the start of the comparison range. */
+    isComparisonStart(value: number): boolean;
+    /** Whether the cell is a start bridge cell between the main and comparison ranges. */
+    isComparisonBridgeStart(value: number, rowIndex: number, colIndex: number): boolean;
+    /** Whether the cell is an end bridge cell between the main and comparison ranges. */
+    isComparisonBridgeEnd(value: number, rowIndex: number, colIndex: number): boolean;
+    /** Gets whether a value is the end of the comparison range. */
+    isComparisonEnd(value: number): boolean;
+    /** Gets whether a value is within the current comparison range. */
+    isInComparisonRange(value: number): boolean;
+    /**
+     * Gets whether a value is the same as the start and end of the comparison range.
+     * For context, the functions that we use to determine whether something is the start/end of
+     * a range don't allow for the start and end to be on the same day, because we'd have to use
+     * much more specific CSS selectors to style them correctly in all scenarios. This is fine for
+     * the regular range, because when it happens, the selected styles take over and still show where
+     * the range would've been, however we don't have these selected styles for a comparison range.
+     * This function is used to apply a class that serves the same purpose as the one for selected
+     * dates, but it only applies in the context of a comparison range.
+     */
+    isComparisonIdentical(value: number): boolean;
+    /** Gets whether a value is the start of the preview range. */
+    isPreviewStart(value: number): boolean;
+    /** Gets whether a value is the end of the preview range. */
+    isPreviewEnd(value: number): boolean;
+    /** Gets whether a value is inside the preview range. */
+    isInPreview(value: number): boolean;
+    /** Gets ids of aria descriptions for the start and end of a date range. */
+    getDescribedby(value: number): OptionalType<string>;
+    /**
+     * Event handler for when the user enters an element
+     * inside the calendar body (e.g. by hovering in or focus).
+     */
+    private enterHandler;
+    private touchmoveHandler;
+    /**
+     * Event handler for when the user's pointer leaves an element
+     * inside the calendar body (e.g. by hovering out or blurring).
+     */
+    private leaveHandler;
+    /**
+     * Triggered on mousedown or touchstart on a date cell.
+     * Responsible for starting a drag sequence.
+     */
+    private mousedownHandler;
+    /** Triggered on mouseup anywhere. Responsible for ending a drag sequence. */
+    private mouseupHandler;
+    /** Triggered on touchend anywhere. Respsonsible for ending a drag sequence. */
+    private touchendHandler;
+    /** Finds the CalendarCell that corresponds to a DOM node. */
+    private getCellFromElement;
+    /** Checks whether a node is a table cell element. */
+    private isTableCell;
+    /**
+     * Gets the date table cell element that is or contains the specified element.
+     * Or returns null if element is not part of a date cell.
+     */
+    private getCellElement;
+    /** Checks whether a value is the start of a range. */
+    private isStart;
+    /** Checks whether a value is the end of a range. */
+    private isEnd;
+    /** Checks whether a value is inside of a range. */
+    private isInsideRange;
+    /**
+     * Extracts the element that actually corresponds to a touch event's location
+     * (rather than the element that initiated the sequence of touch events).
+     */
+    private getActualTouchTarget;
+    /**
+     * Takes a day of the month and returns a new date in the same month and year as the currently
+     *  active date. The returned date will have the same day of the month as the argument date.
+     */
+    private getDateFromDayOfMonth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarBodyComponent, "upd-calendar-body", never, { "label": { "alias": "label"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "todayValue": { "alias": "todayValue"; "required": false; }; "startValue": { "alias": "startValue"; "required": false; }; "endValue": { "alias": "endValue"; "required": false; }; "labelMinRequiredCells": { "alias": "labelMinRequiredCells"; "required": false; }; "numCols": { "alias": "numCols"; "required": false; }; "activeCell": { "alias": "activeCell"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "cellAspectRatio": { "alias": "cellAspectRatio"; "required": false; }; "comparisonStart": { "alias": "comparisonStart"; "required": false; }; "comparisonEnd": { "alias": "comparisonEnd"; "required": false; }; "previewStart": { "alias": "previewStart"; "required": false; }; "previewEnd": { "alias": "previewEnd"; "required": false; }; "startDateAccessibleName": { "alias": "startDateAccessibleName"; "required": false; }; "endDateAccessibleName": { "alias": "endDateAccessibleName"; "required": false; }; }, { "selectedValueChange": "selectedValueChange"; "previewChange": "previewChange"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; }, never, never, false, never>;
+}

package/calendar/components/calendar-header/calendar-header.component.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from "@angular/core";
+export declare class CalendarHeaderComponent {
+    /**
+     * The `aria-label` for changing the calendar view.
+     */
+    get periodButtonLabel(): string;
+    /**
+     * The label for the previous button.
+     */
+    get prevButtonLabel(): string;
+    /**
+     * The label for the next button.
+     */
+    get nextButtonLabel(): string;
+    /**
+     * Whether the selected view is not a month.
+     */
+    get isNotMonth(): boolean;
+    /**
+     * ID of the label of the period button.
+     */
+    get periodButtonLabelId(): string;
+    get minYearOfPageLabel(): string;
+    get maxYearOfPageLabel(): string;
+    get periodText(): string;
+    private get minYearOfPage();
+    private id;
+    private readonly calendarService;
+    private readonly calendarSignalsService;
+    private readonly dateService;
+    /**
+     * Handles user clicks on the period label.
+     */
+    currentPeriodClicked(): void;
+    /**
+     * Handles user clicks on the previous button.
+     */
+    previousClicked(): void;
+    /**
+     * Handles user clicks on the next button.
+     */
+    nextClicked(): void;
+    /**
+     * Whether the previous period button is enabled.
+     */
+    previousEnabled(): boolean;
+    /**
+     * Whether the next period button is enabled.
+     */
+    nextEnabled(): boolean;
+    /**
+     * Whether the two dates represent the same view in the current view mode (month or year).
+     */
+    private isSameView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarHeaderComponent, "upd-calendar-header", never, {}, {}, never, never, false, never>;
+}

package/calendar/components/calendar-month-view/calendar-month-view.component.d.ts

@@ -0,0 +1,151 @@
+import { AfterContentInit, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { OptionalType } from '@updevs/sdk/types';
+import { BaseComponent } from '@updevs/sdk/layout';
+import { CalendarUserEventModel } from '../../models/calendar-user-event.model';
+import { CalendarBodyComponent } from '../calendar-body/calendar-body.component';
+import { DateRangeModel } from '../../models/date-range.model';
+import { CalendarCellModel } from '../../models/calendar-cell.model';
+import { CalendarCellClassFunctionType } from '../../types/calendar-cell-class-function.type';
+import * as i0 from "@angular/core";
+export declare class CalendarMonthViewComponent extends BaseComponent implements AfterContentInit, OnChanges {
+    /**
+     * The body of calendar table
+     */
+    _matCalendarBody: CalendarBodyComponent;
+    /**
+     * The date to display in this month view (everything other than the month and year is ignored).
+     */
+    get activeDate(): Date;
+    set activeDate(value: Date);
+    /** The currently selected date. */
+    get selected(): DateRangeModel | OptionalType<Date>;
+    set selected(value: DateRangeModel | OptionalType<Date>);
+    /** The minimum selectable date. */
+    get minDate(): OptionalType<Date>;
+    set minDate(value: OptionalType<Date>);
+    /** The maximum selectable date. */
+    get maxDate(): OptionalType<Date>;
+    set maxDate(value: OptionalType<Date>);
+    /** Function used to filter which dates are selectable. */
+    dateFilter?: (date: Date) => boolean;
+    /** Function that can be used to add custom CSS classes to dates. */
+    dateClass?: CalendarCellClassFunctionType;
+    /** Start of the comparison range. */
+    comparisonStart?: Date;
+    /** End of the comparison range. */
+    comparisonEnd?: Date;
+    /** ARIA Accessible name of the `<input matStartDate/>` */
+    startDateAccessibleName?: string;
+    /** ARIA Accessible name of the `<input matEndDate/>` */
+    endDateAccessibleName?: string;
+    /**
+     * First day of week.
+     * Zero-based starting from Sunday.
+     * Default: 0 - Sunday.
+     */
+    firstDayOfWeek: number;
+    /** Origin of active drag, or null when dragging is not active. */
+    activeDrag?: CalendarUserEventModel<Date>;
+    /** Whether the user is currently selecting a range of dates. */
+    isRange: boolean;
+    /** Emits when a new date is selected. */
+    readonly selectedChange: EventEmitter<OptionalType<Date>>;
+    /** Emits when any date is selected. */
+    readonly userSelection: EventEmitter<CalendarUserEventModel<OptionalType<Date>>>;
+    /** Emits when the user initiates a date range drag via mouse or touch. */
+    readonly dragStarted: EventEmitter<CalendarUserEventModel<Date>>;
+    /**
+     * Emits when the user completes or cancels a date range drag.
+     * Emits null when the drag was canceled or the newly selected date range if completed.
+     */
+    readonly dragEnded: EventEmitter<CalendarUserEventModel<OptionalType<DateRangeModel>>>;
+    /** Emits when any date is activated. */
+    readonly activeDateChange: EventEmitter<Date>;
+    /** The label for this month (e.g. "January 2017"). */
+    monthLabel: string;
+    /** Grid of calendar cells representing the dates of the month. */
+    weeks: CalendarCellModel[][];
+    /** The number of blank cells in the first row before the 1st of the month. */
+    firstWeekOffset: number;
+    /** Start value of the currently-shown date range. */
+    rangeStart?: number;
+    /** End value of the currently-shown date range. */
+    rangeEnd?: number;
+    /** Start value of the currently-shown comparison date range. */
+    comparisonRangeStart?: number;
+    /** End value of the currently-shown comparison date range. */
+    comparisonRangeEnd?: number;
+    /** Start of the preview range. */
+    previewStart?: number;
+    /** End of the preview range. */
+    previewEnd?: number;
+    /** The date of the month that today falls on. Null if today is in another month. */
+    todayDate?: number;
+    /** The names of the weekdays. */
+    weekdays: {
+        long: string;
+        narrow: string;
+        id: number;
+    }[];
+    /** Flag used to filter out space/enter keyup events that originated outside of the view. */
+    private _selectionKeyPressed;
+    private _minDate?;
+    private _maxDate?;
+    private oldActiveDate?;
+    private readonly translocoService;
+    private readonly changeDetectorRef;
+    private readonly dateService;
+    private readonly calendarSignalsService;
+    private readonly calendarRangeStrategy;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Handles when a new date is selected. */
+    dateSelected(event: CalendarUserEventModel<number>): void;
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    /** Handles keyup events on the calendar body when calendar is in month view. */
+    handleCalendarBodyKeyup(event: KeyboardEvent): void;
+    /** Initializes this month view. */
+    init(): void;
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview?: boolean): void;
+    /** Focuses the active cell after change detection has run and the microtask queue is empty. */
+    focusActiveCellAfterViewChecked(): void;
+    /** Called when the user has activated a new cell and the preview needs to be updated. */
+    previewChanged({ value: cell }: CalendarUserEventModel<OptionalType<CalendarCellModel>>): void;
+    /**
+     * Called when the user has ended a drag. If the drag/drop was successful,
+     * computes and emits the new range selection.
+     */
+    protected _dragEnded(event: CalendarUserEventModel<OptionalType<Date>>): void;
+    private updateActiveDate;
+    /**
+     * Takes a day of the month and returns a new date in the same month and year as the currently
+     *  active date. The returned date will have the same day of the month as the argument date.
+     */
+    private getDateFromDayOfMonth;
+    /** Initializes the weekdays. */
+    private initWeekdays;
+    /** Creates MatCalendarCells for the dates in this month. */
+    private createWeekCells;
+    /** Date filter for the month */
+    private shouldEnableDate;
+    /**
+     * Gets the date in this month that the given Date falls on.
+     * Returns null if the given Date is in another month.
+     */
+    private getDateInCurrentMonth;
+    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */
+    private isSameMonthAndYearAsActiveDate;
+    /** Gets the value that will be used to one cell to another. */
+    private getCellCompareValue;
+    /** Sets the current range based on a model value. */
+    private setRanges;
+    /** Gets whether a date can be selected in the month view. */
+    private canSelect;
+    /** Clears out preview state. */
+    private clearPreview;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarMonthViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarMonthViewComponent, "upd-calendar-month-view", never, { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; "comparisonStart": { "alias": "comparisonStart"; "required": false; }; "comparisonEnd": { "alias": "comparisonEnd"; "required": false; }; "startDateAccessibleName": { "alias": "startDateAccessibleName"; "required": false; }; "endDateAccessibleName": { "alias": "endDateAccessibleName"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "activeDrag": { "alias": "activeDrag"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; }, { "selectedChange": "selectedChange"; "userSelection": "userSelection"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "activeDateChange": "activeDateChange"; }, never, never, false, never>;
+}

package/calendar/components/calendar-multi-year-view/calendar-multi-year-view.component.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare const yearsPerPage = 24;
+export declare class CalendarMultiYearViewComponent {
+    /** Initializes this month view. */
+    init(): void;
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarMultiYearViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarMultiYearViewComponent, "upd-calendar-multi-year-view", never, {}, {}, never, never, false, never>;
+}

package/calendar/components/calendar-year-view/calendar-year-view.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class CalendarYearViewComponent {
+    /** Initializes this month view. */
+    init(): void;
+    /** Focuses the active cell after the microtask queue is empty. */
+    focusActiveCell(movePreview?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarYearViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarYearViewComponent, "upd-calendar-year-view", never, {}, {}, never, never, false, never>;
+}

package/calendar/models/calendar-cell.model.d.ts

@@ -0,0 +1,16 @@
+import { CalendarCellCssClassesType } from '../types/calendar-cell-css-classes.type';
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ * @docs-private
+ */
+export declare class CalendarCellModel {
+    value: number;
+    displayValue: string;
+    ariaLabel: string;
+    isEnabled: boolean;
+    cssClasses: CalendarCellCssClassesType;
+    compareValue: number;
+    rawValue?: Date | undefined;
+    readonly id: number;
+    constructor(value: number, displayValue: string, ariaLabel: string, isEnabled: boolean, cssClasses?: CalendarCellCssClassesType, compareValue?: number, rawValue?: Date | undefined);
+}

package/calendar/models/calendar-user-event.model.d.ts

@@ -0,0 +1,4 @@
+export interface CalendarUserEventModel<TValue> {
+    value: TValue;
+    event: Event;
+}

package/calendar/models/date-range.model.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A class representing a range of dates.
+ */
+export declare class DateRangeModel {
+    /**
+     * The start date of the range.
+     */
+    readonly start?: Date | undefined;
+    /**
+     * The end date of the range.
+     */
+    readonly end?: Date | undefined;
+    /**
+     * Ensures that objects with a `start` and `end` property can't be assigned to a variable that
+     * expects a `DateRange`
+     */ private disableStructuralEquivalency;
+    constructor(
+    /**
+     * The start date of the range.
+     */
+    start?: Date | undefined, 
+    /**
+     * The end date of the range.
+     */
+    end?: Date | undefined);
+}

package/calendar/models/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './calendar-user-event.model';
+export * from './date-range.model';

package/calendar/public-api.d.ts

@@ -0,0 +1,5 @@
+export * from './models/public-api';
+export * from './services/public-api';
+export * from './types/public-api';
+export * from './calendar.component';
+export * from './upd-calendar.module';

package/calendar/services/calendar-range-strategy.service.d.ts

@@ -0,0 +1,35 @@
+import { OptionalType } from '@updevs/sdk/types';
+import { DateRangeModel } from '../models/date-range.model';
+import * as i0 from "@angular/core";
+/**
+ * Provides the default date range selection behavior.
+ */
+export declare class CalendarRangeStrategyService {
+    private readonly dateService;
+    /**
+     * Called when the user has finished selecting a value.
+     * @param date Date that was selected. Will be null if the user cleared the selection.
+     * @param currentRange Range that is currently show in the calendar.
+     */
+    selectionFinished(date: OptionalType<Date>, currentRange: DateRangeModel): DateRangeModel;
+    /**
+     * Called when the user has activated a new date (e.g. by hovering over
+     * it or moving focus) and the calendar tries to display a date range.
+     *
+     * @param activeDate Date that the user has activated. Will be null if the user moved
+     *    focus to an element that's no a calendar cell.
+     * @param currentRange Range that is currently shown in the calendar.
+     */
+    createPreview(activeDate: OptionalType<Date>, currentRange: DateRangeModel): DateRangeModel;
+    /**
+     * Called when the user has dragged a date in the currently selected range to another
+     * date. Returns the date updated range that should result from this interaction.
+     *
+     * @param dragOrigin The date the user started dragging from.
+     * @param originalRange The originally selected date range.
+     * @param newDate The currently targeted date in the drag operation.
+     */
+    createDrag(dragOrigin: Date, originalRange: DateRangeModel, newDate: Date): OptionalType<DateRangeModel>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarRangeStrategyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarRangeStrategyService>;
+}

package/calendar/services/calendar-signals.service.d.ts

@@ -0,0 +1,24 @@
+import { Signal } from '@angular/core';
+import { OptionalType } from '@updevs/sdk/types';
+import { CalendarViewType } from '../types/calendar-view.type';
+import { DateRangeModel } from '../models/date-range.model';
+import * as i0 from "@angular/core";
+export declare class CalendarSignalsService {
+    get minDate(): Signal<OptionalType<Date>>;
+    set minDate(value: OptionalType<Date>);
+    get maxDate(): Signal<OptionalType<Date>>;
+    set maxDate(value: OptionalType<Date>);
+    get activeDate(): Signal<Date>;
+    set activeDate(value: Date);
+    get selectedDate(): Signal<DateRangeModel | OptionalType<Date>>;
+    set selectedDate(value: OptionalType<DateRangeModel | OptionalType<Date>>);
+    get currentView(): Signal<CalendarViewType>;
+    set currentView(value: CalendarViewType);
+    private readonly minDateSignal;
+    private readonly maxDateSignal;
+    private readonly activeDateSignal;
+    private readonly selectedDateSignal;
+    private readonly currentViewSignal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarSignalsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarSignalsService>;
+}

package/calendar/services/calendar.service.d.ts

@@ -0,0 +1,15 @@
+import { OptionalType } from '@updevs/sdk/types';
+import * as i0 from "@angular/core";
+export declare class CalendarService {
+    /**
+     * When the multi-year view is first opened, the active year will be in view.
+     * So we compute how many years are between the active year and the *slot* where our
+     * "startingYear" will render when paged into view.
+     */
+    getMultiYearActiveOffset(activeDate: Date, minDate: OptionalType<Date>, maxDate: OptionalType<Date>): number;
+    isSameMultiYearView(date1: Date, date2: Date, minDate: OptionalType<Date>, maxDate: OptionalType<Date>): boolean;
+    getStartingYear(minDate: OptionalType<Date>, maxDate: OptionalType<Date>): number;
+    private euclideanModulo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarService>;
+}

package/calendar/services/public-api.d.ts

@@ -0,0 +1 @@
+export * from './calendar-range-strategy.service';

package/calendar/tools/events-options.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Event options that can be used to bind an active, capturing event.
+ */
+export declare const activeCapturingEventOptions: boolean | AddEventListenerOptions;
+/**
+ * Event options that can be used to bind a passive, capturing event.
+ */
+export declare const passiveCapturingEventOptions: boolean | AddEventListenerOptions;
+/**
+ * Event options that can be used to bind a passive, non-capturing event.
+ */
+export declare const passiveEventOptions: boolean | AddEventListenerOptions;

package/calendar/tools/keyboard-tools.d.ts

@@ -0,0 +1,9 @@
+import { ModifierKeyType } from '../types/modifier-key.type';
+export declare class KeyboardTools {
+    /**
+     * Checks whether a modifier key is pressed.
+     * @param event Event to be checked.
+     * @param modifiers
+     */
+    static hasModifierKey(event: KeyboardEvent, ...modifiers: ModifierKeyType[]): boolean;
+}