@radix-ng/primitives 0.33.2 → 0.35.0

package/calendar/src/calendar-root.directive.d.ts

@@ -85,9 +85,9 @@ export declare class RdxCalendarRootDirective implements AfterViewInit {
      * The days of the week
      */
     readonly weekDays: import("@angular/core").ModelSignal<string[] | undefined>;
-    protected readonly fixedWeeksRef: import("@angular/core").WritableSignal<boolean>;
-    protected readonly disabledRef: import("@angular/core").WritableSignal<boolean>;
-    protected readonly pagedNavigationRef: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _fixedWeeks: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _disabled: import("@angular/core").WritableSignal<boolean>;
+    protected readonly _pagedNavigation: import("@angular/core").WritableSignal<boolean>;
     /**
      * @ignore
      */

package/core/index.d.ts

@@ -9,6 +9,7 @@ export * from './src/is-inside-form';
 export * from './src/is-nullish';
 export * from './src/is-number';
 export * from './src/kbd-constants';
+export * from './src/provide-token';
 export * from './src/window';
 export * from './src/date-time';
 export * from './src/positioning/constants';

package/core/src/accessor/provide-value-accessor.d.ts

@@ -9,4 +9,4 @@ import { Provider, Type } from '@angular/core';
  * export class ExampleDirective{}
  * ```
  */
-export declare function provideValueAccessor(type: Type<never>): Provider;
+export declare function provideValueAccessor<T>(type: Type<T>): Provider;

package/core/src/date-time/index.d.ts

@@ -1,6 +1,9 @@
 export * from './calendar';
 export * from './comparators';
 export * from './formatter';
+export * from './parser';
 export * from './placeholders';
+export * from './segment';
 export * from './types';
+export * from './useDateField';
 export * from './utils';

package/core/src/date-time/parser.d.ts

@@ -0,0 +1,37 @@
+import { InputSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Granularity } from './comparators';
+import { Formatter } from './formatter';
+import { HourCycle, SegmentContentObj, SegmentPart, SegmentValueObj } from './types';
+type SyncDateSegmentValuesProps = {
+    value: DateValue;
+    formatter: Formatter;
+};
+type SyncTimeSegmentValuesProps = {
+    value: DateValue;
+    formatter: Formatter;
+};
+export declare function syncTimeSegmentValues(props: SyncTimeSegmentValuesProps): SegmentValueObj;
+export declare function initializeSegmentValues(granularity: Granularity): SegmentValueObj;
+type SharedContentProps = {
+    granularity: Granularity;
+    dateRef: DateValue;
+    formatter: Formatter;
+    hideTimeZone: boolean;
+    hourCycle: HourCycle;
+    isTimeValue?: boolean;
+};
+type CreateContentObjProps = SharedContentProps & {
+    segmentValues: SegmentValueObj;
+    locale: InputSignal<string>;
+};
+export declare function syncSegmentValues(props: SyncDateSegmentValuesProps): SegmentValueObj;
+type CreateContentProps = CreateContentObjProps;
+export declare function createContent(props: CreateContentProps): {
+    obj: SegmentContentObj;
+    arr: {
+        part: SegmentPart;
+        value: string;
+    }[];
+};
+export {};

package/core/src/date-time/parts.d.ts

@@ -0,0 +1,12 @@
+import type { DateSegmentPart, EditableSegmentPart, SegmentPart, TimeSegmentPart } from './types';
+export declare const DATE_SEGMENT_PARTS: readonly ["day", "month", "year"];
+export declare const TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
+export declare const NON_EDITABLE_SEGMENT_PARTS: readonly ["literal", "timeZoneName"];
+export declare const EDITABLE_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod"];
+export declare const EDITABLE_TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
+export declare const ALL_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod", "literal", "timeZoneName"];
+export declare const ALL_EXCEPT_LITERAL_PARTS: ("day" | "month" | "year" | "hour" | "minute" | "second" | "dayPeriod" | "timeZoneName")[];
+export declare function isDateSegmentPart(part: unknown): part is DateSegmentPart;
+export declare function isTimeSegmentPart(part: unknown): part is TimeSegmentPart;
+export declare function isSegmentPart(part: string): part is EditableSegmentPart;
+export declare function isAnySegmentPart(part: unknown): part is SegmentPart;

package/core/src/date-time/segment.d.ts

@@ -0,0 +1,4 @@
+export declare function isSegmentNavigationKey(key: string): boolean;
+export declare function isNumberString(value: string): boolean;
+export declare function isAcceptableSegmentKey(key: string): boolean;
+export declare function getSegmentElements(parentElement: HTMLElement): Element[];

package/core/src/date-time/types.d.ts

@@ -1,6 +1,7 @@
 import type { DateValue } from '@internationalized/date';
+import { DATE_SEGMENT_PARTS, EDITABLE_SEGMENT_PARTS, NON_EDITABLE_SEGMENT_PARTS, TIME_SEGMENT_PARTS } from './parts';
 export type DateMatcher = (date: DateValue) => boolean;
-export type HourCycle = 12 | 24;
+export type HourCycle = 12 | 24 | undefined;
 export type Month<T> = {
     /**
      * A `DateValue` used to represent the month. Since days
@@ -26,3 +27,19 @@ export type Month<T> = {
      */
     dates: T[];
 };
+export type DateSegmentPart = (typeof DATE_SEGMENT_PARTS)[number];
+export type TimeSegmentPart = (typeof TIME_SEGMENT_PARTS)[number];
+export type EditableSegmentPart = (typeof EDITABLE_SEGMENT_PARTS)[number];
+export type NonEditableSegmentPart = (typeof NON_EDITABLE_SEGMENT_PARTS)[number];
+export type SegmentPart = EditableSegmentPart | NonEditableSegmentPart;
+export type AnyExceptLiteral = Exclude<SegmentPart, 'literal'>;
+export type DayPeriod = 'AM' | 'PM' | null;
+export type DateSegmentObj = {
+    [K in DateSegmentPart]: number | null;
+};
+export type TimeSegmentObj = {
+    [K in TimeSegmentPart]: K extends 'dayPeriod' ? DayPeriod : number | null;
+};
+export type DateAndTimeSegmentObj = DateSegmentObj & TimeSegmentObj;
+export type SegmentValueObj = DateSegmentObj | DateAndTimeSegmentObj;
+export type SegmentContentObj = Record<EditableSegmentPart, string>;

package/core/src/date-time/useDateField.d.ts

@@ -0,0 +1,141 @@
+import { InputSignal, ModelSignal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Formatter } from './formatter';
+import { HourCycle, SegmentPart, SegmentValueObj } from './types';
+export type UseDateFieldProps = {
+    hasLeftFocus: WritableSignal<boolean>;
+    lastKeyZero: WritableSignal<boolean>;
+    placeholder: ModelSignal<DateValue>;
+    hourCycle: HourCycle;
+    formatter: Formatter;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    part: SegmentPart;
+    modelValue: ModelSignal<DateValue | undefined>;
+    focusNext: () => void;
+};
+type SegmentAttrProps = {
+    disabled: boolean;
+    segmentValues: SegmentValueObj;
+    hourCycle: HourCycle;
+    placeholder: DateValue;
+    formatter: Formatter;
+};
+declare function daySegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function monthSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    contenteditable: boolean;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function yearSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function hourSegmentAttrs(props: SegmentAttrProps): {};
+declare function minuteSegmentAttrs(props: SegmentAttrProps): {};
+declare function secondSegmentAttrs(props: SegmentAttrProps): {};
+declare function dayPeriodSegmentAttrs(props: SegmentAttrProps): {};
+declare function literalSegmentAttrs(_props: SegmentAttrProps): {
+    'aria-hidden': boolean;
+    'data-segment': string;
+};
+declare function timeZoneSegmentAttrs(props: SegmentAttrProps): {
+    role: string;
+    'aria-label': string;
+    'data-readonly': boolean;
+    'data-segment': string;
+    tabindex: number | undefined;
+    style: string;
+};
+declare function eraSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': unknown;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+export declare const segmentBuilders: {
+    day: {
+        attrs: typeof daySegmentAttrs;
+    };
+    month: {
+        attrs: typeof monthSegmentAttrs;
+    };
+    year: {
+        attrs: typeof yearSegmentAttrs;
+    };
+    hour: {
+        attrs: typeof hourSegmentAttrs;
+    };
+    minute: {
+        attrs: typeof minuteSegmentAttrs;
+    };
+    second: {
+        attrs: typeof secondSegmentAttrs;
+    };
+    dayPeriod: {
+        attrs: typeof dayPeriodSegmentAttrs;
+    };
+    literal: {
+        attrs: typeof literalSegmentAttrs;
+    };
+    timeZoneName: {
+        attrs: typeof timeZoneSegmentAttrs;
+    };
+    era: {
+        attrs: typeof eraSegmentAttrs;
+    };
+};
+export declare function useDateField(props: UseDateFieldProps): {
+    handleSegmentClick: (e: MouseEvent) => void;
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    attributes: import("@angular/core").Signal<{}>;
+};
+export {};

package/core/src/date-time/utils.d.ts

@@ -1 +1,4 @@
+import { Granularity } from './comparators';
+import { HourCycle } from './types';
+export declare function getOptsByGranularity(granularity: Granularity, hourCycle: HourCycle, isTimeValue?: boolean): Intl.DateTimeFormatOptions;
 export declare function handleCalendarInitialFocus(calendar: HTMLElement): void;

package/core/src/provide-token.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken, Provider, Type } from '@angular/core';
+/**
+ * Creates an Angular provider that binds the given token to the existing instance
+ * of the specified class. This is especially useful when you want multiple
+ * tokens (or interfaces) to resolve to the same directive/component instance.
+ *
+ * @template T - The type associated with the injection token.
+ * @param token - The InjectionToken or abstract type you want to provide.
+ * @param type  - The class type whose existing instance will be used for this token.
+ * @returns A Provider configuration object for Angular's DI system.
+ *
+ * @example
+ *
+ * @Directive({
+ *   providers: [
+ *     provideToken(RdxToggleGroupToken, RdxToggleGroupDirective),
+ *     provideValueAccessor(RdxToggleGroupDirective)
+ *   ]
+ * })
+ * export class RdxToggleGroupDirective {}
+ */
+export declare function provideToken<T>(token: InjectionToken<T>, type: Type<unknown>): Provider;

package/date-field/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/date-field

package/date-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/date-field-input.directive';
+export * from './src/date-field-root.directive';

package/date-field/src/date-field-context.token.d.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, InputSignal, ModelSignal, Signal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { Formatter, HourCycle, SegmentValueObj } from '@radix-ng/primitives/core';
+export interface DateFieldContextToken {
+    locale: InputSignal<string>;
+    value: ModelSignal<DateValue | undefined>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    isInvalid: Signal<boolean>;
+    placeholder: ModelSignal<DateValue>;
+    hourCycle: InputSignal<HourCycle>;
+    formatter: Formatter;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+}
+export declare const DATE_FIELDS_ROOT_CONTEXT: InjectionToken<DateFieldContextToken>;
+export declare function injectDateFieldsRootContext(): DateFieldContextToken;

package/date-field/src/date-field-input.directive.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef } from '@angular/core';
+import { SegmentPart } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+export declare class RdxDateFieldInputDirective {
+    private el;
+    private readonly rootContext;
+    /**
+     * The part of the date to render
+     * `'day' | 'month' | 'year' | 'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName'`
+     */
+    readonly part: import("@angular/core").InputSignal<SegmentPart | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly readonly: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly hasLeftFocus: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly lastKeyZero: import("@angular/core").WritableSignal<boolean>;
+    private readonly fieldData;
+    private readonly attributes;
+    /**
+     * @ignore
+     */
+    handleSegmentClick: (e: MouseEvent) => void;
+    /**
+     * @ignore
+     */
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    constructor(el: ElementRef);
+    /**
+     * @ignore
+     */
+    onFocus(e: FocusEvent): void;
+    /**
+     * @ignore
+     */
+    onFocusOut(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDateFieldInputDirective, "[rdxDateFieldInput]", never, { "part": { "alias": "part"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/date-field/src/date-field-root.directive.d.ts

@@ -0,0 +1,126 @@
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { AfterViewInit, OnInit } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Formatter, Granularity, HourCycle, SegmentValueObj } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+export declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar.
+     */
+    readonly value: import("@angular/core").ModelSignal<DateValue | undefined>;
+    /**
+     * A callback fired when the date field's value is invalid.
+     */
+    readonly isDateUnavailable: import("@angular/core").InputSignal<DateMatcher | undefined>;
+    /**
+     * The hour cycle to use for formatting times. Defaults to the locale preference
+     */
+    readonly hourCycle: import("@angular/core").InputSignal<HourCycle>;
+    /**
+     * The granularity to use for formatting the field. Defaults to 'day' if a CalendarDate is provided, otherwise defaults to 'minute'.
+     * The field will render segments for each part of the date up to and including the specified granularity.
+     */
+    readonly granularity: import("@angular/core").InputSignal<Granularity | undefined>;
+    /**
+     * The locale to use for formatting dates.
+     */
+    readonly locale: import("@angular/core").InputSignal<string>;
+    readonly dir: import("@angular/core").InputSignal<Direction>;
+    /**
+     * The minimum valid date that can be entered.
+     */
+    readonly minValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * The maximum valid date that can be entered.
+     */
+    readonly maxValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * Whether or not to hide the time zone segment of the field.
+     */
+    readonly hideTimeZone: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether or not the field is readonly.
+     */
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @ignore
+     */
+    readonly defaultDate: import("@angular/core").Signal<DateValue>;
+    /**
+     * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
+     */
+    readonly placeholder: import("@angular/core").ModelSignal<DateValue | undefined>;
+    /**
+     * @ignore
+     */
+    readonly segmentElements: import("@angular/core").WritableSignal<Set<HTMLElement>>;
+    /**
+     * @ignore
+     */
+    readonly currentFocusedElement: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    readonly segmentValues: import("@angular/core").WritableSignal<SegmentValueObj>;
+    /**
+     * @ignore
+     */
+    readonly inferredGranularity: import("@angular/core").Signal<Granularity | undefined>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: import("@angular/core").Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly allSegmentContent: import("@angular/core").Signal<{
+        obj: import("@radix-ng/primitives/core").SegmentContentObj;
+        arr: {
+            part: import("@radix-ng/primitives/core").SegmentPart;
+            value: string;
+        }[];
+    }>;
+    /**
+     * An array of segments that should be readonly, which prevent user input on them.
+     */
+    readonly segmentContents: import("@angular/core").Signal<{
+        part: import("@radix-ng/primitives/core").SegmentPart;
+        value: string;
+    }[]>;
+    /**
+     * @ignore
+     */
+    readonly currentSegmentIndex: import("@angular/core").Signal<number>;
+    /**
+     * @ignore
+     */
+    readonly prevFocusableSegment: import("@angular/core").Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly nextFocusableSegment: import("@angular/core").Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly focusNext: () => void;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    setFocusedElement(el: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, never, never, true, never>;
+}

package/dialog/src/dialog-ref.d.ts

@@ -10,6 +10,9 @@ export declare const DISMISSED_VALUE: {};
 export declare class RdxDialogRef<C = unknown> {
     readonly cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>;
     readonly config: RdxDialogConfig<C>;
+    private _previousTimeout;
+    private readonly _openSignal;
+    readonly state: import("@angular/core").Signal<"open" | "closed">;
     closed$: Observable<RdxDialogResult<C> | undefined>;
     dismissed$: Observable<void>;
     result$: Observable<RdxDialogResult<C>>;

package/dialog/src/dialog.config.d.ts

@@ -26,6 +26,7 @@ type RdxBaseDialogConfig<C> = {
     autoFocus?: AutoFocusTarget | 'first-input' | string;
     canClose?: (comp: C) => boolean | Observable<boolean>;
     canCloseWithBackdrop?: boolean;
+    closeDelay?: number;
     cdkConfigOverride?: Partial<DialogConfig<C>>;
     mode?: RdxDialogMode;
     backdropClass?: string | string[];

package/fesm2022/radix-ng-primitives-calendar.mjs

@@ -744,18 +744,9 @@ class RdxCalendarRootDirective {
          * The days of the week
          */
         this.weekDays = model();
-        this.fixedWeeksRef = linkedSignal({
-            source: this.fixedWeeks,
-            computation: (value) => value
-        });
-        this.disabledRef = linkedSignal({
-            source: this.disabled,
-            computation: (value) => value
-        });
-        this.pagedNavigationRef = linkedSignal({
-            source: this.pagedNavigation,
-            computation: (value) => value
-        });
+        this._fixedWeeks = linkedSignal(this.fixedWeeks);
+        this._disabled = linkedSignal(this.disabled);
+        this._pagedNavigation = linkedSignal(this.pagedNavigation);
         /**
          * @ignore
          */
@@ -768,13 +759,13 @@ class RdxCalendarRootDirective {
             locale: this.locale,
             placeholder: this.placeholder,
             weekStartsOn: this.weekStartsOn,
-            fixedWeeks: this.fixedWeeksRef,
+            fixedWeeks: this._fixedWeeks,
             numberOfMonths: this.numberOfMonths,
             minValue: this.minValue,
             maxValue: this.maxValue,
-            disabled: this.disabledRef,
+            disabled: this._disabled,
             weekdayFormat: this.weekdayFormat,
-            pagedNavigation: this.pagedNavigationRef,
+            pagedNavigation: this._pagedNavigation,
             isDateDisabled: this.isDateDisabled,
             isDateUnavailable: this.isDateUnavailable,
             calendarLabel: this.calendarLabel,