@primeui/scheduler-core 0.0.1-alpha.1

package/LICENSE

@@ -0,0 +1,23 @@
+# License
+
+MIT License
+
+Copyright (c) 2026 PrimeTek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# PrimeUI Calendar Core

package/dist/calendar/index.d.mts

@@ -0,0 +1,57 @@
+import { Calendar } from '@internationalized/date';
+import { SchedulerCalendarMode, SchedulerViewType } from '@primeui/scheduler-types/scheduler';
+
+interface SchedulerCalendarDate {
+    era?: string;
+    year: number;
+    month: number;
+    day: number;
+}
+interface SchedulerCalendarDuration {
+    days?: number;
+    months?: number;
+    years?: number;
+}
+interface SchedulerCalendarAdapter {
+    id: string;
+    fromDate(date: Date): SchedulerCalendarDate;
+    toDate(date: SchedulerCalendarDate): Date;
+    add(date: SchedulerCalendarDate, duration: SchedulerCalendarDuration): SchedulerCalendarDate;
+    startOfMonth(date: SchedulerCalendarDate): SchedulerCalendarDate;
+    endOfMonth(date: SchedulerCalendarDate): SchedulerCalendarDate;
+    startOfWeek(date: SchedulerCalendarDate, firstDayOfWeek: number): SchedulerCalendarDate;
+    getDayOfWeek(date: SchedulerCalendarDate): number;
+    getDaysInMonth(date: SchedulerCalendarDate): number;
+    getMonthsInYear(date: SchedulerCalendarDate): number;
+    compare(a: SchedulerCalendarDate, b: SchedulerCalendarDate): number;
+    isSameDay(a: SchedulerCalendarDate, b: SchedulerCalendarDate): boolean;
+}
+type SchedulerInternationalCalendarFactory = (calendarId: string) => Calendar | null | undefined;
+interface SchedulerCalendarAdapterOptions {
+    locale?: string;
+    createCalendar?: SchedulerInternationalCalendarFactory;
+}
+interface SchedulerCalendarInteractionOptions {
+    calendar?: SchedulerCalendarMode;
+    locale?: string;
+    view?: SchedulerViewType | string;
+}
+interface SchedulerCalendarIdResolution {
+    requestedCalendar: SchedulerCalendarMode;
+    locale: string;
+    calendarId: string;
+    isSupported: boolean;
+    fallbackCalendarId: string | null;
+}
+declare const schedulerInternationalCalendarIds: readonly ["gregory", "buddhist", "ethiopic", "ethioaa", "coptic", "hebrew", "indian", "islamic-civil", "islamic-tbla", "islamic-umalqura", "japanese", "persian", "roc"];
+type SchedulerInternationalCalendarId = (typeof schedulerInternationalCalendarIds)[number];
+declare const gregorianCalendarAdapter: SchedulerCalendarAdapter;
+declare function resolveSchedulerCalendarId(calendar?: SchedulerCalendarMode, options?: Pick<SchedulerCalendarAdapterOptions, 'locale' | 'createCalendar'>): SchedulerCalendarIdResolution;
+declare function isCalendarAdapterCorrectView(view: SchedulerViewType | string | undefined): boolean;
+declare function resolveSchedulerCalendarModeForView(calendar: SchedulerCalendarMode | undefined, view: SchedulerViewType | string | undefined): SchedulerCalendarMode;
+declare function moveDateToCalendarDay(sourceDate: Date, targetDay: Date, options?: SchedulerCalendarInteractionOptions): Date;
+declare function addCalendarDaysToDate(sourceDate: Date, days: number, options?: SchedulerCalendarInteractionOptions): Date;
+declare function differenceInCalendarDays(startDate: Date, endDate: Date, options?: SchedulerCalendarInteractionOptions): number;
+declare function getSchedulerCalendarAdapter(calendar?: SchedulerCalendarMode, options?: SchedulerCalendarAdapterOptions): SchedulerCalendarAdapter;
+
+export { type SchedulerCalendarAdapter, type SchedulerCalendarAdapterOptions, type SchedulerCalendarDate, type SchedulerCalendarDuration, type SchedulerCalendarIdResolution, type SchedulerCalendarInteractionOptions, type SchedulerInternationalCalendarFactory, type SchedulerInternationalCalendarId, addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds };

package/dist/calendar/index.mjs

@@ -0,0 +1 @@
+export { addCalendarDaysToDate, differenceInCalendarDays, getSchedulerCalendarAdapter, gregorianCalendarAdapter, isCalendarAdapterCorrectView, moveDateToCalendarDay, resolveSchedulerCalendarId, resolveSchedulerCalendarModeForView, schedulerInternationalCalendarIds } from '../chunk-DYW6WUHE.mjs';

package/dist/chunk-2B3YLWHA.mjs

@@ -0,0 +1,196 @@
+// src/event/event.utils.ts
+function isStartOfDay(date) {
+  return date.getHours() === 0 && date.getMinutes() === 0 && date.getSeconds() === 0 && date.getMilliseconds() === 0;
+}
+function normalizeAllDayEnd(start, end, allDay) {
+  if (!allDay) {
+    return end;
+  }
+  if (end.getTime() <= start.getTime() || !isStartOfDay(end)) {
+    return end;
+  }
+  return new Date(end.getTime() - 1);
+}
+function parseEventDate(date) {
+  if (!date) return null;
+  if (date instanceof Date) return date;
+  const parsed = new Date(date);
+  return isNaN(parsed.getTime()) ? null : parsed;
+}
+function getEventStart(event) {
+  return parseEventDate(event.start) ?? /* @__PURE__ */ new Date();
+}
+function getEventEnd(event) {
+  const start = getEventStart(event);
+  const end = parseEventDate(event.end);
+  if (end) return end;
+  if (typeof event.duration === "number" && Number.isFinite(event.duration) && event.duration > 0) {
+    return new Date(start.getTime() + event.duration);
+  }
+  return new Date(start.getTime() + 60 * 60 * 1e3);
+}
+function moveEventTo(event, target) {
+  const start = getEventStart(event);
+  const end = getEventEnd(event);
+  const duration = end.getTime() - start.getTime();
+  return {
+    ...event,
+    start: target,
+    end: new Date(target.getTime() + duration)
+  };
+}
+function resizeEventBy(event, minutes) {
+  const end = getEventEnd(event);
+  return {
+    ...event,
+    end: new Date(end.getTime() + minutes * 6e4)
+  };
+}
+function parseEvent(event) {
+  const start = parseEventDate(event.start);
+  if (!start) return null;
+  let end = parseEventDate(event.end);
+  if (!end) {
+    if (event.allDay) {
+      end = new Date(start);
+      end.setHours(23, 59, 59, 999);
+    } else {
+      end = new Date(start.getTime() + 60 * 60 * 1e3);
+    }
+  }
+  if (end < start) {
+    end = new Date(start.getTime() + 60 * 60 * 1e3);
+  }
+  end = normalizeAllDayEnd(start, end, event.allDay);
+  const durationMinutes = Math.round((end.getTime() - start.getTime()) / (1e3 * 60));
+  const startDay = new Date(start.getFullYear(), start.getMonth(), start.getDate());
+  const endDay = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  const spanDays = Math.ceil((endDay.getTime() - startDay.getTime()) / (1e3 * 60 * 60 * 24)) + 1;
+  const isMultiDay = spanDays > 1 || event.allDay === true;
+  return {
+    ...event,
+    start,
+    end,
+    durationMinutes,
+    isMultiDay,
+    spanDays
+  };
+}
+function parseEvents(events) {
+  const parsed = [];
+  for (const event of events) {
+    const p = parseEvent(event);
+    if (p) parsed.push(p);
+  }
+  return parsed;
+}
+function filterEventsByDateRange(events, rangeStart, rangeEnd) {
+  return events.filter((event) => {
+    return event.start <= rangeEnd && event.end >= rangeStart;
+  });
+}
+function filterEventsForDay(events, date) {
+  const dayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+  const dayEnd = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+  return events.filter((event) => {
+    return event.start <= dayEnd && event.end >= dayStart;
+  });
+}
+function sortEvents(events) {
+  return [...events].sort((a, b) => {
+    if (a.allDay && !b.allDay) return -1;
+    if (!a.allDay && b.allDay) return 1;
+    if (a.isMultiDay && !b.isMultiDay) return -1;
+    if (!a.isMultiDay && b.isMultiDay) return 1;
+    if (a.isMultiDay && b.isMultiDay) {
+      if (b.spanDays !== a.spanDays) return b.spanDays - a.spanDays;
+    }
+    const startDiff = a.start.getTime() - b.start.getTime();
+    if (startDiff !== 0) return startDiff;
+    return b.durationMinutes - a.durationMinutes;
+  });
+}
+function getEventStartMinutes(event) {
+  return event.start.getHours() * 60 + event.start.getMinutes();
+}
+function getEventEndMinutes(event) {
+  return event.end.getHours() * 60 + event.end.getMinutes();
+}
+function eventsOverlap(a, b) {
+  return a.start < b.end && a.end > b.start;
+}
+function getEventColor(event, defaultColor = "") {
+  return event.color || defaultColor;
+}
+function getEventTextColor(event, defaultTextColor = "") {
+  return event.textColor || defaultTextColor;
+}
+function getEventsForCell(events, cellDate) {
+  const cellYear = cellDate.getFullYear();
+  const cellMonth = cellDate.getMonth();
+  const cellDay = cellDate.getDate();
+  const cellStart = new Date(cellYear, cellMonth, cellDay, 0, 0, 0, 0);
+  const cellEnd = new Date(cellYear, cellMonth, cellDay, 23, 59, 59, 999);
+  return events.filter((event) => {
+    if (event.allDay || event.isMultiDay) {
+      const eventStartDay = new Date(event.start.getFullYear(), event.start.getMonth(), event.start.getDate());
+      const eventEndDay = new Date(event.end.getFullYear(), event.end.getMonth(), event.end.getDate(), 23, 59, 59, 999);
+      return cellStart <= eventEndDay && cellEnd >= eventStartDay;
+    }
+    return event.start.getFullYear() === cellYear && event.start.getMonth() === cellMonth && event.start.getDate() === cellDay;
+  });
+}
+function sortEventsForCell(events) {
+  return [...events].sort((a, b) => {
+    if (a.allDay && !b.allDay) return -1;
+    if (!a.allDay && b.allDay) return 1;
+    return a.start.getTime() - b.start.getTime();
+  });
+}
+function getVisibleEventsForCell(events, cellDate, maxEvents) {
+  const cellEvents = getEventsForCell(events, cellDate);
+  const sorted = sortEventsForCell(cellEvents);
+  if (maxEvents <= 0) {
+    return [];
+  }
+  if (sorted.length <= maxEvents) {
+    return sorted;
+  }
+  return sorted.slice(0, Math.max(0, maxEvents - 1));
+}
+function getOverflowCountForCell(events, cellDate, maxEvents) {
+  const cellEvents = getEventsForCell(events, cellDate);
+  const totalEvents = cellEvents.length;
+  if (totalEvents === 0) {
+    return 0;
+  }
+  const visibleCount = getVisibleEventsForCell(events, cellDate, maxEvents).length;
+  return Math.max(0, totalEvents - visibleCount);
+}
+function isEventStartOnDate(event, date) {
+  return event.start.getFullYear() === date.getFullYear() && event.start.getMonth() === date.getMonth() && event.start.getDate() === date.getDate();
+}
+function isEventEndOnDate(event, date) {
+  return event.end.getFullYear() === date.getFullYear() && event.end.getMonth() === date.getMonth() && event.end.getDate() === date.getDate();
+}
+function eventMatchesResource(event, resourceId) {
+  if (resourceId === void 0) return true;
+  return event.resourceId === resourceId || Boolean(event.resourceIds?.includes(resourceId));
+}
+function getEventsForDayAndResource(events, date, resourceId) {
+  const dayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+  const dayEnd = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+  return events.filter((event) => {
+    if (!eventMatchesResource(event, resourceId)) return false;
+    return event.start <= dayEnd && event.end >= dayStart;
+  });
+}
+function getTimedEventsForDayAndResource(events, date, resourceId) {
+  const dayEvents = getEventsForDayAndResource(events, date, resourceId);
+  return dayEvents.filter((event) => {
+    if (event.allDay) return false;
+    return event.start.getFullYear() === date.getFullYear() && event.start.getMonth() === date.getMonth() && event.start.getDate() === date.getDate();
+  });
+}
+
+export { eventMatchesResource, eventsOverlap, filterEventsByDateRange, filterEventsForDay, getEventColor, getEventEnd, getEventEndMinutes, getEventStart, getEventStartMinutes, getEventTextColor, getEventsForCell, getEventsForDayAndResource, getOverflowCountForCell, getTimedEventsForDayAndResource, getVisibleEventsForCell, isEventEndOnDate, isEventStartOnDate, moveEventTo, parseEvent, parseEventDate, parseEvents, resizeEventBy, sortEvents, sortEventsForCell };