@primeui/scheduler-core 0.0.1-alpha.1

package/dist/controllers/index.d.mts

@@ -0,0 +1,384 @@
+import { SchedulerEvent, DragDelta, EventDragState, EventResizeState, SchedulerViewType, EventConstraint, EventAllowCallback, BusinessHours, BlockedIntervalsOptions, AppointmentSlot, AppointmentSlotsOptions, DateRange, SchedulerResource } from '@primeui/scheduler-types/scheduler';
+import { S as SchedulerGridCell } from '../date-D_CjQPmM.mjs';
+import { P as ParsedEvent } from '../event.utils-QSNdd-3W.mjs';
+import { SchedulerCalendarInteractionOptions } from '../calendar/index.mjs';
+import { d as SchedulerPointerInput, e as SchedulerRectInput } from '../touch-BhsMWsjf.mjs';
+export { r as getTimeFromYPosition, s as getYPositionFromTime } from '../touch-BhsMWsjf.mjs';
+import '@primeui/scheduler-types/date';
+import '../display-format-CLVvRt4I.mjs';
+import '@internationalized/date';
+
+declare const RESIZE_EDGE_SIZE = 12;
+interface MonthDragContext {
+    grid: SchedulerGridCell[][];
+    eventOverlap: boolean;
+    parsedEvents: ParsedEvent[];
+}
+interface MonthDragMoveResult {
+    dragGhostPosition: {
+        x: number;
+        y: number;
+    };
+    dropTargetDate: Date | null;
+    delta: DragDelta;
+    previewEvent: SchedulerEvent | null;
+    shouldEmitDragStart: boolean;
+    shouldEmitDrag: boolean;
+}
+interface MonthDragEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    delta: DragDelta;
+    wasBlocked: boolean;
+}
+interface MonthResizeContext {
+    grid: SchedulerGridCell[][];
+    eventOverlap: boolean;
+    parsedEvents: ParsedEvent[];
+}
+interface MonthResizePreviewData {
+    weekIndex: number;
+    startCol: number;
+    endCol: number;
+    row: number;
+    event: SchedulerEvent;
+}
+interface MonthResizeMoveResult {
+    resizeTargetDate: Date;
+    startDelta: number;
+    endDelta: number;
+    previewEvent: SchedulerEvent;
+    previewData: MonthResizePreviewData[];
+}
+interface MonthResizeEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    wasBlocked: boolean;
+}
+declare function detectResizeEdgeForAllDay(relativeX: number, elementWidth: number, threshold?: number): 'start' | 'end' | null;
+declare function calculateDragClickOffset(eventStart: Date, clickedDate: Date, calendarOptions?: SchedulerCalendarInteractionOptions): number;
+declare function processMonthDragMove(state: EventDragState, targetDate: Date | null, dragClickDayOffset: number, mouseX: number, mouseY: number, calendarOptions?: SchedulerCalendarInteractionOptions): MonthDragMoveResult;
+declare function finalizeMonthDrag(state: EventDragState, context: MonthDragContext, calendarOptions?: SchedulerCalendarInteractionOptions): MonthDragEndResult;
+declare function calculateResizeDeltas(originalEvent: SchedulerEvent, targetDate: Date, resizeEdge: 'start' | 'end', calendarOptions?: SchedulerCalendarInteractionOptions): {
+    startDelta: number;
+    endDelta: number;
+};
+declare function calculateResizePreviewPosition(previewEvent: SchedulerEvent, grid: SchedulerGridCell[][], originalRow: number): MonthResizePreviewData[];
+declare function processMonthResizeMove(state: EventResizeState & {
+    resizeEdge: 'start' | 'end';
+    originalRow?: number;
+}, targetDate: Date, grid: SchedulerGridCell[][], calendarOptions?: SchedulerCalendarInteractionOptions): MonthResizeMoveResult;
+declare function finalizeMonthResize(state: EventResizeState, context: MonthResizeContext): MonthResizeEndResult;
+declare function findEventPositionInGrid(event: SchedulerEvent | ParsedEvent, grid: SchedulerGridCell[][], getWeekEventPositions: (week: SchedulerGridCell[]) => {
+    event: SchedulerEvent | ParsedEvent;
+    startCol: number;
+    endCol: number;
+    row: number;
+}[]): {
+    weekIndex: number;
+    startCol: number;
+    endCol: number;
+    row: number;
+} | null;
+interface DragGhostStyle {
+    [key: string]: string;
+    position: string;
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+    background: string;
+    color: string;
+    padding: string;
+    borderRadius: string;
+    fontSize: string;
+    fontWeight: string;
+    lineHeight: string;
+    pointerEvents: string;
+    zIndex: string;
+    opacity: string;
+    boxShadow: string;
+    whiteSpace: string;
+    overflow: string;
+    textOverflow: string;
+    display: string;
+    alignItems: string;
+    boxSizing: string;
+}
+declare function getDragGhostStyle(position: {
+    x: number;
+    y: number;
+}, dimensions: {
+    width: number;
+    height: number;
+} | null, event: SchedulerEvent): DragGhostStyle;
+
+interface TimedPointerStartInput {
+    event: SchedulerEvent;
+    pointer: SchedulerPointerInput;
+    rect: SchedulerRectInput | null | undefined;
+    canDrag: boolean;
+    canResize: boolean;
+}
+type TimedPointerStartResult = {
+    mode: 'none';
+} | {
+    mode: 'drag';
+    dragState: EventDragState;
+} | {
+    mode: 'resize';
+    resizeState: EventResizeState;
+};
+declare function resolveTimedPointerStart(input: TimedPointerStartInput): TimedPointerStartResult;
+interface TimedPointerDispatchHandlers {
+    onDrag: (pointer: SchedulerPointerInput) => void;
+    onResize: (pointer: SchedulerPointerInput) => void;
+}
+declare function dispatchTimedPointerMove(hasDragState: boolean, hasResizeState: boolean, handlers: TimedPointerDispatchHandlers, pointer: SchedulerPointerInput): void;
+declare function dispatchTimedPointerEnd(hasDragState: boolean, hasResizeState: boolean, handlers: TimedPointerDispatchHandlers, pointer: SchedulerPointerInput): void;
+interface TimedViewContext {
+    slotMinTime: string;
+    slotMaxTime: string;
+    slotDuration: number;
+    slotHeight: number;
+    eventOverlap: boolean;
+    parsedEvents: ParsedEvent[];
+}
+interface TimedDragMoveResult {
+    delta: DragDelta;
+    previewEvent: SchedulerEvent;
+    previewColIndex: number;
+    previewTop: number;
+    previewHeight: number;
+}
+interface TimedDragEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    delta: DragDelta;
+    wasBlocked: boolean;
+}
+interface TimedResizeMoveResult {
+    previewEvent: SchedulerEvent;
+    previewColIndex: number;
+    previewTop: number;
+    previewHeight: number;
+}
+interface TimedResizeEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    startDelta: number;
+    endDelta: number;
+    wasBlocked: boolean;
+}
+interface TimedDragCalculation {
+    daysDelta: number;
+    millisecondsDelta: number;
+    delta: DragDelta;
+}
+declare function calculateTimedDragDelta(state: EventDragState, columnWidth: number, slotHeight: number, slotDuration: number, snapDuration: number): TimedDragCalculation;
+interface ColumnInfo {
+    date: Date;
+    index: number;
+}
+declare function findColumnIndexForDate(date: Date, columns: {
+    date: Date;
+}[]): number;
+declare function calculateTimedDragPreview(previewEvent: SchedulerEvent, columns: {
+    date: Date;
+}[], slotMinTime: string, slotDuration: number, slotHeight: number): {
+    colIndex: number;
+    top: number;
+    height: number;
+} | null;
+declare function processTimedDragMove(state: EventDragState, columnWidth: number, columns: {
+    date: Date;
+}[], context: Pick<TimedViewContext, 'slotHeight' | 'slotDuration' | 'slotMinTime'>, snapDuration: number, calendarOptions?: SchedulerCalendarInteractionOptions): TimedDragMoveResult | null;
+declare function finalizeTimedDrag(state: EventDragState, context: Pick<TimedViewContext, 'eventOverlap' | 'parsedEvents'>, calendarOptions?: SchedulerCalendarInteractionOptions): TimedDragEndResult;
+declare function calculateTimedResizePreview(previewEvent: SchedulerEvent, columns: {
+    date: Date;
+}[], slotMinTime: string, slotDuration: number, slotHeight: number): {
+    colIndex: number;
+    top: number;
+    height: number;
+} | null;
+declare function processTimedResizeMove(state: EventResizeState, columns: {
+    date: Date;
+}[], context: Pick<TimedViewContext, 'slotHeight' | 'slotDuration' | 'slotMinTime'>): TimedResizeMoveResult | null;
+declare function finalizeTimedResize(state: EventResizeState, context: Pick<TimedViewContext, 'eventOverlap' | 'parsedEvents'>): TimedResizeEndResult;
+interface PreviewStyle {
+    [key: string]: string | undefined;
+    position: string;
+    top: string;
+    height: string;
+    left: string;
+    right: string;
+    zIndex: string;
+    pointerEvents: string;
+    opacity: string;
+    background?: string;
+    borderColor?: string;
+    color?: string;
+}
+declare function getTimedPreviewStyle(top: number, height: number, event: SchedulerEvent): PreviewStyle;
+interface TimedPreviewDropValidationInput {
+    previewEvent: SchedulerEvent | null | undefined;
+    originalEvent: SchedulerEvent | null | undefined;
+    view: SchedulerViewType;
+    eventConstraint?: EventConstraint;
+    eventAllow?: EventAllowCallback;
+    businessHours: BusinessHours;
+    blockedIntervals?: BlockedIntervalsOptions;
+    resourceId?: string | number;
+}
+declare function hasTimedDropConstraints(eventConstraint: EventConstraint | undefined, eventAllow: EventAllowCallback | undefined, blockedIntervals?: BlockedIntervalsOptions): boolean;
+declare function canDropTimedPreviewEvent(input: TimedPreviewDropValidationInput): boolean;
+
+declare function resolveTimelineSnapDuration(slotDuration: number, explicitSnapDuration?: number): number;
+declare const TIMELINE_RESIZE_EDGE_SIZE = 12;
+interface TimelineDragContext extends SchedulerCalendarInteractionOptions {
+    viewStart: Date;
+    viewEnd: Date;
+    totalWidth: number;
+    slotDuration: number;
+    snapDuration?: number;
+    eventOverlap: boolean;
+    parsedEvents: ParsedEvent[];
+    minTimeMinutes?: number;
+    maxTimeMinutes?: number;
+    overlapPolicy?: 'allow' | 'prevent';
+    allEvents?: SchedulerEvent[];
+    targetResourceId?: string | number;
+    targetResourceIds?: (string | number)[];
+}
+interface TimelineDragMoveResult {
+    dragGhostPosition: {
+        x: number;
+        y: number;
+    };
+    delta: DragDelta;
+    previewEvent: SchedulerEvent | null;
+    shouldEmitDragStart: boolean;
+    shouldEmitDrag: boolean;
+}
+interface TimelineDragEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    delta: DragDelta;
+    wasBlocked: boolean;
+}
+interface TimelineResizeContext extends SchedulerCalendarInteractionOptions {
+    viewStart: Date;
+    viewEnd: Date;
+    totalWidth: number;
+    slotDuration: number;
+    snapDuration?: number;
+    eventOverlap: boolean;
+    parsedEvents: ParsedEvent[];
+    minTimeMinutes?: number;
+    maxTimeMinutes?: number;
+    overlapPolicy?: 'allow' | 'prevent';
+    allEvents?: SchedulerEvent[];
+    targetResourceId?: string | number;
+    targetResourceIds?: (string | number)[];
+}
+interface TimelineResizePreviewStyle {
+    left: string;
+    width: string;
+}
+interface TimelineResizeMoveResult {
+    startDelta: number;
+    endDelta: number;
+    previewEvent: SchedulerEvent;
+    previewStyle: TimelineResizePreviewStyle;
+}
+interface TimelineResizeEndResult {
+    success: boolean;
+    newEvent: SchedulerEvent | null;
+    wasBlocked: boolean;
+}
+declare function detectResizeEdgeForTimeline(relativeX: number, elementWidth: number, threshold?: number): 'start' | 'end' | null;
+declare function createTimelineDragState(event: SchedulerEvent, startX: number, startY: number, offsetX: number, offsetY: number): EventDragState;
+declare function updateTimelineDragState(state: EventDragState, currentX: number, currentY: number, minDistance?: number): EventDragState;
+declare function calculateTimelineDragDelta(state: EventDragState, context: Pick<TimelineDragContext, 'viewStart' | 'viewEnd' | 'totalWidth' | 'slotDuration' | 'snapDuration' | 'minTimeMinutes' | 'maxTimeMinutes'>): DragDelta;
+declare function processTimelineDragMove(state: EventDragState, mouseX: number, mouseY: number, context: TimelineDragContext, minDistance?: number): TimelineDragMoveResult;
+declare function finalizeTimelineDrag(state: EventDragState, delta: DragDelta, context: Pick<TimelineDragContext, 'eventOverlap' | 'parsedEvents' | 'overlapPolicy' | 'allEvents' | 'targetResourceId' | 'targetResourceIds' | 'calendar' | 'locale' | 'view'>): TimelineDragEndResult;
+interface TimelineResizeState extends Omit<EventResizeState, 'edge'> {
+    edge: 'start' | 'end';
+    startX: number;
+    currentX: number;
+    visualStartPx?: number;
+    visualEndPx?: number;
+}
+declare function createTimelineResizeState(event: SchedulerEvent, edge: 'start' | 'end', startX: number, startY: number): TimelineResizeState;
+declare function calculateTimelineResizeDeltas(state: TimelineResizeState, context: Pick<TimelineResizeContext, 'viewStart' | 'viewEnd' | 'totalWidth' | 'slotDuration' | 'snapDuration' | 'minTimeMinutes' | 'maxTimeMinutes'>): {
+    startDelta: number;
+    endDelta: number;
+};
+declare function calculateResizePreviewStyle(originalEvent: SchedulerEvent, startDelta: number, endDelta: number, context: Pick<TimelineResizeContext, 'viewStart' | 'viewEnd' | 'totalWidth' | 'minTimeMinutes' | 'maxTimeMinutes'>): TimelineResizePreviewStyle;
+declare function processTimelineResizeMove(state: TimelineResizeState, mouseX: number, context: TimelineResizeContext): TimelineResizeMoveResult;
+declare function finalizeTimelineResize(state: TimelineResizeState, startDelta: number, endDelta: number, context: Pick<TimelineResizeContext, 'eventOverlap' | 'parsedEvents' | 'overlapPolicy' | 'allEvents' | 'targetResourceId' | 'targetResourceIds'>): TimelineResizeEndResult;
+interface TimelineDragGhostStyle {
+    [key: string]: string;
+    position: string;
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+    background: string;
+    color: string;
+    padding: string;
+    borderRadius: string;
+    borderInlineStart: string;
+    pointerEvents: string;
+    zIndex: string;
+    opacity: string;
+    boxShadow: string;
+    overflow: string;
+    display: string;
+    flexDirection: string;
+    justifyContent: string;
+    alignItems: string;
+    gap: string;
+    boxSizing: string;
+}
+declare function getTimelineDragGhostStyle(position: {
+    x: number;
+    y: number;
+}, dimensions: {
+    width: number;
+    height: number;
+} | null, event: SchedulerEvent): TimelineDragGhostStyle;
+
+interface SlotTrackingSnapshot {
+    slot: AppointmentSlot;
+    bookedCount: number;
+}
+interface AppointmentSlotTrackingState {
+    initialized: boolean;
+    snapshots: Map<string, SlotTrackingSnapshot>;
+    previousEvents: SchedulerEvent[];
+}
+interface AppointmentSlotTrackingContext {
+    options: AppointmentSlotsOptions;
+    view: SchedulerViewType;
+    viewRange: DateRange;
+    resources: SchedulerResource[];
+    slotMinTime: string;
+    slotMaxTime: string;
+}
+interface AppointmentSlotTrackingChange {
+    type: 'book' | 'cancel';
+    slot: AppointmentSlot;
+    event: SchedulerEvent;
+}
+interface AppointmentSlotTrackingSyncResult {
+    state: AppointmentSlotTrackingState;
+    changes: AppointmentSlotTrackingChange[];
+}
+declare function createAppointmentSlotTrackingState(): AppointmentSlotTrackingState;
+declare function isAppointmentSlotTrackingView(view: SchedulerViewType): boolean;
+declare function getSlotTrackingKey(slot: AppointmentSlot): string;
+declare function cloneEventForSlotTracking(event: SchedulerEvent): SchedulerEvent;
+declare function syncAppointmentSlotTracking(state: AppointmentSlotTrackingState, context: AppointmentSlotTrackingContext, currentEvents: SchedulerEvent[]): AppointmentSlotTrackingSyncResult;
+
+export { type AppointmentSlotTrackingChange, type AppointmentSlotTrackingContext, type AppointmentSlotTrackingState, type AppointmentSlotTrackingSyncResult, type ColumnInfo, type DragGhostStyle, type MonthDragContext, type MonthDragEndResult, type MonthDragMoveResult, type MonthResizeContext, type MonthResizeEndResult, type MonthResizeMoveResult, type MonthResizePreviewData, type PreviewStyle, RESIZE_EDGE_SIZE, type SlotTrackingSnapshot, TIMELINE_RESIZE_EDGE_SIZE, type TimedDragCalculation, type TimedDragEndResult, type TimedDragMoveResult, type TimedPointerDispatchHandlers, type TimedPointerStartInput, type TimedPointerStartResult, type TimedPreviewDropValidationInput, type TimedResizeEndResult, type TimedResizeMoveResult, type TimedViewContext, type TimelineDragContext, type TimelineDragEndResult, type TimelineDragGhostStyle, type TimelineDragMoveResult, type TimelineResizeContext, type TimelineResizeEndResult, type TimelineResizeMoveResult, type TimelineResizePreviewStyle, type TimelineResizeState, calculateDragClickOffset, calculateResizeDeltas, calculateResizePreviewPosition, calculateResizePreviewStyle, calculateTimedDragDelta, calculateTimedDragPreview, calculateTimedResizePreview, calculateTimelineDragDelta, calculateTimelineResizeDeltas, canDropTimedPreviewEvent, cloneEventForSlotTracking, createAppointmentSlotTrackingState, createTimelineDragState, createTimelineResizeState, detectResizeEdgeForAllDay, detectResizeEdgeForTimeline, dispatchTimedPointerEnd, dispatchTimedPointerMove, finalizeMonthDrag, finalizeMonthResize, finalizeTimedDrag, finalizeTimedResize, finalizeTimelineDrag, finalizeTimelineResize, findColumnIndexForDate, findEventPositionInGrid, getDragGhostStyle, getSlotTrackingKey, getTimedPreviewStyle, getTimelineDragGhostStyle, hasTimedDropConstraints, isAppointmentSlotTrackingView, processMonthDragMove, processMonthResizeMove, processTimedDragMove, processTimedResizeMove, processTimelineDragMove, processTimelineResizeMove, resolveTimedPointerStart, resolveTimelineSnapDuration, syncAppointmentSlotTracking, updateTimelineDragState };

package/dist/controllers/index.mjs

@@ -0,0 +1,13 @@
+export { RESIZE_EDGE_SIZE, TIMELINE_RESIZE_EDGE_SIZE, calculateDragClickOffset, calculateResizeDeltas, calculateResizePreviewPosition, calculateResizePreviewStyle, calculateTimedDragDelta, calculateTimedDragPreview, calculateTimedResizePreview, calculateTimelineDragDelta, calculateTimelineResizeDeltas, canDropTimedPreviewEvent, cloneEventForSlotTracking, createAppointmentSlotTrackingState, createTimelineDragState, createTimelineResizeState, detectResizeEdgeForAllDay, detectResizeEdgeForTimeline, dispatchTimedPointerEnd, dispatchTimedPointerMove, finalizeMonthDrag, finalizeMonthResize, finalizeTimedDrag, finalizeTimedResize, finalizeTimelineDrag, finalizeTimelineResize, findColumnIndexForDate, findEventPositionInGrid, getDragGhostStyle, getSlotTrackingKey, getTimedPreviewStyle, getTimelineDragGhostStyle, hasTimedDropConstraints, isAppointmentSlotTrackingView, processMonthDragMove, processMonthResizeMove, processTimedDragMove, processTimedResizeMove, processTimelineDragMove, processTimelineResizeMove, resolveTimedPointerStart, resolveTimelineSnapDuration, syncAppointmentSlotTracking, updateTimelineDragState } from '../chunk-5N4ZOBJV.mjs';
+export { getTimeFromYPosition, getYPositionFromTime } from '../chunk-2THQAZ26.mjs';
+import '../chunk-SYJ5O4KH.mjs';
+import '../chunk-NX46LPLF.mjs';
+import '../chunk-2B3YLWHA.mjs';
+import '../chunk-NZGJN7HG.mjs';
+import '../chunk-HPC5B3AR.mjs';
+import '../chunk-5KORIWDT.mjs';
+import '../chunk-FIBAZFC4.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';
+import '../chunk-QR2SVYAD.mjs';

package/dist/date-D_CjQPmM.d.mts

@@ -0,0 +1,74 @@
+import { WeekNumbering } from '@primeui/scheduler-types/date';
+import { S as SchedulerCalendarDisplayConfigInput } from './display-format-CLVvRt4I.mjs';
+
+declare function getMonthDays(year: number, month: number): Date[];
+declare function getWeekDays(date: Date, firstDayOfWeek?: number): Date[];
+declare function getDayHours(date: Date, minTime?: string, maxTime?: string): Date[];
+declare function getYearMonths(year: number): Date[];
+declare function startOfWeek(date: Date, firstDayOfWeek?: number): Date;
+declare function endOfWeek(date: Date, firstDayOfWeek?: number): Date;
+declare function startOfMonth(date: Date): Date;
+declare function endOfMonth(date: Date): Date;
+declare function startOfDay(date: Date): Date;
+declare function endOfDay(date: Date): Date;
+declare function addDays(date: Date, amount: number): Date;
+declare function addWeeks(date: Date, amount: number): Date;
+declare function addMonths(date: Date, amount: number): Date;
+declare function addYears(date: Date, amount: number): Date;
+declare function addHours(date: Date, amount: number): Date;
+declare function addMinutes(date: Date, amount: number): Date;
+declare function isSameDay(d1: Date, d2: Date): boolean;
+declare function isSameWeek(d1: Date, d2: Date, firstDayOfWeek?: number): boolean;
+declare function isSameMonth(d1: Date, d2: Date): boolean;
+declare function isSameYear(d1: Date, d2: Date): boolean;
+declare function isToday(date: Date): boolean;
+declare function isWeekend(date: Date): boolean;
+declare function isBefore(d1: Date, d2: Date): boolean;
+declare function isAfter(d1: Date, d2: Date): boolean;
+declare function isBetween(date: Date, start: Date, end: Date, inclusive?: boolean): boolean;
+declare function isDateInRange(date: Date, minDate: Date | null | undefined, maxDate: Date | null | undefined): boolean;
+declare function getDaysInMonth(year: number, month: number): number;
+declare function getWeekNumber(date: Date, weekNumbering?: WeekNumbering, locale?: string): number;
+interface SchedulerGridCell {
+    date: Date;
+    dayOfMonth: number;
+    dayOfMonthLabel: string;
+    dayNumberLabel: string;
+    isCurrentMonth: boolean;
+    isToday: boolean;
+    isWeekend: boolean;
+    isDisabled: boolean;
+    weekNumber: number;
+}
+declare function getSchedulerGrid(year: number, month: number, firstDayOfWeek?: number, minDate?: Date | null, maxDate?: Date | null, weekNumbering?: WeekNumbering, locale?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): SchedulerGridCell[][];
+declare function formatDateString(date: Date, format: string, locale?: string): string;
+declare function formatMonthYearTitle(date: Date, locale?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatWeekdayName(date: Date, locale?: string, format?: 'long' | 'short' | 'narrow', displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatGregorianDayNumber(date: Date, locale?: string, options?: Intl.DateTimeFormatOptions, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatGregorianWeekday(date: Date, locale?: string, width?: 'long' | 'short' | 'narrow', options?: Intl.DateTimeFormatOptions, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatGregorianMonthTitle(date: Date, locale?: string, options?: Intl.DateTimeFormatOptions, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatGregorianYear(date: Date, locale?: string, options?: Intl.DateTimeFormatOptions, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function getWeekdayNames(locale?: string, format?: 'long' | 'short' | 'narrow', firstDayOfWeek?: number, displayConfig?: SchedulerCalendarDisplayConfigInput): string[];
+declare function getMonthNames(locale?: string, format?: 'long' | 'short' | 'narrow', displayConfig?: SchedulerCalendarDisplayConfigInput): string[];
+declare function parseDate(dateString: string): Date | null;
+declare function toDateString(date: Date): string;
+declare function toTimeString(date: Date): string;
+declare function toDateTimeString(date: Date): string;
+declare function getDatesBetween(start: Date, end: Date): Date[];
+declare function clampDate(date: Date, minDate: Date | null | undefined, maxDate: Date | null | undefined): Date;
+declare function differenceInDays(d1: Date, d2: Date): number;
+declare function differenceInMinutes(d1: Date, d2: Date): number;
+declare function differenceInHours(d1: Date, d2: Date): number;
+declare function setTime(date: Date, hours: number, minutes?: number, seconds?: number): Date;
+declare function parseTimeString(timeString: string): {
+    hours: number;
+    minutes: number;
+};
+declare function timeStringToMinutes(timeString: string): number;
+declare function minutesToPixels(minutes: number, slotDuration: number, slotHeight: number): number;
+declare function minutesToTimeString(minutes: number): string;
+declare function formatEventTime12h(date: Date): string;
+declare function calculateDaysDelta(targetDate: Date, originalDate: Date): number;
+declare function applyDaysDelta(date: Date, days: number): Date;
+
+export { toDateString as $, getMonthDays as A, getMonthNames as B, getSchedulerGrid as C, getWeekDays as D, getWeekNumber as E, getWeekdayNames as F, getYearMonths as G, isAfter as H, isBefore as I, isBetween as J, isDateInRange as K, isSameDay as L, isSameMonth as M, isSameWeek as N, isSameYear as O, isToday as P, isWeekend as Q, minutesToPixels as R, type SchedulerGridCell as S, minutesToTimeString as T, parseDate as U, parseTimeString as V, setTime as W, startOfDay as X, startOfMonth as Y, startOfWeek as Z, timeStringToMinutes as _, addDays as a, toDateTimeString as a0, toTimeString as a1, addHours as b, addMinutes as c, addMonths as d, addWeeks as e, addYears as f, applyDaysDelta as g, calculateDaysDelta as h, clampDate as i, differenceInDays as j, differenceInHours as k, differenceInMinutes as l, endOfDay as m, endOfMonth as n, endOfWeek as o, formatDateString as p, formatEventTime12h as q, formatGregorianDayNumber as r, formatGregorianMonthTitle as s, formatGregorianWeekday as t, formatGregorianYear as u, formatMonthYearTitle as v, formatWeekdayName as w, getDatesBetween as x, getDayHours as y, getDaysInMonth as z };

package/dist/display-format-CLVvRt4I.d.mts

@@ -0,0 +1,57 @@
+import { SchedulerCalendarMode, SchedulerNumberingSystem, SchedulerViewType, DateDisplayOptions, DisplayOptions, TimeFormatOptions } from '@primeui/scheduler-types/scheduler';
+
+declare const DEFAULT_TIME_FORMAT_OPTIONS: Required<TimeFormatOptions>;
+declare const DEFAULT_DATE_DISPLAY_OPTIONS: Required<DateDisplayOptions>;
+declare const DEFAULT_DISPLAY_OPTIONS: Required<DisplayOptions>;
+interface SchedulerCalendarDisplayConfigInput {
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+    numberingSystem?: SchedulerNumberingSystem;
+    timeZone?: string;
+    view?: SchedulerViewType | string;
+}
+interface SchedulerCalendarDisplayConfig {
+    locale: string;
+    calendar: SchedulerCalendarMode;
+    numberingSystem?: string;
+    timeZone?: string;
+}
+interface SchedulerDateFormatter {
+    config: SchedulerCalendarDisplayConfig;
+    format: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+    formatDayNumber: (date: Date, format?: 'numeric' | '2-digit') => string;
+    formatWeekdayDayNumber: (date: Date, weekday?: 'long' | 'short' | 'narrow', day?: 'numeric' | '2-digit') => string;
+    formatWeekday: (date: Date, width?: 'long' | 'short' | 'narrow') => string;
+    formatMonth: (date: Date, format?: 'numeric' | '2-digit' | 'short' | 'long' | 'narrow') => string;
+    formatMonthTitle: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+    formatYear: (date: Date) => string;
+    formatNumber: (value: number) => string;
+}
+declare function normalizeTimeFormatOptions(options?: TimeFormatOptions): Required<TimeFormatOptions>;
+declare function normalizeDateDisplayOptions(options?: DateDisplayOptions): Required<DateDisplayOptions>;
+declare function normalizeDisplayOptions(options?: DisplayOptions): Required<DisplayOptions>;
+declare function resolveSchedulerCalendarDisplayConfig(input?: SchedulerCalendarDisplayConfigInput): SchedulerCalendarDisplayConfig;
+declare function createSchedulerDateFormatter(input?: SchedulerCalendarDisplayConfigInput): SchedulerDateFormatter;
+declare function __getDateTimeFormatterCacheSize(): number;
+declare function __clearDateTimeFormatterCache(): void;
+declare function formatTime(date: Date, locale: string, options?: TimeFormatOptions, timeZone?: string): string;
+declare function formatTimeRange(start: Date, end: Date, locale: string, options?: TimeFormatOptions, timeZone?: string): string;
+declare function formatSlotTime(date: Date, locale: string, options?: TimeFormatOptions, timeZone?: string): string;
+declare function getRelativeDay(date: Date, locale: string, timeZone?: string): string | null;
+declare function formatDate(date: Date, locale: string, options?: DateDisplayOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatWeekday(date: Date, locale: string, format?: 'narrow' | 'short' | 'long', timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatMonth(date: Date, locale: string, format?: 'numeric' | '2-digit' | 'short' | 'long', timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatDayOfMonth(date: Date, locale: string, format?: 'numeric' | '2-digit', timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatMonthYear(date: Date, locale: string, options?: DateDisplayOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatDateRange(start: Date, end: Date, locale: string, options?: DateDisplayOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatEventDateTime(event: {
+    start: Date | string;
+    end?: Date | string;
+    allDay?: boolean;
+}, locale: string, displayOptions?: DisplayOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatHeaderTitle(date: Date, view: string, locale: string, options?: DateDisplayOptions, context?: {
+    daysOfWeek?: number[];
+    firstDayOfWeek?: number;
+}, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+
+export { DEFAULT_DATE_DISPLAY_OPTIONS as D, type SchedulerCalendarDisplayConfigInput as S, __clearDateTimeFormatterCache as _, DEFAULT_DISPLAY_OPTIONS as a, DEFAULT_TIME_FORMAT_OPTIONS as b, type SchedulerCalendarDisplayConfig as c, type SchedulerDateFormatter as d, __getDateTimeFormatterCacheSize as e, createSchedulerDateFormatter as f, formatDate as g, formatDateRange as h, formatDayOfMonth as i, formatEventDateTime as j, formatHeaderTitle as k, formatMonth as l, formatMonthYear as m, formatSlotTime as n, formatTime as o, formatTimeRange as p, formatWeekday as q, getRelativeDay as r, normalizeDateDisplayOptions as s, normalizeDisplayOptions as t, normalizeTimeFormatOptions as u, resolveSchedulerCalendarDisplayConfig as v };