@primeui/scheduler-core 0.0.1-alpha.1

package/dist/interaction/index.d.mts

@@ -0,0 +1,442 @@
+export { D as DEFAULT_DRAG_MIN_DISTANCE, a as DEFAULT_SNAP_DURATION, S as SchedulerDropCalendarOptions, b as SchedulerEventDropCandidate, c as SchedulerEventDropCandidateInput, d as SchedulerPointerInput, e as SchedulerRectInput, f as applyDeltaToEvent, g as calculateDayDelta, h as calculateDragDelta, i as calculateTimeDelta, j as clampTime, k as createDragState, l as createSchedulerEventDropCandidate, m as findOverlappingEvents, n as getDayIndexFromX, o as getPointerCoords, p as getSchedulerEventDropDelta, q as getSchedulerTimedInteractionDeltaMs, r as getTimeFromYPosition, s as getYPositionFromTime, t as isEventDraggable, u as snapTime, v as snapToSlot, w as updateDragState, x as validateDragPosition } from '../touch-BhsMWsjf.mjs';
+import { SchedulerEventSelectionState, SchedulerEventSelectionOptions, SchedulerViewType, SchedulerEvent, EventResizeState, DragConstraints, TimeFormatOptions, QuickInfoOptions, InlineEditOptions, ConflictInfo, ConflictOptions, SchedulerResource, ConflictDetectedPayload, CapacityExceededPayload, ResourceCapacityInfo, SchedulerPermissionAction, SchedulerPermissionResolver, SchedulerPermissionContext } from '@primeui/scheduler-types/scheduler';
+import { S as SchedulerGridCell } from '../date-D_CjQPmM.mjs';
+export { D as DateSelectionResult, a as DragEndResult, b as DragMoveResult, c as DragSelectionState, d as DragStartResult, S as SelectionMode, e as SelectionState, T as TimeSelectionResult, f as calculateDragRange, g as clearSelection, h as finalizeDragSelection, i as getActiveRange, j as handleDateSelection, k as handleTimeSelection, l as hasSelection, m as isDateInSelectionRange, n as isDateSelected, o as isRangeEnd, p as isRangeStart, s as startDragSelection, u as updateDragPreview } from '../selection-CO_98HdS.mjs';
+import { S as SchedulerCalendarDisplayConfigInput } from '../display-format-CLVvRt4I.mjs';
+import { TimelineCell, TimelineEventPosition } from '@primeui/scheduler-types/timeline';
+import '../calendar/index.mjs';
+import '@internationalized/date';
+import '@primeui/scheduler-types/date';
+
+interface AutoScrollRect {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+interface ResolveAutoScrollDeltaInput {
+    pointerX: number;
+    pointerY: number;
+    rect: AutoScrollRect;
+    canScrollX: boolean;
+    canScrollY: boolean;
+    threshold: number;
+    maxSpeed: number;
+}
+interface AutoScrollDelta {
+    x: number;
+    y: number;
+}
+interface AutoScrollTarget {
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    clientWidth: number;
+    clientHeight: number;
+    measure: () => AutoScrollRect;
+}
+interface DragAutoScrollerOptions {
+    enabled?: boolean | (() => boolean);
+    getContainers: (point: {
+        clientX: number;
+        clientY: number;
+    }) => Array<AutoScrollTarget | null | undefined>;
+    threshold?: number;
+    maxSpeed?: number;
+    interval?: number;
+}
+interface DragAutoScroller {
+    update: (point: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+    stop: () => void;
+    destroy: () => void;
+    isActive: () => boolean;
+}
+declare function resolveAutoScrollDelta(input: ResolveAutoScrollDeltaInput): AutoScrollDelta;
+declare function createDragAutoScroller(options: DragAutoScrollerOptions): DragAutoScroller;
+
+interface NormalizedEventSelectionOptions extends SchedulerEventSelectionOptions {
+    enabled: boolean;
+}
+declare const RESOURCE_VIEWS: SchedulerViewType[];
+declare function isResourceView(view: SchedulerViewType): boolean;
+declare function eventBelongsToResource(event: SchedulerEvent, resourceId: string | number): boolean;
+declare function filterVisibleIdsByResource(visibleIds: (string | number)[], events: SchedulerEvent[], resourceId: string | number | undefined, currentView: SchedulerViewType): (string | number)[];
+interface EventSelectionModifiers {
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    toggle?: boolean;
+}
+interface EventSelectionResult extends SchedulerEventSelectionState {
+    changed: boolean;
+    limitReached?: boolean;
+}
+declare function normalizeEventSelectionOptions(options?: boolean | SchedulerEventSelectionOptions): NormalizedEventSelectionOptions;
+declare function applyEventSelection(params: {
+    eventId: string | number;
+    visibleIds: (string | number)[];
+    modifiers: EventSelectionModifiers;
+    options: NormalizedEventSelectionOptions;
+    state: SchedulerEventSelectionState;
+}): EventSelectionResult;
+declare function selectAllVisibleEvents(visibleIds: (string | number)[], options: NormalizedEventSelectionOptions): EventSelectionResult;
+declare function invertSelection(currentIds: (string | number)[], visibleIds: (string | number)[], options: NormalizedEventSelectionOptions): EventSelectionResult;
+declare function clearEventSelection(): SchedulerEventSelectionState;
+
+declare const RESIZE_HANDLE_SIZE = 8;
+type SchedulerEventResizeEdge = 'top' | 'bottom' | 'start' | 'end';
+interface SchedulerEventResizePreview {
+    edge: SchedulerEventResizeEdge;
+    startDelta: number;
+    endDelta: number;
+}
+interface SchedulerEventResizePreviewResult extends SchedulerEventResizePreview {
+    event: SchedulerEvent;
+}
+declare function createResizeState(event: SchedulerEvent, edge: 'top' | 'bottom', startY: number): EventResizeState;
+declare function updateResizeState(state: EventResizeState, currentY: number, slotHeight: number, slotDuration: number, snapDuration?: number): EventResizeState;
+declare function applyResizeToEvent(event: SchedulerEvent, startDelta: number, endDelta: number): SchedulerEvent;
+declare function getSchedulerTimedResizePreview(input: {
+    edge: Extract<SchedulerEventResizeEdge, 'top' | 'bottom'>;
+    event: SchedulerEvent;
+    start: Date;
+    end: Date;
+    deltaMinutes: number;
+    snapMinutes: number;
+}): SchedulerEventResizePreviewResult;
+declare function getSchedulerTimelineResizePreview(input: {
+    edge: Extract<SchedulerEventResizeEdge, 'start' | 'end'>;
+    event: SchedulerEvent;
+    start: Date;
+    end: Date;
+    deltaMs: number;
+    snapMinutes: number;
+}): SchedulerEventResizePreviewResult;
+declare function validateResize(event: SchedulerEvent, startDelta: number, endDelta: number, constraints: DragConstraints, allEvents: SchedulerEvent[], minDuration?: number): {
+    valid: boolean;
+    reason?: string;
+};
+declare function isEventResizable(event: SchedulerEvent, globalEditable?: boolean, eventDurationEditable?: boolean): boolean;
+declare function detectResizeEdge(mouseY: number, eventTop: number, eventHeight: number): 'top' | 'bottom' | null;
+declare function getResizeCursor(edge: 'top' | 'bottom' | null): string;
+declare function calculateNewEventTimes(state: EventResizeState, slotMinTime: string, slotMaxTime: string): {
+    start: Date;
+    end: Date;
+} | null;
+
+type KeyboardAction = 'prev-day' | 'next-day' | 'prev-week' | 'next-week' | 'start-of-week' | 'end-of-week' | 'prev-month' | 'next-month' | 'prev-year' | 'next-year' | 'prev-time-slot' | 'next-time-slot' | 'select' | 'escape' | 'tab';
+declare function getKeyboardAction(key: string, viewType: SchedulerViewType): KeyboardAction | null;
+interface KeyboardNavigationOptions {
+    currentDate: Date;
+    firstDayOfWeek?: number;
+    slotDuration?: number;
+    slotMinTime?: string;
+    slotMaxTime?: string;
+}
+interface SchedulerKeyboardInput {
+    key: string;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+}
+declare function getStartOfWeek(date: Date, firstDayOfWeek?: number): Date;
+declare function getEndOfWeek(date: Date, firstDayOfWeek?: number): Date;
+declare function calculateNewFocusedDate(action: KeyboardAction, options: KeyboardNavigationOptions): Date | null;
+interface KeyboardNavigationResult {
+    action: KeyboardAction;
+    newFocusedDate: Date | null;
+    shouldPreventDefault: boolean;
+    shouldNavigate: 'prev' | 'next' | null;
+    shouldSelect: boolean;
+    shouldClearFocus: boolean;
+}
+declare function handleKeyboardNavigation(input: SchedulerKeyboardInput, viewType: SchedulerViewType, currentFocusedDate: Date | null, options: Omit<KeyboardNavigationOptions, 'currentDate'>): KeyboardNavigationResult | null;
+declare function getPeriodNavigationDirection(input: SchedulerKeyboardInput): 'prev' | 'next' | null;
+
+interface FocusContext {
+    viewType: SchedulerViewType;
+    currentDate: Date;
+    firstDayOfWeek?: number;
+    slotMinTime?: string;
+    slotMaxTime?: string;
+    slotDuration?: number;
+}
+interface MonthFocusContext extends FocusContext {
+    viewType: 'month';
+    grid: SchedulerGridCell[][];
+}
+interface WeekFocusContext extends FocusContext {
+    viewType: 'week';
+    columns: {
+        date: Date;
+        isToday?: boolean;
+    }[];
+}
+interface DayFocusContext extends FocusContext {
+    viewType: 'day';
+    isToday: boolean;
+}
+interface YearFocusContext extends FocusContext {
+    viewType: 'year';
+    displayedYear: number;
+}
+type ViewFocusContext = MonthFocusContext | WeekFocusContext | DayFocusContext | YearFocusContext;
+declare function snapTimeToSlot(date: Date, slotMinTime: string, slotDuration: number): Date;
+declare function clampTimeToSlotBounds(date: Date, slotMinTime: string, slotMaxTime: string, slotDuration: number): Date;
+declare function getDefaultFocusDateForMonth(grid: SchedulerGridCell[][]): Date;
+declare function getDefaultFocusDateForWeek(columns: {
+    date: Date;
+    isToday?: boolean;
+}[], slotMinTime: string, slotDuration: number): Date;
+declare function getDefaultFocusDateForDay(date: Date, isToday: boolean, slotMinTime: string, slotDuration: number): Date;
+declare function getDefaultFocusDateForYear(displayedYear: number): Date;
+declare function getDefaultFocusDate(context: ViewFocusContext): Date;
+declare function isDateInMonthView(date: Date, grid: SchedulerGridCell[][]): boolean;
+declare function isDateInWeekView(date: Date, columns: {
+    date: Date;
+}[]): boolean;
+declare function isDateInDayView(date: Date, viewDate: Date): boolean;
+declare function isDateInYearView(date: Date, displayedYear: number): boolean;
+declare function getNavigationDirectionForMonth(targetDate: Date, grid: SchedulerGridCell[][]): 'prev' | 'next' | null;
+declare function getNavigationDirectionForWeek(targetDate: Date, columns: {
+    date: Date;
+}[]): 'prev' | 'next' | null;
+declare function getNavigationDirectionForDay(targetDate: Date, viewDate: Date): 'prev' | 'next' | null;
+declare function getNavigationDirectionForYear(targetDate: Date, displayedYear: number): 'prev' | 'next' | null;
+declare function findCellForDate(date: Date, grid: SchedulerGridCell[][]): SchedulerGridCell | null;
+declare function getDisplayedMonthFromGrid(grid: SchedulerGridCell[][]): {
+    month: number;
+    year: number;
+};
+declare function getStartOfWeekForFocus(date: Date, firstDayOfWeek?: number): Date;
+declare function getEndOfWeekForFocus(date: Date, firstDayOfWeek?: number): Date;
+
+declare function formatEventTimeRange(event: SchedulerEvent, locale?: string, options?: TimeFormatOptions, timeZone?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatEventDate(event: SchedulerEvent, locale?: string, displayConfig?: SchedulerCalendarDisplayConfigInput): string;
+declare function formatEventDuration(event: SchedulerEvent): string;
+
+interface VirtualScrollState {
+    scrollLeft: number;
+    containerWidth: number;
+    totalWidth: number;
+    overscan: number;
+}
+interface VirtualRange {
+    startIndex: number;
+    endIndex: number;
+    startOffset: number;
+    visibleCells: TimelineCell[];
+}
+interface VirtualEventRange {
+    visibleEvents: TimelineEventPosition[];
+    leftBuffer: TimelineEventPosition[];
+    rightBuffer: TimelineEventPosition[];
+}
+declare const DEFAULT_OVERSCAN = 2;
+declare const VIRTUAL_THRESHOLD = 100;
+declare function shouldUseVirtualScrolling(totalCells: number, threshold?: number): boolean;
+declare function createVirtualScrollState(scrollLeft: number, containerWidth: number, totalWidth: number, overscan?: number): VirtualScrollState;
+declare function calculateVirtualRange(state: VirtualScrollState, cells: TimelineCell[]): VirtualRange;
+declare function calculateVisibleEvents(events: TimelineEventPosition[], scrollLeft: number, containerWidth: number, bufferWidth?: number): VirtualEventRange;
+declare function updateVirtualScrollState(state: VirtualScrollState, scrollLeft: number): VirtualScrollState;
+declare function getScrollPositionForDate(targetDate: Date, viewStart: Date, totalWidth: number, totalDuration: number, containerWidth: number, centerInView?: boolean): number;
+declare function getScrollPositionForNow(viewStart: Date, viewEnd: Date, totalWidth: number, containerWidth: number): number | null;
+declare function isDateInVisibleRange(date: Date, viewStart: Date, scrollLeft: number, containerWidth: number, totalWidth: number, totalDuration: number): boolean;
+interface ChunkedCells {
+    chunks: TimelineCell[][];
+    chunkWidth: number;
+    totalChunks: number;
+}
+declare function createChunkedCells(cells: TimelineCell[], chunkSize?: number): ChunkedCells;
+declare function getVisibleChunks(chunkedCells: ChunkedCells, scrollLeft: number, containerWidth: number, overscan?: number): {
+    startChunk: number;
+    endChunk: number;
+    visibleCells: TimelineCell[];
+};
+declare function calculateTotalWidth(cells: TimelineCell[]): number;
+declare function getEstimatedScrollPosition(targetIndex: number, averageCellWidth: number): number;
+declare function getCellAtPosition(scrollLeft: number, cells: TimelineCell[]): {
+    cell: TimelineCell;
+    index: number;
+} | null;
+
+interface NormalizedQuickInfoOptions extends Required<QuickInfoOptions> {
+}
+declare function normalizeQuickInfoOptions(options?: boolean | QuickInfoOptions): NormalizedQuickInfoOptions;
+
+interface NormalizedInlineEditOptions extends InlineEditOptions {
+    enabled: boolean;
+}
+declare function normalizeInlineEditOptions(options?: boolean | InlineEditOptions): NormalizedInlineEditOptions;
+
+interface ParsedTime {
+    hours: number;
+    minutes: number;
+}
+interface ParsedInlineEditTime {
+    start: Date;
+    end?: Date;
+    normalizedValue: string;
+}
+declare function toValidDate(value: Date | string | undefined): Date | null;
+declare function formatTimeToken(date: Date): string;
+declare function parseInlineTimeToken(input: string): ParsedTime | null;
+declare function getInlineEditTimeValue(event: SchedulerEvent): string;
+declare function parseInlineEditTimeValue(input: string, event: SchedulerEvent): ParsedInlineEditTime | null;
+declare function hasInlineTimeChanged(event: SchedulerEvent, start: Date, end?: Date): boolean;
+
+interface ResourceConflictDecision {
+    canProceed: boolean;
+    conflicts: ConflictInfo[];
+}
+interface ResourceConflictEvaluationInput {
+    event: SchedulerEvent;
+    options: ConflictOptions;
+    resources: SchedulerResource[];
+    events: SchedulerEvent[];
+    targetResourceId?: string | number;
+}
+interface ResourceConflictRuntimeInput {
+    event: SchedulerEvent;
+    options: ConflictOptions;
+    resources: SchedulerResource[];
+    events: SchedulerEvent[];
+    currentDate: Date;
+    conflictedEventIds: (string | number)[];
+    decision: ResourceConflictDecision;
+}
+interface ResourceConflictRuntimeResult {
+    conflictedEventIds: (string | number)[];
+    conflictDetectedPayload?: ConflictDetectedPayload;
+    capacityExceededPayloads: CapacityExceededPayload[];
+}
+declare function dedupeConflicts(conflicts: ConflictInfo[]): ConflictInfo[];
+declare function projectEventsWithCandidate(events: SchedulerEvent[], event: SchedulerEvent): SchedulerEvent[];
+declare function updateConflictedEventIds(conflictedEventIds: (string | number)[], eventId: string | number, hasConflict: boolean): (string | number)[];
+declare function evaluateResourceConflictDecision(input: ResourceConflictEvaluationInput): ResourceConflictDecision;
+declare function resolveCapacityExceededPayloads(event: SchedulerEvent, conflicts: ConflictInfo[], resources: SchedulerResource[], events: SchedulerEvent[], currentDate: Date): CapacityExceededPayload[];
+declare function resolveResourceConflictRuntime(input: ResourceConflictRuntimeInput): ResourceConflictRuntimeResult;
+
+interface ConflictEmitInstruction {
+    conflictDetected?: ConflictDetectedPayload;
+    capacityExceeded: CapacityExceededPayload[];
+}
+interface ConflictWorkflowResult {
+    decision: ResourceConflictDecision;
+    conflictedEventIds: (string | number)[];
+    emits: ConflictEmitInstruction;
+}
+interface ProcessConflictDecisionInput {
+    event: SchedulerEvent;
+    options: ConflictOptions;
+    resources: SchedulerResource[];
+    events: SchedulerEvent[];
+    currentDate: Date;
+    conflictedEventIds: (string | number)[];
+    targetResourceId?: string | number;
+}
+interface EvaluateDropConflictInput {
+    event: SchedulerEvent;
+    options: ConflictOptions;
+    resources: SchedulerResource[];
+    events: SchedulerEvent[];
+    dropStart: Date;
+    dropEnd: Date;
+    dropResourceId?: string | number;
+}
+interface BuildResourceCapacityMapInput {
+    options: ConflictOptions;
+    flatResources: SchedulerResource[];
+    events: SchedulerEvent[];
+    currentDate: Date;
+}
+declare function processConflictDecision(input: ProcessConflictDecisionInput): ConflictWorkflowResult;
+declare function evaluateDropConflict(input: EvaluateDropConflictInput): boolean;
+declare function buildResourceCapacityMap(input: BuildResourceCapacityMapInput): Record<string, ResourceCapacityInfo>;
+
+interface GlobalKeyboardContext {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    popoverVisible: boolean;
+    quickInfoVisible: boolean;
+    morePopoverVisible: boolean;
+    focusedEventId: string | null;
+    isInsideRoot: boolean;
+    isEditableElement: boolean;
+    selectedEventCount: number;
+    eventSelectionEnabled: boolean;
+    availableViewCount: number;
+}
+type GlobalKeyAction = {
+    type: 'dismiss-popover';
+} | {
+    type: 'dismiss-quickinfo';
+} | {
+    type: 'dismiss-more-popover';
+} | {
+    type: 'activate-event';
+    eventId: string;
+} | {
+    type: 'escape-event-focus';
+} | {
+    type: 'delete-events';
+} | {
+    type: 'switch-view';
+    viewIndex: number;
+} | {
+    type: 'navigate';
+    direction: 'prev' | 'next';
+} | {
+    type: 'go-today';
+} | {
+    type: 'select-all';
+} | {
+    type: 'clear-event-selection';
+} | {
+    type: 'none';
+};
+declare function resolveGlobalKeyAction(ctx: GlobalKeyboardContext): GlobalKeyAction;
+interface OutsideClickContext {
+    isOutside: boolean;
+    isDragging: boolean;
+    unselectOnOutsideClick: boolean;
+    hasFocus: boolean;
+    hasDateSelection: boolean;
+    hasEventSelection: boolean;
+    eventSelectionEnabled: boolean;
+}
+interface OutsideClickAction {
+    clearFocus: boolean;
+    clearDateSelection: boolean;
+    clearEventSelection: boolean;
+}
+declare function resolveOutsideClickAction(ctx: OutsideClickContext): OutsideClickAction;
+
+interface ColumnTimedOffset {
+    colIndexOffset: number;
+    milliseconds: number;
+}
+declare function getTimeOfDayMs(date: Date): number;
+declare function getDayOffset(anchor: Date, target: Date): number;
+declare function getSelectedEventsForMultiDrag(selectedIds: (string | number)[], events: SchedulerEvent[]): SchedulerEvent[];
+declare function isMultiDragCandidate(selectedIds: (string | number)[], anchorId: string | number): boolean;
+declare function computeTimedMultiDragOffsets(anchorStart: Date, selectedEvents: SchedulerEvent[]): Map<string | number, number>;
+declare function computeColumnTimedMultiDragOffsets(anchorStart: Date, anchorColIndex: number, selectedEvents: SchedulerEvent[], getColumnIndex: (date: Date) => number): Map<string | number, ColumnTimedOffset>;
+declare function computeDayMultiDragOffsets(anchorStart: Date, selectedEvents: SchedulerEvent[]): Map<string | number, number>;
+
+declare function isPermissionAllowed<TNativeEvent = unknown>(resolver: SchedulerPermissionResolver<TNativeEvent> | undefined, ctx: SchedulerPermissionContext<TNativeEvent>): boolean;
+declare function filterEventsByPermission<TNativeEvent = unknown>(events: SchedulerEvent[], action: SchedulerPermissionAction, resolver: SchedulerPermissionResolver<TNativeEvent> | undefined, view: SchedulerViewType): SchedulerEvent[];
+declare function isEventDraggableWithPermission<TNativeEvent = unknown>(event: SchedulerEvent, globalEditable: boolean, eventStartEditable: boolean, resolver: SchedulerPermissionResolver<TNativeEvent> | undefined, view: SchedulerViewType): boolean;
+declare function isEventResizableWithPermission<TNativeEvent = unknown>(event: SchedulerEvent, globalEditable: boolean, eventDurationEditable: boolean, resolver: SchedulerPermissionResolver<TNativeEvent> | undefined, view: SchedulerViewType): boolean;
+
+export { type AutoScrollDelta, type AutoScrollRect, type AutoScrollTarget, type BuildResourceCapacityMapInput, type ChunkedCells, type ColumnTimedOffset, type ConflictEmitInstruction, type ConflictWorkflowResult, DEFAULT_OVERSCAN, type DayFocusContext, type DragAutoScroller, type DragAutoScrollerOptions, type EvaluateDropConflictInput, type EventSelectionModifiers, type EventSelectionResult, type FocusContext, type GlobalKeyAction, type GlobalKeyboardContext, type KeyboardAction, type KeyboardNavigationOptions, type KeyboardNavigationResult, type MonthFocusContext, type NormalizedEventSelectionOptions, type NormalizedInlineEditOptions, type NormalizedQuickInfoOptions, type OutsideClickAction, type OutsideClickContext, type ParsedInlineEditTime, type ParsedTime, type ProcessConflictDecisionInput, RESIZE_HANDLE_SIZE, RESOURCE_VIEWS, type ResolveAutoScrollDeltaInput, type ResourceConflictDecision, type ResourceConflictEvaluationInput, type ResourceConflictRuntimeInput, type ResourceConflictRuntimeResult, type SchedulerEventResizeEdge, type SchedulerEventResizePreview, type SchedulerEventResizePreviewResult, type SchedulerKeyboardInput, VIRTUAL_THRESHOLD, type ViewFocusContext, type VirtualEventRange, type VirtualRange, type VirtualScrollState, type WeekFocusContext, type YearFocusContext, applyEventSelection, applyResizeToEvent, buildResourceCapacityMap, calculateNewEventTimes, calculateNewFocusedDate, calculateTotalWidth, calculateVirtualRange, calculateVisibleEvents, clampTimeToSlotBounds, clearEventSelection, computeColumnTimedMultiDragOffsets, computeDayMultiDragOffsets, computeTimedMultiDragOffsets, createChunkedCells, createDragAutoScroller, createResizeState, createVirtualScrollState, dedupeConflicts, detectResizeEdge, evaluateDropConflict, evaluateResourceConflictDecision, eventBelongsToResource, filterEventsByPermission, filterVisibleIdsByResource, findCellForDate, formatEventDate, formatEventDuration, formatEventTimeRange, formatTimeToken, getCellAtPosition, getDayOffset, getDefaultFocusDate, getDefaultFocusDateForDay, getDefaultFocusDateForMonth, getDefaultFocusDateForWeek, getDefaultFocusDateForYear, getDisplayedMonthFromGrid, getEndOfWeek, getEndOfWeekForFocus, getEstimatedScrollPosition, getInlineEditTimeValue, getKeyboardAction, getNavigationDirectionForDay, getNavigationDirectionForMonth, getNavigationDirectionForWeek, getNavigationDirectionForYear, getPeriodNavigationDirection, getResizeCursor, getSchedulerTimedResizePreview, getSchedulerTimelineResizePreview, getScrollPositionForDate, getScrollPositionForNow, getSelectedEventsForMultiDrag, getStartOfWeek, getStartOfWeekForFocus, getTimeOfDayMs, getVisibleChunks, handleKeyboardNavigation, hasInlineTimeChanged, invertSelection, isDateInDayView, isDateInMonthView, isDateInVisibleRange, isDateInWeekView, isDateInYearView, isEventDraggableWithPermission, isEventResizable, isEventResizableWithPermission, isMultiDragCandidate, isPermissionAllowed, isResourceView, normalizeEventSelectionOptions, normalizeInlineEditOptions, normalizeQuickInfoOptions, parseInlineEditTimeValue, parseInlineTimeToken, processConflictDecision, projectEventsWithCandidate, resolveAutoScrollDelta, resolveCapacityExceededPayloads, resolveGlobalKeyAction, resolveOutsideClickAction, resolveResourceConflictRuntime, selectAllVisibleEvents, shouldUseVirtualScrolling, snapTimeToSlot, toValidDate, updateConflictedEventIds, updateResizeState, updateVirtualScrollState, validateResize };

package/dist/interaction/index.mjs

@@ -0,0 +1,9 @@
+export { DEFAULT_DRAG_MIN_DISTANCE, DEFAULT_OVERSCAN, DEFAULT_SNAP_DURATION, RESIZE_HANDLE_SIZE, RESOURCE_VIEWS, VIRTUAL_THRESHOLD, applyDeltaToEvent, applyEventSelection, applyResizeToEvent, buildResourceCapacityMap, calculateDayDelta, calculateDragDelta, calculateNewEventTimes, calculateNewFocusedDate, calculateTimeDelta, calculateTotalWidth, calculateVirtualRange, calculateVisibleEvents, clampTime, clampTimeToSlotBounds, clearEventSelection, computeColumnTimedMultiDragOffsets, computeDayMultiDragOffsets, computeTimedMultiDragOffsets, createChunkedCells, createDragAutoScroller, createDragState, createResizeState, createSchedulerEventDropCandidate, createVirtualScrollState, dedupeConflicts, detectResizeEdge, evaluateDropConflict, evaluateResourceConflictDecision, eventBelongsToResource, filterEventsByPermission, filterVisibleIdsByResource, findCellForDate, findOverlappingEvents, formatEventDate, formatEventDuration, formatEventTimeRange, formatTimeToken, getCellAtPosition, getDayIndexFromX, getDayOffset, getDefaultFocusDate, getDefaultFocusDateForDay, getDefaultFocusDateForMonth, getDefaultFocusDateForWeek, getDefaultFocusDateForYear, getDisplayedMonthFromGrid, getEndOfWeek, getEndOfWeekForFocus, getEstimatedScrollPosition, getInlineEditTimeValue, getKeyboardAction, getNavigationDirectionForDay, getNavigationDirectionForMonth, getNavigationDirectionForWeek, getNavigationDirectionForYear, getPeriodNavigationDirection, getPointerCoords, getResizeCursor, getSchedulerEventDropDelta, getSchedulerTimedInteractionDeltaMs, getSchedulerTimedResizePreview, getSchedulerTimelineResizePreview, getScrollPositionForDate, getScrollPositionForNow, getSelectedEventsForMultiDrag, getStartOfWeek, getStartOfWeekForFocus, getTimeFromYPosition, getTimeOfDayMs, getVisibleChunks, getYPositionFromTime, handleKeyboardNavigation, hasInlineTimeChanged, invertSelection, isDateInDayView, isDateInMonthView, isDateInVisibleRange, isDateInWeekView, isDateInYearView, isEventDraggable, isEventDraggableWithPermission, isEventResizable, isEventResizableWithPermission, isMultiDragCandidate, isPermissionAllowed, isResourceView, normalizeEventSelectionOptions, normalizeInlineEditOptions, normalizeQuickInfoOptions, parseInlineEditTimeValue, parseInlineTimeToken, processConflictDecision, projectEventsWithCandidate, resolveAutoScrollDelta, resolveCapacityExceededPayloads, resolveGlobalKeyAction, resolveOutsideClickAction, resolveResourceConflictRuntime, selectAllVisibleEvents, shouldUseVirtualScrolling, snapTime, snapTimeToSlot, snapToSlot, toValidDate, updateConflictedEventIds, updateDragState, updateResizeState, updateVirtualScrollState, validateDragPosition, validateResize } from '../chunk-2THQAZ26.mjs';
+export { calculateDragRange, clearSelection, finalizeDragSelection, getActiveRange, handleDateSelection, handleTimeSelection, hasSelection, isDateInSelectionRange, isDateSelected, isRangeEnd, isRangeStart, startDragSelection, updateDragPreview } from '../chunk-NX46LPLF.mjs';
+import '../chunk-2B3YLWHA.mjs';
+import '../chunk-HPC5B3AR.mjs';
+import '../chunk-FIBAZFC4.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';
+import '../chunk-QR2SVYAD.mjs';

package/dist/month/index.d.mts

@@ -0,0 +1,104 @@
+import { SchedulerEvent, SchedulerCalendarMode, SchedulerNumberingSystem, DateRange } from '@primeui/scheduler-types/scheduler';
+import { WeekNumbering } from '@primeui/scheduler-types/date';
+
+interface MonthSpanningEventLayout {
+    event: SchedulerEvent;
+    row: number;
+    startCol: number;
+    endCol: number;
+    isContinuationStart: boolean;
+    isContinuationEnd: boolean;
+}
+interface MonthWeekEventLayout {
+    positioned: MonthSpanningEventLayout[];
+    overflowByDay: Record<string, SchedulerEvent[]>;
+    timedByDay: Record<string, SchedulerEvent[]>;
+    dayStats: Array<{
+        spanningDepth: number;
+        overflowCount: number;
+    }>;
+}
+declare function daysBetween(a: Date, b: Date): number;
+declare function durationDays(event: SchedulerEvent): number;
+declare function getEventsForMonthWeek(events: SchedulerEvent[], days: Date[]): SchedulerEvent[];
+declare function getEventsForMonthDay(events: SchedulerEvent[], date: Date): SchedulerEvent[];
+declare function getMonthSpanningEventLayout(event: SchedulerEvent, weekStart: Date): {
+    gridColumnStart: number;
+    gridColumnEnd: number;
+    row: number;
+} | null;
+declare function buildMonthWeekEventLayout(input: {
+    events: SchedulerEvent[];
+    weekStart: Date;
+    maxVisibleRows: number;
+    stackingMode?: 'stack' | 'collapse' | 'expand';
+}): MonthWeekEventLayout;
+
+interface MonthGridViewModelInput {
+    currentDate: Date;
+    firstDayOfWeek: number;
+    events: SchedulerEvent[];
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+    numberingSystem?: SchedulerNumberingSystem;
+    weekNumbering?: WeekNumbering;
+    minDate?: Date | null;
+    maxDate?: Date | null;
+    selectedDates?: Date[];
+    selectedRange?: DateRange | null;
+    maxVisibleRows: number;
+    stackingMode?: 'stack' | 'collapse' | 'expand';
+    now?: Date;
+    schedulerTimezone?: string;
+    resolvedDisplayTimezone?: string;
+}
+interface MonthGridDayCellViewModel {
+    date: Date;
+    dateKey: string;
+    dayOfMonth: number;
+    dayOfMonthLabel: string;
+    dayNumberLabel: string;
+    isCurrentMonth: boolean;
+    isToday: boolean;
+    isWeekend: boolean;
+    isDisabled: boolean;
+    isSelected: boolean;
+    isInRange: boolean;
+    isRangeStart: boolean;
+    isRangeEnd: boolean;
+    events: SchedulerEvent[];
+    timedEvents: SchedulerEvent[];
+    visibleEvents: SchedulerEvent[];
+    overflowEvents: SchedulerEvent[];
+    spanningDepth: number;
+    overflowCount: number;
+    eventCount: number;
+    owningEventCount: number;
+}
+interface MonthGridWeekViewModel {
+    days: MonthGridDayCellViewModel[];
+    weekNumber: number;
+    events: SchedulerEvent[];
+    layout: MonthWeekEventLayout;
+}
+interface MonthGridViewModel {
+    monthStart: Date;
+    monthEnd: Date;
+    monthTitle: string;
+    events: SchedulerEvent[];
+    weeks: MonthGridWeekViewModel[];
+    dayCells: MonthGridDayCellViewModel[];
+    getEventsForDay: (date: Date) => SchedulerEvent[];
+    getEventsForWeek: (days: Date[]) => SchedulerEvent[];
+    getEventLayout: (event: SchedulerEvent, weekStart: Date) => {
+        gridColumnStart: number;
+        gridColumnEnd: number;
+        row: number;
+    } | null;
+    getWeekLayout: (weekStart: Date) => MonthWeekEventLayout;
+    getOverflowCount: (date: Date, maxRows?: number) => number;
+    getOverflowEvents: (date: Date) => SchedulerEvent[];
+}
+declare function buildMonthGridViewModel(input: MonthGridViewModelInput): MonthGridViewModel;
+
+export { type MonthGridDayCellViewModel, type MonthGridViewModel, type MonthGridViewModelInput, type MonthGridWeekViewModel, type MonthSpanningEventLayout, type MonthWeekEventLayout, buildMonthGridViewModel, buildMonthWeekEventLayout, daysBetween, durationDays, getEventsForMonthDay, getEventsForMonthWeek, getMonthSpanningEventLayout };

package/dist/month/index.mjs

@@ -0,0 +1,6 @@
+import '../chunk-UMAMDBU4.mjs';
+export { buildMonthGridViewModel, buildMonthWeekEventLayout, daysBetween, durationDays, getEventsForMonthDay, getEventsForMonthWeek, getMonthSpanningEventLayout } from '../chunk-6PK5WSKT.mjs';
+import '../chunk-QDMZBJDV.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';

package/dist/overlay-BYM9B6nC.d.mts

@@ -0,0 +1,64 @@
+import { TimeFormatOptions, AppointmentSlot, AppointmentSlotStatus, AppointmentSlotDisplayMode, AppointmentSlotsOptions, SchedulerEvent, SchedulerResource, ExpandedBlockedInterval, BlockedIntervalsOptions, BusinessHours } from '@primeui/scheduler-types/scheduler';
+import { S as SchedulerCalendarDisplayConfigInput } from './display-format-CLVvRt4I.mjs';
+
+declare const DEFAULT_APPOINTMENT_SLOTS_OPTIONS: AppointmentSlotsOptions;
+declare function normalizeAppointmentSlotsOptions(options: boolean | Partial<AppointmentSlotsOptions> | undefined): AppointmentSlotsOptions;
+declare function generateAppointmentSlots(date: Date, slotDuration: number, minTime: string, maxTime: string, resourceId?: string | number): AppointmentSlot[];
+declare function getSlotsForDay(options: AppointmentSlotsOptions, date: Date, resource?: SchedulerResource, minTime?: string, maxTime?: string): AppointmentSlot[];
+declare function getSlotsForTimeRange(options: AppointmentSlotsOptions, startDate: Date, endDate: Date, resource?: SchedulerResource, minTime?: string, maxTime?: string): AppointmentSlot[];
+declare function updateSlotAvailability(slot: AppointmentSlot, events: SchedulerEvent[]): AppointmentSlot;
+declare function updateSlotsAvailability(slots: AppointmentSlot[], events: SchedulerEvent[]): AppointmentSlot[];
+declare function canBookSlot(slot: AppointmentSlot): boolean;
+declare function getSlotAtTime(slots: AppointmentSlot[], date: Date, resourceId?: string | number): AppointmentSlot | undefined;
+declare function getSlotsInTimeRange(slots: AppointmentSlot[], start: Date, end: Date, resourceId?: string | number): AppointmentSlot[];
+declare function getAvailableSlots(slots: AppointmentSlot[]): AppointmentSlot[];
+declare function getSlotCapacityDisplay(slot: AppointmentSlot): string;
+declare function getSlotById(slots: AppointmentSlot[], id: string | number): AppointmentSlot | undefined;
+declare function createSlotFromTimeRange(start: Date, end: Date, resourceId?: string | number, options?: Partial<AppointmentSlot>): AppointmentSlot;
+interface AppointmentSlotOverlay {
+    slot: AppointmentSlot;
+    top: number;
+    height: number;
+    status: AppointmentSlotStatus;
+    capacityDisplay?: string;
+    displayMode: AppointmentSlotDisplayMode;
+}
+interface AppointmentSlotIndicator {
+    timeSlotMinutes: number;
+    top: number;
+    slots: AppointmentSlot[];
+    availableCount: number;
+    bookedCount: number;
+    blockedCount: number;
+    tentativeCount: number;
+    primaryStatus: AppointmentSlotStatus;
+}
+interface AppointmentSlotDisplayOptions extends SchedulerCalendarDisplayConfigInput {
+    timeFormat?: TimeFormatOptions;
+    dateOptions?: Intl.DateTimeFormatOptions;
+    includeDate?: boolean;
+}
+interface AppointmentSlotDisplayLabels {
+    dateLabel: string;
+    timeRangeLabel: string;
+    summaryLabel: string;
+    ariaLabel: string;
+}
+declare function getAppointmentSlotDisplayLabels(slot: AppointmentSlot, options?: AppointmentSlotDisplayOptions): AppointmentSlotDisplayLabels;
+declare function getAppointmentSlotOverlays(options: AppointmentSlotsOptions, date: Date, events: SchedulerEvent[], slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number, resourceId?: string | number): AppointmentSlotOverlay[];
+declare function getAppointmentSlotIndicators(options: AppointmentSlotsOptions, date: Date, events: SchedulerEvent[], slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number, resourceId?: string | number): AppointmentSlotIndicator[];
+declare function getSlotOverlayClasses(overlay: AppointmentSlotOverlay): string[];
+declare function getSlotOverlayStyle(overlay: AppointmentSlotOverlay): Record<string, string>;
+
+interface TimedOverlay {
+    style: Record<string, string>;
+    title?: string;
+    className?: string;
+    interval?: ExpandedBlockedInterval;
+}
+declare function getTimedBusinessHoursOverlays(date: Date, businessHours: BusinessHours, slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number): Array<Record<string, string>>;
+declare function getTimedBlockedIntervalsOverlays(date: Date, blockedIntervals: BlockedIntervalsOptions | undefined, slotMinTime: string, slotMaxTime: string, slotDuration: number, slotHeight: number, resourceId?: string | number): TimedOverlay[];
+declare function isSlotInBusinessHours(slotTime: Date, date: Date, businessHours: BusinessHours | undefined): boolean;
+declare function isSlotInBlockedInterval(slotTime: Date, date: Date, slotDuration: number, blockedIntervals: BlockedIntervalsOptions | undefined, resourceId?: string | number): boolean;
+
+export { type AppointmentSlotDisplayLabels as A, DEFAULT_APPOINTMENT_SLOTS_OPTIONS as D, type TimedOverlay as T, type AppointmentSlotDisplayOptions as a, type AppointmentSlotIndicator as b, type AppointmentSlotOverlay as c, canBookSlot as d, createSlotFromTimeRange as e, getAppointmentSlotDisplayLabels as f, generateAppointmentSlots as g, getAppointmentSlotIndicators as h, getAppointmentSlotOverlays as i, getAvailableSlots as j, getSlotAtTime as k, getSlotById as l, getSlotCapacityDisplay as m, getSlotOverlayClasses as n, getSlotOverlayStyle as o, getSlotsForDay as p, getSlotsForTimeRange as q, getSlotsInTimeRange as r, getTimedBlockedIntervalsOverlays as s, getTimedBusinessHoursOverlays as t, isSlotInBlockedInterval as u, isSlotInBusinessHours as v, normalizeAppointmentSlotsOptions as w, updateSlotAvailability as x, updateSlotsAvailability as y };