@radix-ng/primitives 0.33.1 → 0.33.2

package/calendar/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/calendar

package/calendar/index.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/calendar-cell-trigger.directive";
+import * as i2 from "./src/calendar-cell.directive";
+import * as i3 from "./src/calendar-grid-body.directive";
+import * as i4 from "./src/calendar-grid-head.directive";
+import * as i5 from "./src/calendar-grid-row.directive";
+import * as i6 from "./src/calendar-grid.directive";
+import * as i7 from "./src/calendar-head-cell.directive";
+import * as i8 from "./src/calendar-header.directive";
+import * as i9 from "./src/calendar-prev.directive";
+import * as i10 from "./src/calendar-root.directive";
+import * as i11 from "./src/calendar-heading.directive";
+import * as i12 from "./src/calendar-next.directive";
+export { RdxCalendarCellTriggerDirective } from './src/calendar-cell-trigger.directive';
+export { RdxCalendarCellDirective } from './src/calendar-cell.directive';
+export { RdxCalendarGridBodyDirective } from './src/calendar-grid-body.directive';
+export { RdxCalendarGridHeadDirective } from './src/calendar-grid-head.directive';
+export { RdxCalendarGridRowDirective } from './src/calendar-grid-row.directive';
+export { RdxCalendarGridDirective } from './src/calendar-grid.directive';
+export { RdxCalendarHeadCellDirective } from './src/calendar-head-cell.directive';
+export { RdxCalendarHeaderDirective } from './src/calendar-header.directive';
+export { RdxCalendarHeadingDirective } from './src/calendar-heading.directive';
+export { RdxCalendarNextDirective } from './src/calendar-next.directive';
+export { RdxCalendarPrevDirective } from './src/calendar-prev.directive';
+export { RdxCalendarRootDirective } from './src/calendar-root.directive';
+export declare class RdxCalendarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCalendarModule, never, [typeof i1.RdxCalendarCellTriggerDirective, typeof i2.RdxCalendarCellDirective, typeof i3.RdxCalendarGridBodyDirective, typeof i4.RdxCalendarGridHeadDirective, typeof i5.RdxCalendarGridRowDirective, typeof i6.RdxCalendarGridDirective, typeof i7.RdxCalendarHeadCellDirective, typeof i8.RdxCalendarHeaderDirective, typeof i9.RdxCalendarPrevDirective, typeof i10.RdxCalendarRootDirective, typeof i11.RdxCalendarHeadingDirective, typeof i12.RdxCalendarNextDirective], [typeof i1.RdxCalendarCellTriggerDirective, typeof i2.RdxCalendarCellDirective, typeof i3.RdxCalendarGridBodyDirective, typeof i4.RdxCalendarGridHeadDirective, typeof i5.RdxCalendarGridRowDirective, typeof i6.RdxCalendarGridDirective, typeof i7.RdxCalendarHeadCellDirective, typeof i8.RdxCalendarHeaderDirective, typeof i9.RdxCalendarPrevDirective, typeof i10.RdxCalendarRootDirective, typeof i11.RdxCalendarHeadingDirective, typeof i12.RdxCalendarNextDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCalendarModule>;
+}

package/calendar/src/calendar-cell-trigger.directive.d.ts

@@ -0,0 +1,54 @@
+import { AfterViewInit } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import * as i0 from "@angular/core";
+export declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
+    private readonly rootContext;
+    private readonly elementRef;
+    /**
+     * The date value provided to the cell trigger
+     */
+    readonly day: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * The month in which the cell is rendered
+     */
+    readonly month: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * Current day
+     */
+    readonly dayValue: import("@angular/core").Signal<string | undefined>;
+    /**
+     * Current today state
+     */
+    readonly isDateToday: import("@angular/core").Signal<boolean>;
+    /**
+     * Current selected state
+     */
+    readonly isSelectedDate: import("@angular/core").Signal<boolean>;
+    readonly isDisabled: import("@angular/core").Signal<boolean>;
+    readonly isOutsideView: import("@angular/core").Signal<boolean>;
+    readonly isFocusedDate: import("@angular/core").Signal<boolean>;
+    readonly isUnavailable: import("@angular/core").Signal<boolean>;
+    readonly labelText: import("@angular/core").Signal<string>;
+    /**
+     * @ignore
+     */
+    currentElement: HTMLElement;
+    ngAfterViewInit(): void;
+    protected onClick(): void;
+    protected onArrowKey(event: KeyboardEvent): void;
+    private shiftFocus;
+    /**
+     * @ignore
+     */
+    SELECTOR: string;
+    /**
+     * @ignore
+     */
+    getSelectableCells(calendar: HTMLElement): HTMLElement[];
+    /**
+     * @ignore
+     */
+    changeDate(date: DateValue): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarCellTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarCellTriggerDirective, "[rdxCalendarCellTrigger]", ["rdxCalendarCellTrigger"], { "day": { "alias": "day"; "required": false; "isSignal": true; }; "month": { "alias": "month"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,11 @@
+import { DateValue } from '@internationalized/date';
+import * as i0 from "@angular/core";
+export declare class RdxCalendarCellDirective {
+    protected readonly rootContext: import("./\u0441alendar-\u0441ontext.token").CalendarRootContextToken;
+    /**
+     * The date of the cell
+     */
+    readonly date: import("@angular/core").InputSignal<DateValue | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarCellDirective, "td[rdxCalendarCell]", never, { "date": { "alias": "date"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/calendar/src/calendar-grid-body.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarGridBodyDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarGridBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarGridBodyDirective, "tbody[rdxCalendarGridBody]", never, {}, {}, never, never, true, never>;
+}

package/calendar/src/calendar-grid-head.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarGridHeadDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarGridHeadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarGridHeadDirective, "thead[rdxCalendarGridHead]", never, {}, {}, never, never, true, never>;
+}

package/calendar/src/calendar-grid-row.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarGridRowDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarGridRowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarGridRowDirective, "tr[rdxCalendarGridRow]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarGridDirective {
+    private readonly rootContext;
+    readonly disabled: import("@angular/core").Signal<true | undefined>;
+    readonly readonly: import("@angular/core").Signal<true | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarGridDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarGridDirective, "table[rdxCalendarGrid]", never, {}, {}, never, never, true, never>;
+}

package/calendar/src/calendar-head-cell.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarHeadCellDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarHeadCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarHeadCellDirective, "th[rdxCalendarHeadCell]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarHeaderDirective, "div[rdxCalendarHeader]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class RdxCalendarHeadingDirective {
+    protected readonly rootContext: import("./\u0441alendar-\u0441ontext.token").CalendarRootContextToken;
+    readonly headingValue: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarHeadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarHeadingDirective, "div[rdxCalendarHeading]", ["rdxCalendarHeading"], {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { DateValue } from '@internationalized/date';
+import * as i0 from "@angular/core";
+export declare class RdxCalendarNextDirective {
+    protected readonly rootContext: import("./\u0441alendar-\u0441ontext.token").CalendarRootContextToken;
+    /**
+     * The function to be used for the `next page`. Overwrites the nextPage function set on the `CalendarRoot`.
+     */
+    readonly nextPage: import("@angular/core").InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarNextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarNextDirective, "button[rdxCalendarNext]", ["rdxCalendarNext"], { "nextPage": { "alias": "nextPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { DateValue } from '@internationalized/date';
+import * as i0 from "@angular/core";
+export declare class RdxCalendarPrevDirective {
+    protected readonly rootContext: import("./\u0441alendar-\u0441ontext.token").CalendarRootContextToken;
+    /**
+     * The function to be used for the `prev page`. Overwrites the prevPage function set on the `CalendarRoot`.
+     */
+    readonly prevPage: import("@angular/core").InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: import("@angular/core").Signal<boolean>;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarPrevDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarPrevDirective, "button[rdxCalendarPrev]", ["rdxCalendarPrev"], { "prevPage": { "alias": "prevPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,148 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { AfterViewInit } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Formatter, Month } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+export declare class RdxCalendarRootDirective implements AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar
+     */
+    readonly value: import("@angular/core").ModelSignal<DateValue | DateValue[] | undefined>;
+    /**
+     * The default placeholder date
+     */
+    readonly defaultPlaceholder: import("@angular/core").ModelSignal<DateValue | undefined>;
+    readonly locale: import("@angular/core").InputSignal<string>;
+    readonly defaultDate: 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>;
+    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to always display 6 weeks in the calendar
+     */
+    readonly fixedWeeks: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the calendar is disabled
+     */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to prevent the user from deselecting a date without selecting another date first
+     */
+    readonly preventDeselect: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The day of the week to start the calendar on
+     */
+    readonly weekStartsOn: import("@angular/core").InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    /**
+     * The number of months to display at once
+     */
+    readonly numberOfMonths: import("@angular/core").InputSignal<number>;
+    /**
+     * The reading direction of the calendar when applicable.
+     */
+    readonly dir: import("@angular/core").InputSignal<"ltr" | "rtl">;
+    /**
+     * The minimum date that can be selected
+     */
+    readonly minValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * The maximum date that can be selected
+     */
+    readonly maxValue: import("@angular/core").InputSignal<DateValue | undefined>;
+    /**
+     * The format to use for the weekday strings provided via the weekdays slot prop
+     */
+    readonly weekdayFormat: import("@angular/core").InputSignal<"long" | "short" | "narrow" | undefined>;
+    /**
+     * The accessible label for the calendar
+     */
+    readonly calendarLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Whether the calendar is readonly
+     */
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * This property causes the previous and next buttons to navigate by the number of months displayed at once, rather than one month
+     */
+    readonly pagedNavigation: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly propsNextPage: import("@angular/core").InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    readonly propsPrevPage: import("@angular/core").InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    /**
+     * A function that returns whether a date is disabled
+     */
+    readonly isDateDisabled: import("@angular/core").InputSignal<DateMatcher | undefined>;
+    /**
+     * A function that returns whether a date is unavailable
+     */
+    readonly isDateUnavailable: import("@angular/core").InputSignal<DateMatcher | undefined>;
+    readonly initialFocus: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly months: import("@angular/core").ModelSignal<Month<DateValue>[] | undefined>;
+    /**
+     * 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>;
+    /**
+     * @ignore
+     */
+    readonly headingValue: import("@angular/core").WritableSignal<string>;
+    /**
+     * @ignore
+     */
+    readonly fullCalendarLabel: import("@angular/core").WritableSignal<string>;
+    /**
+     * @ignore
+     */
+    nextPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    /**
+     * @ignore
+     */
+    prevPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    /**
+     * @ignore
+     */
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    isDateSelected: DateMatcher;
+    /**
+     * @ignore
+     */
+    isInvalid: boolean;
+    /**
+     * @ignore
+     */
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    currentElement: HTMLElement;
+    private readonly calendar;
+    constructor();
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onPlaceholderChange(value: DateValue): void;
+    /**
+     * @ignore
+     */
+    onDateChange(date: DateValue): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCalendarRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCalendarRootDirective, "[rdxCalendarRoot]", ["rdxCalendarRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultPlaceholder": { "alias": "defaultPlaceholder"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "fixedWeeks": { "alias": "fixedWeeks"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "preventDeselect": { "alias": "preventDeselect"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "numberOfMonths": { "alias": "numberOfMonths"; "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; }; "weekdayFormat": { "alias": "weekdayFormat"; "required": false; "isSignal": true; }; "calendarLabel": { "alias": "calendarLabel"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "pagedNavigation": { "alias": "pagedNavigation"; "required": false; "isSignal": true; }; "propsNextPage": { "alias": "propsNextPage"; "required": false; "isSignal": true; }; "propsPrevPage": { "alias": "propsPrevPage"; "required": false; "isSignal": true; }; "isDateDisabled": { "alias": "isDateDisabled"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "months": { "alias": "months"; "required": false; "isSignal": true; }; "weekDays": { "alias": "weekDays"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "defaultPlaceholder": "defaultPlaceholderChange"; "placeholder": "placeholderChange"; "months": "monthsChange"; "weekDays": "weekDaysChange"; }, never, never, true, never>;
+}

package/calendar/src/calendar.d.ts

@@ -0,0 +1,44 @@
+import { InputSignal, ModelSignal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Month } from '@radix-ng/primitives/core';
+export type CalendarProps = {
+    locale: InputSignal<string>;
+    placeholder: WritableSignal<DateValue>;
+    weekStartsOn: InputSignal<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    fixedWeeks: WritableSignal<boolean>;
+    numberOfMonths: InputSignal<number>;
+    minValue: InputSignal<DateValue | undefined>;
+    maxValue: InputSignal<DateValue | undefined>;
+    disabled: WritableSignal<boolean>;
+    weekdayFormat: InputSignal<Intl.DateTimeFormatOptions['weekday']>;
+    pagedNavigation: WritableSignal<boolean>;
+    isDateDisabled?: InputSignal<DateMatcher | undefined>;
+    isDateUnavailable?: InputSignal<DateMatcher | undefined>;
+    calendarLabel: InputSignal<string | undefined>;
+    nextPage: InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+    prevPage: InputSignal<((placeholder: DateValue) => DateValue) | undefined>;
+};
+export type CalendarStateProps = {
+    date: ModelSignal<DateValue | DateValue[] | undefined>;
+    isDateDisabled?: DateMatcher;
+    isDateUnavailable?: DateMatcher;
+};
+export declare function calendarState(props: CalendarStateProps): {
+    isDateSelected: (dateObj: DateValue) => boolean;
+    isInvalid: import("@angular/core").Signal<boolean>;
+};
+export declare function calendar(props: CalendarProps): {
+    isDateDisabled: (dateObj: DateValue) => boolean;
+    isDateUnavailable: (date: DateValue) => boolean;
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (prevPageFunc?: (date: DateValue) => DateValue) => boolean;
+    month: WritableSignal<Month<DateValue>[]>;
+    weekdays: import("@angular/core").Signal<string[]>;
+    visibleView: import("@angular/core").Signal<DateValue[]>;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    formatter: import("@radix-ng/primitives/core").Formatter;
+    nextPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    prevPage: (prevPageFunc?: (date: DateValue) => DateValue) => void;
+    headingValue: import("@angular/core").Signal<string>;
+    fullCalendarLabel: import("@angular/core").Signal<string>;
+};

package/calendar/src//321/201alendar-/321/201ontext.token.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken, InputSignal, ModelSignal, WritableSignal } from '@angular/core';
+import { DateValue } from '@internationalized/date';
+import { DateMatcher, Formatter } from '@radix-ng/primitives/core';
+export interface CalendarRootContextToken {
+    nextPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    prevPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    headingValue: WritableSignal<string>;
+    dir: InputSignal<'ltr' | 'rtl'>;
+    readonly: boolean;
+    numberOfMonths: InputSignal<number>;
+    placeholder: ModelSignal<DateValue>;
+    pagedNavigation: boolean;
+    disabled: InputSignal<boolean>;
+    isDateSelected?: DateMatcher;
+    isDateDisabled?: DateMatcher;
+    isDateUnavailable: DateMatcher;
+    formatter: Formatter;
+    onDateChange: (date: DateValue) => void;
+    currentElement: HTMLElement;
+}
+export declare const CALENDAR_ROOT_CONTEXT: InjectionToken<CalendarRootContextToken>;
+export declare function injectCalendarRootContext(): CalendarRootContextToken;

package/core/index.d.ts

@@ -10,6 +10,8 @@ export * from './src/is-nullish';
 export * from './src/is-number';
 export * from './src/kbd-constants';
 export * from './src/window';
+export * from './src/date-time';
 export * from './src/positioning/constants';
 export * from './src/positioning/types';
 export * from './src/positioning/utils';
+export * from './src/watch';

package/core/src/chunk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Splits an array into chunks of a given size.
+ * @param arr The array to split.
+ * @param size The size of each chunk.
+ * @returns An array of arrays, where each sub-array has `size` elements from the original array.
+ * @example ```ts
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8];
+ * const chunks = chunk(arr, 3);
+ * // chunks = [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * ```
+ */
+export declare function chunk<T>(arr: T[], size: number): T[][];

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

@@ -0,0 +1,33 @@
+import { DateValue } from '@internationalized/date';
+import { Month } from './types';
+export type CreateMonthProps = {
+    /**
+     * The date object representing the month's date (usually the first day of the month).
+     */
+    dateObj: DateValue;
+    /**
+     * The day of the week to start the calendar on (0 for Sunday, 1 for Monday, etc.).
+     */
+    weekStartsOn: number;
+    /**
+     * Whether to always render 6 weeks in the calendar, even if the month doesn't
+     * span 6 weeks.
+     */
+    fixedWeeks: boolean;
+    /**
+     * The locale to use when creating the calendar month.
+     */
+    locale: string;
+};
+/**
+ * Retrieves an array of date values representing the days between
+ * the provided start and end dates.
+ */
+export declare function getDaysBetween(start: DateValue, end: DateValue): DateValue[];
+export declare function createMonth(props: CreateMonthProps): Month<DateValue>;
+type SetMonthProps = CreateMonthProps & {
+    numberOfMonths: number | undefined;
+    currentMonths?: Month<DateValue>[];
+};
+export declare function createMonths(props: SetMonthProps): Month<DateValue>[];
+export {};

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

@@ -0,0 +1,92 @@
+import { CalendarDateTime, type DateValue, ZonedDateTime } from '@internationalized/date';
+import type { DateMatcher } from './types';
+/**
+ * Given a `DateValue` object, convert it to a native `Date` object.
+ * If a timezone is provided, the date will be converted to that timezone.
+ * If no timezone is provided, the date will be converted to the local timezone.
+ */
+export declare function toDate(dateValue: DateValue, tz?: string): Date;
+export declare function isCalendarDateTime(dateValue: DateValue): dateValue is CalendarDateTime;
+export declare function isZonedDateTime(dateValue: DateValue): dateValue is ZonedDateTime;
+export declare function hasTime(dateValue: DateValue): dateValue is CalendarDateTime | ZonedDateTime;
+/**
+ * Given a date, return the number of days in the month.
+ */
+export declare function getDaysInMonth(date: Date | DateValue): number;
+/**
+ * Determine if a date is before the reference date.
+ * @param dateToCompare - is this date before the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` before this date
+ *
+ * @see {@link isBeforeOrSame} for inclusive
+ */
+export declare function isBefore(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is after the reference date.
+ * @param dateToCompare - is this date after the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after this date
+ *
+ * @see {@link isAfterOrSame} for inclusive
+ */
+export declare function isAfter(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is before or the same as the reference date.
+ *
+ * @param dateToCompare - the date to compare
+ * @param referenceDate - the reference date to make the comparison against
+ *
+ * @see {@link isBefore} for non-inclusive
+ */
+export declare function isBeforeOrSame(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is after or the same as the reference date.
+ *
+ * @param dateToCompare - is this date after or the same as the `referenceDate`
+ * @param referenceDate - is the `dateToCompare` after or the same as this date
+ *
+ * @see {@link isAfter} for non-inclusive
+ */
+export declare function isAfterOrSame(dateToCompare: DateValue, referenceDate: DateValue): boolean;
+/**
+ * Determine if a date is inclusively between a start and end reference date.
+ *
+ * @param date - is this date inclusively between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetween} for non-inclusive
+ */
+export declare function isBetweenInclusive(date: DateValue, start: DateValue, end: DateValue): boolean;
+/**
+ * Determine if a date is between a start and end reference date.
+ *
+ * @param date - is this date between the `start` and `end` dates
+ * @param start - the start reference date to make the comparison against
+ * @param end - the end reference date to make the comparison against
+ *
+ * @see {@link isBetweenInclusive} for inclusive
+ */
+export declare function isBetween(date: DateValue, start: DateValue, end: DateValue): boolean;
+export declare function getLastFirstDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
+export declare function getNextLastDayOfWeek<T extends DateValue = DateValue>(date: T, firstDayOfWeek: number, locale: string): T;
+export declare function areAllDaysBetweenValid(start: DateValue, end: DateValue, isUnavailable: DateMatcher | undefined, isDisabled: DateMatcher | undefined): boolean;
+export type Granularity = 'day' | 'hour' | 'minute' | 'second';
+export type TimeGranularity = 'hour' | 'minute' | 'second';
+type GetDefaultDateProps = {
+    defaultValue?: DateValue | DateValue[] | undefined;
+    defaultPlaceholder?: DateValue | undefined;
+    granularity?: Granularity;
+    locale?: string;
+};
+/**
+ * A helper function used throughout the various date builders
+ * to generate a default `DateValue` using the `defaultValue`,
+ * `defaultPlaceholder`, and `granularity` props.
+ *
+ * It's important to match the `DateValue` type being used
+ * elsewhere in the builder, so they behave according to the
+ * behavior the user expects based on the props they've provided.
+ *
+ */
+export declare function getDefaultDate(props: GetDefaultDateProps): DateValue;
+export {};

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

@@ -0,0 +1,30 @@
+import { type DateValue } from '@internationalized/date';
+export interface DateFormatterOptions extends Intl.DateTimeFormatOptions {
+    calendar?: string;
+}
+export type Formatter = {
+    getLocale: () => string;
+    setLocale: (newLocale: string) => void;
+    custom: (date: Date, options: DateFormatterOptions) => string;
+    selectedDate: (date: DateValue, includeTime?: boolean) => string;
+    dayOfWeek: (date: Date, length?: DateFormatterOptions['weekday']) => string;
+    fullMonthAndYear: (date: Date, options?: DateFormatterOptions) => string;
+    fullMonth: (date: Date, options?: DateFormatterOptions) => string;
+    fullYear: (date: Date, options?: DateFormatterOptions) => string;
+    dayPeriod: (date: Date) => string;
+    part: (dateObj: DateValue, type: Intl.DateTimeFormatPartTypes, options?: DateFormatterOptions) => string;
+    toParts: (date: DateValue, options?: DateFormatterOptions) => Intl.DateTimeFormatPart[];
+    getMonths: () => {
+        label: string;
+        value: number;
+    }[];
+};
+/**
+ * Creates a wrapper around the `DateFormatter`, which is
+ * an improved version of the {@link Intl.DateTimeFormat} API,
+ * that is used internally by the various date builders to
+ * easily format dates in a consistent way.
+ *
+ * @see [DateFormatter](https://react-spectrum.adobe.com/internationalized/date/DateFormatter.html)
+ */
+export declare function createFormatter(initialLocale: string): Formatter;

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

@@ -0,0 +1,6 @@
+export * from './calendar';
+export * from './comparators';
+export * from './formatter';
+export * from './placeholders';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,8 @@
+declare const supportedLocales: readonly ["ach", "af", "am", "an", "ar", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "cak", "ckb", "cs", "cy", "da", "de", "dsb", "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fr", "fy", "ga", "gd", "gl", "he", "hr", "hsb", "hu", "ia", "id", "it", "ja", "ka", "kk", "kn", "ko", "lb", "lo", "lt", "lv", "meh", "ml", "ms", "nl", "nn", "no", "oc", "pl", "pt", "rm", "ro", "ru", "sc", "scn", "sk", "sl", "sr", "sv", "szl", "tg", "th", "tr", "uk", "zh-CN", "zh-TW"];
+declare const placeholderFields: readonly ["year", "month", "day"];
+type SupportedLocale = (typeof supportedLocales)[number];
+type PlaceholderField = (typeof placeholderFields)[number];
+export type PlaceholderMap = Record<SupportedLocale, Record<PlaceholderField, string>>;
+type Field = 'era' | 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'dayPeriod';
+export declare function getPlaceholder(field: Field, value: string, locale: SupportedLocale | (string & {})): string;
+export {};

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

@@ -0,0 +1,28 @@
+import type { DateValue } from '@internationalized/date';
+export type DateMatcher = (date: DateValue) => boolean;
+export type HourCycle = 12 | 24;
+export type Month<T> = {
+    /**
+     * A `DateValue` used to represent the month. Since days
+     * from the previous and next months may be included in the
+     * calendar grid, we need a source of truth for the value
+     * the grid is representing.
+     */
+    value: DateValue;
+    /**
+     * An array of (rows) arrays representing the weeks in the calendar.
+     * Each sub-array represents a week, and contains the dates for each
+     * day in that week. This structure is useful for rendering the calendar
+     * grid using a table, where each row represents a week and each cell
+     * represents a day.
+     */
+    weeks: T[][];
+    /**
+     * An array of (cells) all the dates in the current month, including dates from
+     * the previous and next months that are used to fill out the calendar grid.
+     * This array is useful for rendering the calendar grid in a customizable way,
+     * as it provides all the dates that should be displayed in the grid in a flat
+     * array.
+     */
+    dates: T[];
+};