@primeui/scheduler-core 0.0.1-alpha.1

package/dist/resource/index.d.mts

@@ -0,0 +1,172 @@
+import { SchedulerResource, ResourceStoreState, ResourceStoreOptions, FlattenedResource, ResourceColumnLayout, ResourceRowLayout, ResourceGroupingOptions, ResourceFilterOptions } from '@primeui/scheduler-types/resource';
+export * from '@primeui/scheduler-types/resource';
+import { SchedulerEvent } from '@primeui/scheduler-types/scheduler';
+import { ResourceScalePolicyInput, ResourceScalePolicy, ResourceScaleStrategyInput, ResourceScaleStrategy } from '@primeui/scheduler-types/resource-scale';
+export { ResourceScalePolicy, ResourceScalePolicyInput, ResourceScaleStrategy, ResourceScaleStrategyInput, ResourceScaleTier } from '@primeui/scheduler-types/resource-scale';
+
+interface ResourceTreeMutationResult {
+    resources: SchedulerResource[];
+    changed: boolean;
+}
+declare function flattenResourceTree(resourceList: SchedulerResource[]): SchedulerResource[];
+declare function upsertResourceById(resourceList: SchedulerResource[], resource: SchedulerResource): SchedulerResource[];
+declare function addResourceToTree(resourceList: SchedulerResource[], resource: SchedulerResource, parentId?: string | number): ResourceTreeMutationResult;
+declare function updateResourceInTree(resourceList: SchedulerResource[], updatedResource: SchedulerResource): ResourceTreeMutationResult;
+declare function removeResourceFromTree(resourceList: SchedulerResource[], resourceId: string | number): ResourceTreeMutationResult;
+declare function setResourceExpansionInTree(resourceList: SchedulerResource[], resourceId: string | number, expanded: boolean): ResourceTreeMutationResult;
+declare function dedupeResourceIds(resourceIds: Array<string | number>): Array<string | number>;
+declare function areResourceIdSetsEqual(left: Array<string | number>, right: Array<string | number>): boolean;
+
+declare function createResourceStore(initialResources?: SchedulerResource[], options?: ResourceStoreOptions): ResourceStoreState;
+declare function flattenResources(resources: SchedulerResource[], expandedIds: Set<string | number>, resourceMap: Map<string | number, SchedulerResource>, depth?: number, ancestorIds?: (string | number)[], parentExpanded?: boolean): FlattenedResource[];
+declare function addResource(state: ResourceStoreState, resource: SchedulerResource, parentId?: string | number): ResourceStoreState;
+declare function updateResource(state: ResourceStoreState, resourceId: string | number, updates: Partial<SchedulerResource>): ResourceStoreState;
+declare function removeResource(state: ResourceStoreState, resourceId: string | number): ResourceStoreState;
+declare function expandResource(state: ResourceStoreState, resourceId: string | number): ResourceStoreState;
+declare function collapseResource(state: ResourceStoreState, resourceId: string | number): ResourceStoreState;
+declare function toggleResourceExpansion(state: ResourceStoreState, resourceId: string | number): ResourceStoreState;
+declare function expandAllResources(state: ResourceStoreState): ResourceStoreState;
+declare function collapseAllResources(state: ResourceStoreState): ResourceStoreState;
+declare function getResourceById(state: ResourceStoreState, resourceId: string | number): SchedulerResource | undefined;
+declare function getResourcesByIds(state: ResourceStoreState, resourceIds: (string | number)[]): SchedulerResource[];
+declare function getVisibleResources(state: ResourceStoreState): FlattenedResource[];
+declare function getChildResources(state: ResourceStoreState, parentId: string | number): SchedulerResource[];
+declare function getParentResource(state: ResourceStoreState, resourceId: string | number): SchedulerResource | undefined;
+declare function getAncestorResources(state: ResourceStoreState, resourceId: string | number): SchedulerResource[];
+declare function findResourceById(resources: SchedulerResource[], resourceId: string | number): SchedulerResource | undefined;
+declare function getAllResourceIds(resources: SchedulerResource[]): (string | number)[];
+declare function countResources(resources: SchedulerResource[]): number;
+interface HierarchicalHeaderCell {
+    resource: SchedulerResource;
+    colspan: number;
+    depth: number;
+    isLeaf: boolean;
+}
+interface HierarchicalHeaderRow {
+    depth: number;
+    cells: HierarchicalHeaderCell[];
+}
+declare function getLeafResources(resources: SchedulerResource[]): SchedulerResource[];
+declare function getMaxDepth(resources: SchedulerResource[], currentDepth?: number): number;
+declare function countLeafDescendants(resource: SchedulerResource): number;
+declare function getHierarchicalHeaderRows(resources: SchedulerResource[]): HierarchicalHeaderRow[];
+declare function groupResourcesByField(resources: SchedulerResource[], fieldName: string): SchedulerResource[];
+declare function hasHierarchy(resources: SchedulerResource[]): boolean;
+
+declare const DEFAULT_RESOURCE_AREA_WIDTH = 200;
+declare const DEFAULT_RESOURCE_ROW_HEIGHT = 40;
+declare const DEFAULT_RESOURCE_MIN_ROW_HEIGHT = 32;
+interface ResourceEventGroup {
+    resource: FlattenedResource;
+    events: SchedulerEvent[];
+}
+interface DateResourceGroup {
+    date: Date;
+    dateStr: string;
+    resources: {
+        resource: SchedulerResource;
+        events: SchedulerEvent[];
+    }[];
+}
+declare function groupEventsByResource(events: SchedulerEvent[], state: ResourceStoreState): ResourceEventGroup[];
+declare function groupEventsByDate(events: SchedulerEvent[], resources: SchedulerResource[], dates: Date[]): DateResourceGroup[];
+declare function getEventsForResource(events: SchedulerEvent[], resourceId: string | number): SchedulerEvent[];
+declare function getEventsWithoutResource(events: SchedulerEvent[]): SchedulerEvent[];
+declare function getResourceIdsForEvent(event: SchedulerEvent): (string | number)[];
+declare function assignEventToResource(event: SchedulerEvent, resourceId: string | number): SchedulerEvent;
+declare function moveEventToResource(event: SchedulerEvent, fromResourceId: string | number | undefined, toResourceId: string | number): SchedulerEvent;
+declare function addResourceToEvent(event: SchedulerEvent, resourceId: string | number): SchedulerEvent;
+declare function removeResourceFromEvent(event: SchedulerEvent, resourceId: string | number): SchedulerEvent;
+declare function calculateResourceRowLayouts(visibleResources: FlattenedResource[], rowHeight?: number, expandedRowHeights?: Map<string | number, number>, laneCounts?: Map<string | number, number>): ResourceRowLayout[];
+declare function calculateResourceColumnLayouts(resources: SchedulerResource[], totalWidth: number, minColumnWidth?: number): ResourceColumnLayout[];
+declare function getResourceAtPosition(layouts: ResourceRowLayout[], y: number): FlattenedResource | undefined;
+declare function getResourceColumnAtPosition(layouts: ResourceColumnLayout[], x: number): SchedulerResource | undefined;
+declare function sortResources(resources: SchedulerResource[], options: ResourceGroupingOptions): SchedulerResource[];
+declare function getTotalResourceHeight(layouts: ResourceRowLayout[]): number;
+declare function getResourceAreaWidth(options: ResourceGroupingOptions): number;
+declare function getResourceLabel(resource: SchedulerResource, options?: ResourceGroupingOptions): string;
+declare function calculateExpandedRowHeight(eventCount: number, eventHeight?: number, eventGap?: number, minHeight?: number, padding?: number): number;
+
+interface ResourceFilterResult {
+    filteredResources: SchedulerResource[];
+    flattenedResources: FlattenedResource[];
+    matchingIds: Set<string | number>;
+    visibleIds: Set<string | number>;
+}
+declare function filterResources(state: ResourceStoreState, query: string, options?: ResourceFilterOptions): ResourceFilterResult;
+declare function searchResources(resources: SchedulerResource[], query: string, predicate?: (resource: SchedulerResource, query: string) => boolean): SchedulerResource[];
+declare function createResourceFilter(options?: Partial<ResourceFilterOptions>): ResourceFilterOptions;
+declare function highlightMatch(text: string, query: string): {
+    text: string;
+    isMatch: boolean;
+}[];
+declare function getFilterStats(filterResult: ResourceFilterResult, totalCount: number): {
+    matchCount: number;
+    totalCount: number;
+    percentage: number;
+};
+
+declare function resolveResourceScalePolicy(input: ResourceScalePolicyInput): ResourceScalePolicy;
+
+declare function resolveResourceScaleStrategy(input: ResourceScaleStrategyInput): ResourceScaleStrategy;
+
+interface AdaptiveGroupingOptions {
+    enabled: boolean;
+    breakpoint?: number;
+    sidebarPosition?: 'left' | 'right';
+    sidebarWidth?: number | string;
+    showBreadcrumb?: boolean;
+    persistSelection?: boolean;
+}
+interface AdaptiveGroupingState {
+    isMobile: boolean;
+    isSidebarOpen: boolean;
+    selectedResourceId: string | number | null;
+    selectionPath: (string | number)[];
+}
+interface BreadcrumbItem {
+    id: string | number;
+    title: string;
+    isRoot?: boolean;
+}
+declare const DEFAULT_ADAPTIVE_BREAKPOINT = 768;
+declare const DEFAULT_SIDEBAR_WIDTH = 280;
+declare function createAdaptiveGroupingState(): AdaptiveGroupingState;
+declare function detectMobileMode(viewportWidth: number, breakpoint?: number): boolean;
+declare function getAncestorIds(resourceMap: Map<string | number, SchedulerResource>, resourceId: string | number): (string | number)[];
+declare function selectResource(state: AdaptiveGroupingState, resourceMap: Map<string | number, SchedulerResource>, resourceId: string | number, closeSidebarOnSelect?: boolean): AdaptiveGroupingState;
+declare function buildBreadcrumbPath(resourceMap: Map<string | number, SchedulerResource>, selectionPath: (string | number)[]): BreadcrumbItem[];
+declare function toggleSidebar(state: AdaptiveGroupingState): AdaptiveGroupingState;
+declare function openSidebar(state: AdaptiveGroupingState): AdaptiveGroupingState;
+declare function closeSidebar(state: AdaptiveGroupingState): AdaptiveGroupingState;
+declare function setMobileMode(state: AdaptiveGroupingState, isMobile: boolean): AdaptiveGroupingState;
+declare function navigateBreadcrumb(state: AdaptiveGroupingState, resourceMap: Map<string | number, SchedulerResource>, targetId: string | number): AdaptiveGroupingState;
+declare function getFilteredEventsForResource(events: SchedulerEvent[], resourceId: string | number | null, descendantIds?: (string | number)[]): SchedulerEvent[];
+declare function clearResourceSelection(state: AdaptiveGroupingState): AdaptiveGroupingState;
+declare function getSelectedResource(resourceMap: Map<string | number, SchedulerResource>, resourceId: string | number | null): SchedulerResource | null;
+declare function isResourceInPath(selectionPath: (string | number)[], resourceId: string | number): boolean;
+declare function getSelectionDepth(selectionPath: (string | number)[]): number;
+declare const adaptiveClasses: {
+    readonly container: "p-scheduler-adaptive";
+    readonly mobile: "p-scheduler-adaptive-mobile";
+    readonly desktop: "p-scheduler-adaptive-desktop";
+    readonly sidebar: "p-scheduler-adaptive-sidebar";
+    readonly sidebarOpen: "p-scheduler-adaptive-sidebar-open";
+    readonly sidebarLeft: "p-scheduler-adaptive-sidebar-left";
+    readonly sidebarRight: "p-scheduler-adaptive-sidebar-right";
+    readonly sidebarOverlay: "p-scheduler-adaptive-sidebar-overlay";
+    readonly sidebarHeader: "p-scheduler-adaptive-sidebar-header";
+    readonly sidebarBody: "p-scheduler-adaptive-sidebar-body";
+    readonly sidebarClose: "p-scheduler-adaptive-sidebar-close";
+    readonly breadcrumb: "p-scheduler-adaptive-breadcrumb";
+    readonly breadcrumbList: "p-scheduler-adaptive-breadcrumb-list";
+    readonly breadcrumbItem: "p-scheduler-adaptive-breadcrumb-item";
+    readonly breadcrumbItemWrapper: "p-scheduler-adaptive-breadcrumb-item-wrapper";
+    readonly breadcrumbSeparator: "p-scheduler-adaptive-breadcrumb-separator";
+    readonly breadcrumbCurrent: "p-scheduler-adaptive-breadcrumb-current";
+    readonly menuButton: "p-scheduler-adaptive-menu-button";
+    readonly secondaryToolbar: "p-scheduler-adaptive-secondary-toolbar";
+    readonly resourceSelected: "p-scheduler-adaptive-resource-selected";
+};
+
+export { type AdaptiveGroupingOptions, type AdaptiveGroupingState, type BreadcrumbItem, DEFAULT_ADAPTIVE_BREAKPOINT, DEFAULT_RESOURCE_AREA_WIDTH, DEFAULT_RESOURCE_MIN_ROW_HEIGHT, DEFAULT_RESOURCE_ROW_HEIGHT, DEFAULT_SIDEBAR_WIDTH, type DateResourceGroup, type HierarchicalHeaderCell, type HierarchicalHeaderRow, type ResourceEventGroup, type ResourceFilterResult, type ResourceTreeMutationResult, adaptiveClasses, addResource, addResourceToEvent, addResourceToTree, areResourceIdSetsEqual, assignEventToResource, buildBreadcrumbPath, calculateExpandedRowHeight, calculateResourceColumnLayouts, calculateResourceRowLayouts, clearResourceSelection, closeSidebar, collapseAllResources, collapseResource, countLeafDescendants, countResources, createAdaptiveGroupingState, createResourceFilter, createResourceStore, dedupeResourceIds, detectMobileMode, expandAllResources, expandResource, filterResources, findResourceById, flattenResourceTree, flattenResources, getAllResourceIds, getAncestorIds, getAncestorResources, getChildResources, getEventsForResource, getEventsWithoutResource, getFilterStats, getFilteredEventsForResource, getHierarchicalHeaderRows, getLeafResources, getMaxDepth, getParentResource, getResourceAreaWidth, getResourceAtPosition, getResourceById, getResourceColumnAtPosition, getResourceIdsForEvent, getResourceLabel, getResourcesByIds, getSelectedResource, getSelectionDepth, getTotalResourceHeight, getVisibleResources, groupEventsByDate, groupEventsByResource, groupResourcesByField, hasHierarchy, highlightMatch, isResourceInPath, moveEventToResource, navigateBreadcrumb, openSidebar, removeResource, removeResourceFromEvent, removeResourceFromTree, resolveResourceScalePolicy, resolveResourceScaleStrategy, searchResources, selectResource, setMobileMode, setResourceExpansionInTree, sortResources, toggleResourceExpansion, toggleSidebar, updateResource, updateResourceInTree, upsertResourceById };

package/dist/resource/index.mjs

@@ -0,0 +1 @@
+export { DEFAULT_ADAPTIVE_BREAKPOINT, DEFAULT_RESOURCE_AREA_WIDTH, DEFAULT_RESOURCE_MIN_ROW_HEIGHT, DEFAULT_RESOURCE_ROW_HEIGHT, DEFAULT_SIDEBAR_WIDTH, adaptiveClasses, addResource, addResourceToEvent, addResourceToTree, areResourceIdSetsEqual, assignEventToResource, buildBreadcrumbPath, calculateExpandedRowHeight, calculateResourceColumnLayouts, calculateResourceRowLayouts, clearResourceSelection, closeSidebar, collapseAllResources, collapseResource, countLeafDescendants, countResources, createAdaptiveGroupingState, createResourceFilter, createResourceStore, dedupeResourceIds, detectMobileMode, expandAllResources, expandResource, filterResources, findResourceById, flattenResourceTree, flattenResources, getAllResourceIds, getAncestorIds, getAncestorResources, getChildResources, getEventsForResource, getEventsWithoutResource, getFilterStats, getFilteredEventsForResource, getHierarchicalHeaderRows, getLeafResources, getMaxDepth, getParentResource, getResourceAreaWidth, getResourceAtPosition, getResourceById, getResourceColumnAtPosition, getResourceIdsForEvent, getResourceLabel, getResourcesByIds, getSelectedResource, getSelectionDepth, getTotalResourceHeight, getVisibleResources, groupEventsByDate, groupEventsByResource, groupResourcesByField, hasHierarchy, highlightMatch, isResourceInPath, moveEventToResource, navigateBreadcrumb, openSidebar, removeResource, removeResourceFromEvent, removeResourceFromTree, resolveResourceScalePolicy, resolveResourceScaleStrategy, searchResources, selectResource, setMobileMode, setResourceExpansionInTree, sortResources, toggleResourceExpansion, toggleSidebar, updateResource, updateResourceInTree, upsertResourceById } from '../chunk-QR2SVYAD.mjs';

package/dist/selection-CO_98HdS.d.mts

@@ -0,0 +1,56 @@
+import { DateRange } from '@primeui/scheduler-types/scheduler';
+
+type SelectionMode = 'none' | 'single' | 'multiple' | 'range';
+interface SelectionState {
+    selectedDates: Date[];
+    selectedRange: DateRange | null;
+    selectedTimeRange: DateRange | null;
+}
+interface DateSelectionResult {
+    selectedDates: Date[];
+    selectedRange: DateRange | null;
+    selectedTimeRange: DateRange | null;
+    changed: boolean;
+}
+interface TimeSelectionResult {
+    selectedDates: Date[];
+    selectedRange: DateRange | null;
+    selectedTimeRange: DateRange | null;
+    changed: boolean;
+}
+interface DragSelectionState {
+    isDragging: boolean;
+    dragStartDate: Date | null;
+    previewRange: DateRange | null;
+}
+interface DragStartResult {
+    isDragging: boolean;
+    dragStartDate: Date;
+    previewRange: DateRange;
+}
+interface DragMoveResult {
+    previewRange: DateRange;
+}
+interface DragEndResult {
+    selectedDates: Date[];
+    selectedRange: DateRange;
+    selectedTimeRange: DateRange | null;
+    isDragging: false;
+    dragStartDate: null;
+    previewRange: null;
+}
+declare function handleDateSelection(date: Date, mode: SelectionMode, currentState: SelectionState): DateSelectionResult;
+declare function handleTimeSelection(start: Date, end: Date, mode: SelectionMode): TimeSelectionResult;
+declare function startDragSelection(date: Date): DragStartResult;
+declare function calculateDragRange(startDate: Date, currentDate: Date): DateRange;
+declare function updateDragPreview(startDate: Date, currentDate: Date): DragMoveResult;
+declare function finalizeDragSelection(startDate: Date, endDate: Date): DragEndResult;
+declare function clearSelection(): SelectionState;
+declare function hasSelection(state: SelectionState): boolean;
+declare function isDateSelected(date: Date, selectedDates: Date[]): boolean;
+declare function isDateInSelectionRange(date: Date, range: DateRange | null): boolean;
+declare function isRangeStart(date: Date, range: DateRange | null): boolean;
+declare function isRangeEnd(date: Date, range: DateRange | null): boolean;
+declare function getActiveRange(selectedRange: DateRange | null, previewRange: DateRange | null, isDragging: boolean): DateRange | null;
+
+export { type DateSelectionResult as D, type SelectionMode as S, type TimeSelectionResult as T, type DragEndResult as a, type DragMoveResult as b, type DragSelectionState as c, type DragStartResult as d, type SelectionState as e, calculateDragRange as f, clearSelection as g, finalizeDragSelection as h, getActiveRange as i, handleDateSelection as j, handleTimeSelection as k, hasSelection as l, isDateInSelectionRange as m, isDateSelected as n, isRangeEnd as o, isRangeStart as p, startDragSelection as s, updateDragPreview as u };

package/dist/time-grid/index.d.mts

@@ -0,0 +1,92 @@
+import { SchedulerEvent, BlockedInterval, SchedulerViewType, DensityMode, BusinessHours, BlockedIntervalsOptions, AppointmentSlotsOptions, SchedulerCalendarMode } from '@primeui/scheduler-types/scheduler';
+import { SchedulerResource } from '@primeui/scheduler-types/resource';
+import { P as ParsedEvent } from '../event.utils-QSNdd-3W.mjs';
+import { P as PositionedEvent } from '../event.positioning-BdzAVPk7.mjs';
+import { T as TimedOverlay, c as AppointmentSlotOverlay, b as AppointmentSlotIndicator } from '../overlay-BYM9B6nC.mjs';
+import '../display-format-CLVvRt4I.mjs';
+
+interface TimeGridSlotModel {
+    time: string;
+    minutes: number;
+}
+interface TimeGridAllDayEventLayout {
+    event: SchedulerEvent;
+    row: number;
+    startCol: number;
+    endCol: number;
+    isContinuationStart: boolean;
+    isContinuationEnd: boolean;
+}
+interface TimeGridAllDayWeekLayout {
+    positioned: TimeGridAllDayEventLayout[];
+    overflowByDay: Record<string, SchedulerEvent[]>;
+    visibleRowCount: number;
+    gridRowCount: number;
+}
+interface TimeGridPositionedEventResult {
+    event: PositionedEvent;
+    top: number;
+    height: number;
+    left: number;
+    width: number;
+    zIndex: number;
+}
+interface TimeGridViewModelInput {
+    currentDate: Date;
+    currentView: SchedulerViewType;
+    firstDayOfWeek: number;
+    events: SchedulerEvent[];
+    resources?: SchedulerResource[];
+    slotDuration?: number;
+    slotMinTime?: string;
+    slotMaxTime?: string;
+    numberOfDays?: number;
+    daysOfWeek?: number[];
+    density?: DensityMode;
+    now?: Date;
+    nowIndicator?: boolean;
+    resolvedDisplayTimezone?: string;
+    showBusinessHours?: boolean;
+    businessHours?: BusinessHours;
+    blockedIntervals?: BlockedIntervalsOptions;
+    appointmentSlots?: AppointmentSlotsOptions;
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+}
+interface TimeGridViewModel {
+    days: Date[];
+    resources: SchedulerResource[];
+    slotDuration: number;
+    slotMinTime: string;
+    slotMaxTime: string;
+    slotHeight: number;
+    totalSlotCount: number;
+    totalHeight: number;
+    timeSlots: TimeGridSlotModel[];
+    parsedEvents: ParsedEvent[];
+    usesSpanningAllDayRow: boolean;
+    hasAllDayEvents: boolean;
+    nowIndicatorTop: number | null;
+    showNowIndicator: boolean;
+    getTimedEventsForColumn: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getAllDayEventsForDay: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getVisibleAllDayEventsForDay: (date: Date, resourceId?: string | number) => SchedulerEvent[];
+    getOverflowAllDayEventsForDay: () => SchedulerEvent[];
+    getPositionedTimedEvent: (event: SchedulerEvent, date: Date, resourceId?: string | number) => TimeGridPositionedEventResult | null;
+    getEventTopPosition: (event: SchedulerEvent) => number;
+    getEventHeight: (event: SchedulerEvent) => number;
+    getOverlapLayout: (event: SchedulerEvent, date: Date, resourceId?: string | number) => {
+        left: string;
+        width: string;
+        zIndex: number;
+    };
+    getWeekAllDayLayout: (resourceId?: string | number) => TimeGridAllDayWeekLayout;
+    getBusinessHoursOverlays: (date: Date) => Array<Record<string, string>>;
+    getBlockedIntervalOverlays: (date: Date, resourceId?: string | number) => TimedOverlay[];
+    getBlockedIntervalStyle: (interval: BlockedInterval, date: Date, resourceId?: string | number) => Record<string, string> | null;
+    getAppointmentSlotOverlaysForDay: (date: Date, resourceId?: string | number) => AppointmentSlotOverlay[];
+    getAppointmentSlotIndicatorsForDay: (date: Date, resourceId?: string | number) => AppointmentSlotIndicator[];
+}
+declare function buildTimeGridViewModel(input: TimeGridViewModelInput): TimeGridViewModel;
+
+export { type TimeGridAllDayEventLayout, type TimeGridAllDayWeekLayout, type TimeGridPositionedEventResult, type TimeGridSlotModel, type TimeGridViewModel, type TimeGridViewModelInput, buildTimeGridViewModel };

package/dist/time-grid/index.mjs

@@ -0,0 +1,13 @@
+export { buildTimeGridViewModel } from '../chunk-F5W5HD7S.mjs';
+import '../chunk-6VYWVIGM.mjs';
+import '../chunk-2B3YLWHA.mjs';
+import '../chunk-AAVM7UCG.mjs';
+import '../chunk-C7ADJGNV.mjs';
+import '../chunk-NZGJN7HG.mjs';
+import '../chunk-HPC5B3AR.mjs';
+import '../chunk-5KORIWDT.mjs';
+import '../chunk-FIBAZFC4.mjs';
+import '../chunk-QDMZBJDV.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';

package/dist/timeline/index.d.mts

@@ -0,0 +1,165 @@
+import { SchedulerViewType, SchedulerCalendarMode, SchedulerEvent } from '@primeui/scheduler-types/scheduler';
+import { SchedulerResource, FlattenedResource, ResourceRowLayout } from '@primeui/scheduler-types/resource';
+import { TimelineCell, TimelineEventPosition } from '@primeui/scheduler-types/timeline';
+
+declare const DEFAULT_TIMELINE_EVENT_MIN_HEIGHT = 36;
+declare const TIMELINE_LANE_GAP = 2;
+declare const TIMELINE_LANE_BASE_PADDING = 4;
+type TimelineResourceRowHeightMode = 'auto' | 'fixed';
+interface ResolveTimelineResourceRowHeightInput {
+    laneCount: number;
+    eventHeight?: number;
+    eventGap?: number;
+    minRowHeight?: number;
+    mode?: TimelineResourceRowHeightMode;
+}
+interface TimelineCellModel {
+    startDate: Date;
+    endDate: Date;
+    width: number;
+    label: string;
+    isToday: boolean;
+    isWeekend: boolean;
+}
+interface TimelineHeaderCellModel {
+    label: string;
+    width: number;
+    left: number;
+    startDate: Date;
+    endDate: Date;
+}
+interface TimelineHeaderTierModel {
+    cells: TimelineHeaderCellModel[];
+}
+interface TimelineLabelFormatters {
+    hour: (date: Date) => string;
+    day: (date: Date) => string;
+    month: (date: Date) => string;
+    monthYear: (date: Date) => string;
+    quarter: (quarterIndex: number) => string;
+}
+interface BuildTimelineCellsInput {
+    view: SchedulerViewType;
+    start: Date;
+    end: Date;
+    now: Date;
+    slotsPerDay: number;
+    slotDurationMin: number;
+    slotWidth: number;
+    minTimeMin: number;
+    dayWidth: number;
+    timezone?: string;
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+    labels: Pick<TimelineLabelFormatters, 'hour' | 'day' | 'month'>;
+}
+declare function resolveTimelineEventMinHeight(value: number | undefined): number;
+declare function getTimelineLaneStackHeight(laneCount: number, eventMinHeight: number, eventGap?: number): number;
+declare function resolveTimelineResourceRowHeight(input: ResolveTimelineResourceRowHeightInput): number;
+declare function isTimelineMonthGranularityView(view: SchedulerViewType): boolean;
+declare function getTimelineVisibleDayStarts(view: SchedulerViewType, start: Date, end: Date): Date[];
+declare function buildTimelineCells(input: BuildTimelineCellsInput): TimelineCellModel[];
+declare function buildTimelineHeaderTiers(input: {
+    view: SchedulerViewType;
+    cells: TimelineCellModel[];
+    visibleDayStarts: Date[];
+    dayWidth: number;
+    labels: Pick<TimelineLabelFormatters, 'day' | 'monthYear' | 'quarter'>;
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+}): TimelineHeaderTierModel[];
+declare function filterTimelineLaneEvents(events: SchedulerEvent[], input: {
+    resourceId?: string | number;
+    matchIds?: Set<string | number> | null;
+    viewStart: Date;
+    viewEnd: Date;
+}): SchedulerEvent[];
+declare function timeToTimelinePixels(input: {
+    date: Date;
+    view: SchedulerViewType;
+    cells: TimelineCellModel[];
+    visibleDayStarts: Date[];
+    dayWidth: number;
+    minTimeMin: number;
+    visibleMinutesPerDay: number;
+    totalWidth: number;
+}): number;
+declare function getTimelineEventRect(event: SchedulerEvent, input: Omit<Parameters<typeof timeToTimelinePixels>[0], 'date'> & {
+    fallbackDurationMinutes: number;
+}): {
+    left: number;
+    width: number;
+};
+declare function computeTimelineLaneAssignment(events: SchedulerEvent[], stackingMode?: 'stack' | 'collapse' | 'expand'): {
+    assignment: Map<string | number, number>;
+    laneCount: number;
+};
+
+interface TimelineViewModelVirtualRange {
+    startIndex: number;
+    endIndex: number;
+    startOffset: number;
+}
+interface TimelineViewModelInput {
+    view: SchedulerViewType;
+    viewStart: Date;
+    viewEnd: Date;
+    now: Date;
+    events: SchedulerEvent[];
+    resources?: SchedulerResource[];
+    visibleResources?: FlattenedResource[];
+    isResourceExpanded?: (resourceId: string | number) => boolean;
+    showAggregatedEvents?: boolean;
+    rowAutoHeight?: boolean;
+    resourceRowHeight?: number;
+    timelineEventMinHeight?: number;
+    stackingMode?: 'stack' | 'collapse' | 'expand';
+    slotDurationMin: number;
+    slotWidth: number;
+    minTimeMin: number;
+    maxTimeMin: number;
+    timezone?: string;
+    locale?: string;
+    calendar?: SchedulerCalendarMode;
+    labels: TimelineLabelFormatters;
+    virtualRange?: TimelineViewModelVirtualRange | null;
+}
+interface TimelineLaneModel {
+    resourceId?: string | number;
+    events: SchedulerEvent[];
+    assignment: Map<string | number, number>;
+    laneCount: number;
+    aggregateEvents: SchedulerEvent[];
+    aggregateCount: number;
+    isAggregated: boolean;
+}
+interface TimelineViewModel {
+    cells: TimelineCellModel[];
+    visibleDayStarts: Date[];
+    effectiveViewStart: Date;
+    effectiveViewEnd: Date;
+    totalWidth: number;
+    visibleMinutesPerDay: number;
+    resources: SchedulerResource[];
+    visibleResources: FlattenedResource[];
+    headerTiers: TimelineHeaderTierModel[];
+    visibleCells: TimelineCellModel[];
+    visibleHeaderTiers: TimelineHeaderTierModel[];
+    laneModels: Map<string | number | undefined, TimelineLaneModel>;
+    resourceLayouts: ResourceRowLayout[];
+    totalResourceHeight: number;
+    virtualScrollCells: TimelineCell[];
+    virtualScrollEvents: TimelineEventPosition[];
+    getEventsForLane: (resourceId?: string | number) => SchedulerEvent[];
+    getAggregateEvents: (resourceId: string | number | undefined) => SchedulerEvent[];
+    getAggregateCount: (resourceId: string | number | undefined) => number;
+    getEventLeft: (event: SchedulerEvent) => number;
+    getEventWidth: (event: SchedulerEvent) => number;
+    getEventLane: (event: SchedulerEvent, resourceId?: string | number) => number;
+    getLaneCount: (resourceId?: string | number) => number;
+    isAggregatedRow: (resourceId: string | number | undefined) => boolean;
+    timeToPixels: (date: Date) => number;
+}
+declare function buildTimelineViewModel(input: TimelineViewModelInput): TimelineViewModel;
+
+export { type BuildTimelineCellsInput, DEFAULT_TIMELINE_EVENT_MIN_HEIGHT, type ResolveTimelineResourceRowHeightInput, TIMELINE_LANE_BASE_PADDING, TIMELINE_LANE_GAP, type TimelineCellModel, type TimelineHeaderCellModel, type TimelineHeaderTierModel, type TimelineLabelFormatters, type TimelineLaneModel, type TimelineResourceRowHeightMode, type TimelineViewModel, type TimelineViewModelInput, type TimelineViewModelVirtualRange, buildTimelineCells, buildTimelineHeaderTiers, buildTimelineViewModel, computeTimelineLaneAssignment, filterTimelineLaneEvents, getTimelineEventRect, getTimelineLaneStackHeight, getTimelineVisibleDayStarts, isTimelineMonthGranularityView, resolveTimelineEventMinHeight, resolveTimelineResourceRowHeight, timeToTimelinePixels };

package/dist/timeline/index.mjs

@@ -0,0 +1,6 @@
+export { DEFAULT_TIMELINE_EVENT_MIN_HEIGHT, TIMELINE_LANE_BASE_PADDING, TIMELINE_LANE_GAP, buildTimelineCells, buildTimelineHeaderTiers, buildTimelineViewModel, computeTimelineLaneAssignment, filterTimelineLaneEvents, getTimelineEventRect, getTimelineLaneStackHeight, getTimelineVisibleDayStarts, isTimelineMonthGranularityView, resolveTimelineEventMinHeight, resolveTimelineResourceRowHeight, timeToTimelinePixels } from '../chunk-KQGRXTP5.mjs';
+import '../chunk-QDMZBJDV.mjs';
+import '../chunk-WFUJWDST.mjs';
+import '../chunk-TNKJPFGI.mjs';
+import '../chunk-DYW6WUHE.mjs';
+import '../chunk-QR2SVYAD.mjs';

package/dist/touch-BhsMWsjf.d.mts

@@ -0,0 +1,69 @@
+import { SchedulerEvent, DragDelta, EventDragState, DragConstraints } from '@primeui/scheduler-types/scheduler';
+import { SchedulerCalendarInteractionOptions } from './calendar/index.mjs';
+
+declare const DEFAULT_DRAG_MIN_DISTANCE = 5;
+declare const DEFAULT_SNAP_DURATION = 15;
+declare function createDragState(event: SchedulerEvent, startX: number, startY: number, offsetX: number, offsetY: number): EventDragState;
+declare function updateDragState(state: EventDragState, currentX: number, currentY: number, minDistance?: number): EventDragState;
+declare function snapToSlot(minutes: number, slotDuration: number): number;
+declare function snapTime(date: Date, slotDuration: number): Date;
+declare function calculateTimeDelta(pixelDelta: number, slotHeight: number, slotDuration: number, snapDuration?: number): number;
+declare function getSchedulerTimedInteractionDeltaMs(input: {
+    pixelDelta: number;
+    slotHeight: number;
+    slotDuration: number;
+    snapDuration: number;
+}): number;
+interface SchedulerDropCalendarOptions extends SchedulerCalendarInteractionOptions {
+}
+interface SchedulerEventDropCandidateInput extends SchedulerDropCalendarOptions {
+    source: SchedulerEvent;
+    date: Date;
+    resourceId?: string | number;
+    preserveTime?: boolean;
+}
+interface SchedulerEventDropCandidate {
+    next: SchedulerEvent;
+    nextStart: Date;
+    nextEnd: Date;
+    sourceStart: Date;
+    targetResourceId?: string | number;
+    delta: DragDelta;
+}
+declare function getSchedulerEventDropDelta(sourceStart: Date, nextStart: Date, options?: SchedulerDropCalendarOptions): DragDelta;
+declare function createSchedulerEventDropCandidate({ source, date, resourceId, preserveTime, calendar, locale, view }: SchedulerEventDropCandidateInput): SchedulerEventDropCandidate;
+declare function calculateDayDelta(pixelDelta: number, columnWidth: number): number;
+declare function applyDeltaToEvent(event: SchedulerEvent, delta: DragDelta, calendarOptions?: SchedulerCalendarInteractionOptions): SchedulerEvent;
+declare function validateDragPosition(event: SchedulerEvent, delta: DragDelta, constraints: DragConstraints, allEvents: SchedulerEvent[]): {
+    valid: boolean;
+    reason?: string;
+};
+declare function findOverlappingEvents(event: SchedulerEvent, allEvents: SchedulerEvent[]): SchedulerEvent[];
+declare function isEventDraggable(event: SchedulerEvent, globalEditable?: boolean, eventStartEditable?: boolean): boolean;
+declare function getTimeFromYPosition(yPosition: number, date: Date, slotMinTime: string, slotDuration: number, slotHeight: number): Date;
+declare function getYPositionFromTime(date: Date, slotMinTime: string, slotDuration: number, slotHeight: number): number;
+declare function getDayIndexFromX(x: number, columnWidth: number, numColumns: number): number;
+declare function clampTime(date: Date, slotMinTime: string, slotMaxTime: string): Date;
+declare function calculateDragDelta(state: EventDragState, columnWidth: number, slotHeight: number, slotDuration: number): DragDelta;
+
+interface SchedulerPointerInput {
+    clientX: number;
+    clientY: number;
+    button?: number;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+}
+interface SchedulerRectInput {
+    left: number;
+    top: number;
+    width?: number;
+    height: number;
+}
+declare function getPointerCoords(input: SchedulerPointerInput): {
+    clientX: number;
+    clientY: number;
+};
+
+export { DEFAULT_DRAG_MIN_DISTANCE as D, type SchedulerDropCalendarOptions as S, DEFAULT_SNAP_DURATION as a, type SchedulerEventDropCandidate as b, type SchedulerEventDropCandidateInput as c, type SchedulerPointerInput as d, type SchedulerRectInput as e, applyDeltaToEvent as f, calculateDayDelta as g, calculateDragDelta as h, calculateTimeDelta as i, clampTime as j, createDragState as k, createSchedulerEventDropCandidate as l, findOverlappingEvents as m, getDayIndexFromX as n, getPointerCoords as o, getSchedulerEventDropDelta as p, getSchedulerTimedInteractionDeltaMs as q, getTimeFromYPosition as r, getYPositionFromTime as s, isEventDraggable as t, snapTime as u, snapToSlot as v, updateDragState as w, validateDragPosition as x };