nuxt-ui-elements-pro 0.1.5 → 0.1.7

package/dist/runtime/utils/recurrence.js

@@ -0,0 +1,150 @@
+import {
+  asCalendarDate,
+  asCalendarDateTime,
+  startOf,
+  add,
+  subtract
+} from "#std/date";
+import { hasTimeComponent, startOfWeekByDay } from "./event-calendar.js";
+export function getVisibleRange(displayDate, view, weekStartsOn, fixedWeeks) {
+  if (view === "month") {
+    const monthStart = startOf(displayDate, "month");
+    const monthEnd = asCalendarDate(add(startOf(displayDate, "month"), 1, "month"));
+    const monthEndDate = asCalendarDate(subtract(monthEnd, 1, "day"));
+    const gridStart = asCalendarDate(subtract(startOfWeekByDay(monthStart, weekStartsOn), 1, "day"));
+    const gridEnd = fixedWeeks ? asCalendarDate(add(startOfWeekByDay(monthStart, weekStartsOn), 42, "day")) : asCalendarDate(add(startOfWeekByDay(monthEndDate, weekStartsOn).add({ days: 6 }), 1, "day"));
+    return { start: gridStart, end: gridEnd };
+  }
+  if (view === "week" || view === "list") {
+    const weekStart = startOfWeekByDay(asCalendarDate(displayDate), weekStartsOn);
+    return {
+      start: asCalendarDate(subtract(weekStart, 1, "day")),
+      end: asCalendarDate(add(weekStart, 7, "day"))
+    };
+  }
+  return {
+    start: asCalendarDate(subtract(displayDate, 1, "day")),
+    end: asCalendarDate(add(displayDate, 1, "day"))
+  };
+}
+function toFloatingUTC(value) {
+  if (hasTimeComponent(value)) {
+    const dt = value;
+    return new Date(Date.UTC(dt.year, dt.month - 1, dt.day, dt.hour, dt.minute, dt.second ?? 0));
+  }
+  return new Date(Date.UTC(value.year, value.month - 1, value.day));
+}
+function fromFloatingUTC(date, withTime) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  if (withTime) {
+    const hour = String(date.getUTCHours()).padStart(2, "0");
+    const minute = String(date.getUTCMinutes()).padStart(2, "0");
+    return asCalendarDateTime(`${year}-${month}-${day}T${hour}:${minute}`);
+  }
+  return asCalendarDate(`${year}-${month}-${day}`);
+}
+function parseDateValue(input) {
+  if (typeof input === "object" && "calendar" in input) {
+    return input;
+  }
+  if (input instanceof Date) {
+    const iso = input.toISOString();
+    if (iso.endsWith("T00:00:00.000Z")) {
+      return asCalendarDate(input);
+    }
+    return asCalendarDateTime(input);
+  }
+  if (typeof input === "string") {
+    if (input.includes("T") || input.includes(" ")) {
+      try {
+        return asCalendarDateTime(input);
+      } catch {
+        return asCalendarDate(input);
+      }
+    }
+    return asCalendarDate(input);
+  }
+  return asCalendarDate(/* @__PURE__ */ new Date());
+}
+function formatDtstart(date, allDay) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  if (allDay) {
+    return `DTSTART;VALUE=DATE:${y}${m}${d}`;
+  }
+  const hh = String(date.getUTCHours()).padStart(2, "0");
+  const mm = String(date.getUTCMinutes()).padStart(2, "0");
+  const ss = String(date.getUTCSeconds()).padStart(2, "0");
+  return `DTSTART:${y}${m}${d}T${hh}${mm}${ss}Z`;
+}
+export function expandRecurringEvents(events, range, rruleLib) {
+  return events.flatMap((event) => {
+    if (!event.rrule) return [event];
+    return expandSingleEvent(event, range, rruleLib);
+  });
+}
+function expandSingleEvent(event, range, rruleLib) {
+  const { rrulestr } = rruleLib;
+  const parsedStart = parseDateValue(event.start);
+  const isTimedEvent = hasTimeComponent(parsedStart);
+  const startAsUTC = toFloatingUTC(parsedStart);
+  let rruleString = event.rrule;
+  const hasExistingDtstart = /DTSTART[;:]/i.test(rruleString);
+  if (!hasExistingDtstart) {
+    const dtstart = formatDtstart(startAsUTC, !isTimedEvent);
+    if (!rruleString.startsWith("RRULE:")) {
+      rruleString = `RRULE:${rruleString}`;
+    }
+    rruleString = `${dtstart}
+${rruleString}`;
+  }
+  let ruleSet;
+  try {
+    const parsed = rrulestr(rruleString, { forceset: true });
+    ruleSet = parsed;
+  } catch (err) {
+    console.warn(`[UEEventCalendar] Failed to parse rrule for event "${event.id}":`, err);
+    return [event];
+  }
+  if (event.exdate?.length) {
+    for (const exd of event.exdate) {
+      const parsedEx = parseDateValue(exd);
+      ruleSet.exdate(toFloatingUTC(parsedEx));
+    }
+  }
+  const rangeStart = toFloatingUTC(range.start);
+  const rangeEnd = toFloatingUTC(range.end);
+  const occurrences = ruleSet.between(rangeStart, rangeEnd, true);
+  if (occurrences.length === 0) return [];
+  let durationMinutes = 0;
+  if (event.duration != null) {
+    durationMinutes = event.duration;
+  } else if (event.end) {
+    const parsedEnd = parseDateValue(event.end);
+    const endUTC = toFloatingUTC(parsedEnd);
+    durationMinutes = Math.round((endUTC.getTime() - startAsUTC.getTime()) / 6e4);
+  }
+  return occurrences.map((occDate) => {
+    const occStart = fromFloatingUTC(occDate, isTimedEvent);
+    const occEnd = durationMinutes > 0 ? fromFloatingUTC(new Date(occDate.getTime() + durationMinutes * 6e4), isTimedEvent) : occStart;
+    const occKey = isTimedEvent ? `${occStart.toString()}` : `${occStart.toString()}`;
+    return {
+      id: `${event.id}::${occKey}`,
+      title: event.title,
+      start: occStart,
+      end: occEnd,
+      color: event.color,
+      allDay: event.allDay,
+      draggable: event.draggable,
+      resizable: event.resizable,
+      recurringEventId: event.id
+    };
+  });
+}
+export async function expandRecurringEventsAsync(events, range) {
+  const rruleLib = await import("rrule");
+  return expandRecurringEvents(events, range, rruleLib);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-ui-elements-pro",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Pro components for nuxt-ui-elements",
   "license": "UNLICENSED",
   "files": [
@@ -46,23 +46,32 @@
   },
   "devDependencies": {
     "@nuxt/devtools": "3.2.1",
-    "@nuxt/ui": "4.4.0",
     "@nuxt/eslint-config": "1.15.1",
     "@nuxt/module-builder": "1.0.2",
     "@nuxt/schema": "4.3.1",
     "@nuxt/test-utils": "4.0.0",
+    "@nuxt/ui": "4.4.0",
     "@types/node": "latest",
-    "eslint": "10.0.0",
+    "@vue/test-utils": "2.4.6",
+    "eslint": "10.0.1",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-prettier": "5.5.5",
+    "happy-dom": "20.7.0",
     "nuxt": "4.3.1",
     "prettier": "3.8.1",
+    "rrule": "2.8.1",
     "typescript": "5.9.3",
     "vitest": "4.0.18",
-    "vue-tsc": "3.2.4"
+    "vue-tsc": "3.2.5"
   },
   "peerDependencies": {
-    "@nuxt/ui": "^4.0.0"
+    "@nuxt/ui": "^4.0.0",
+    "rrule": "^2.8.0"
+  },
+  "peerDependenciesMeta": {
+    "rrule": {
+      "optional": true
+    }
   },
-  "packageManager": "pnpm@10.30.0+sha512.2b5753de015d480eeb88f5b5b61e0051f05b4301808a82ec8b840c9d2adf7748eb352c83f5c1593ca703ff1017295bc3fdd3119abb9686efc96b9fcb18200937"
+  "packageManager": "pnpm@10.30.1+sha512.3590e550d5384caa39bd5c7c739f72270234b2f6059e13018f975c313b1eb9fefcc09714048765d4d9efe961382c312e624572c0420762bdc5d5940cdf9be73a"
 }