nuxt-ui-elements-pro 0.1.10 → 0.1.11

package/dist/runtime/server/api/_feedback.post.js

@@ -0,0 +1,115 @@
+import { defineEventHandler, readBody, createError, getRequestIP } from "h3";
+import { useRuntimeConfig } from "#imports";
+import { checkRateLimit } from "../utils/feedback-rate-limit.js";
+import { verifyCaptcha } from "../utils/feedback-captcha.js";
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event);
+  const feedbackConfig = config.uiElementsProFeedback;
+  if (!feedbackConfig) {
+    throw createError({ statusCode: 500, message: "Feedback not configured" });
+  }
+  const body = await readBody(event);
+  if (!body) {
+    throw createError({ statusCode: 400, message: "Request body is required" });
+  }
+  if (body._hp) {
+    return { success: true };
+  }
+  const ip = getRequestIP(event, { xForwardedFor: true }) ?? "unknown";
+  const maxRequests = feedbackConfig.rateLimitMax ?? 5;
+  const windowSeconds = feedbackConfig.rateLimitWindow ?? 3600;
+  const rateLimitResult = checkRateLimit(ip, maxRequests, windowSeconds);
+  if (!rateLimitResult.allowed) {
+    throw createError({
+      statusCode: 429,
+      message: `Rate limit exceeded. Try again in ${rateLimitResult.retryAfter} seconds.`
+    });
+  }
+  if (feedbackConfig.captchaSecretKey && feedbackConfig.captchaProvider) {
+    if (!body.captchaToken) {
+      throw createError({ statusCode: 400, message: "CAPTCHA token required" });
+    }
+    const captchaValid = await verifyCaptcha(
+      feedbackConfig.captchaProvider,
+      feedbackConfig.captchaSecretKey,
+      body.captchaToken,
+      ip
+    );
+    if (!captchaValid) {
+      throw createError({ statusCode: 400, message: "CAPTCHA verification failed" });
+    }
+  }
+  if (!body.type || !body.email?.trim() || !body.message?.trim()) {
+    throw createError({ statusCode: 400, message: "Missing required fields" });
+  }
+  const payload = {
+    type: body.type,
+    email: body.email.trim(),
+    message: body.message.trim(),
+    screenshot: body.screenshot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (feedbackConfig.webhook) {
+    try {
+      await $fetch(feedbackConfig.webhook, {
+        method: "POST",
+        body: payload
+      });
+    } catch {
+      throw createError({
+        statusCode: 502,
+        message: "Failed to forward feedback to webhook"
+      });
+    }
+  }
+  if (feedbackConfig.emailTo && feedbackConfig.smtpHost) {
+    try {
+      const nodemailer = await import("nodemailer");
+      const transporter = nodemailer.createTransport({
+        host: feedbackConfig.smtpHost,
+        port: feedbackConfig.smtpPort ?? 587,
+        secure: feedbackConfig.smtpSecure ?? false,
+        ...feedbackConfig.smtpUser ? {
+          auth: {
+            user: feedbackConfig.smtpUser,
+            pass: feedbackConfig.smtpPass
+          }
+        } : {}
+      });
+      const safeType = escapeHtml(payload.type);
+      const safeEmail = escapeHtml(payload.email);
+      const safeMessage = escapeHtml(payload.message).replace(/\n/g, "<br>");
+      await transporter.sendMail({
+        from: feedbackConfig.emailFrom ?? feedbackConfig.emailTo,
+        to: feedbackConfig.emailTo,
+        subject: `[Feedback] ${safeType}: from ${safeEmail}`,
+        html: [
+          `<h2>New Feedback (${safeType})</h2>`,
+          `<p><strong>From:</strong> ${safeEmail}</p>`,
+          `<p><strong>Type:</strong> ${safeType}</p>`,
+          `<p><strong>Message:</strong></p>`,
+          `<p>${safeMessage}</p>`,
+          payload.screenshot ? `<p><strong>Screenshot attached</strong></p>` : ""
+        ].join("\n"),
+        ...payload.screenshot ? {
+          attachments: [
+            {
+              filename: "screenshot.png",
+              content: payload.screenshot.replace(/^data:image\/png;base64,/, ""),
+              encoding: "base64"
+            }
+          ]
+        } : {}
+      });
+    } catch {
+      throw createError({
+        statusCode: 500,
+        message: "Failed to send feedback email"
+      });
+    }
+  }
+  return { success: true };
+});

package/dist/runtime/server/nodemailer.d.ts

@@ -0,0 +1,29 @@
+declare module "nodemailer" {
+  interface TransportOptions {
+    host?: string
+    port?: number
+    secure?: boolean
+    auth?: {
+      user?: string
+      pass?: string
+    }
+  }
+
+  interface MailOptions {
+    from?: string
+    to?: string
+    subject?: string
+    html?: string
+    attachments?: Array<{
+      filename?: string
+      content?: string
+      encoding?: string
+    }>
+  }
+
+  interface Transporter {
+    sendMail(options: MailOptions): Promise<any>
+  }
+
+  function createTransport(options: TransportOptions): Transporter
+}

package/dist/runtime/server/utils/feedback-captcha.d.ts

@@ -0,0 +1 @@
+export declare function verifyCaptcha(provider: string, secretKey: string, token: string, ip?: string): Promise<boolean>;

package/dist/runtime/server/utils/feedback-captcha.js

@@ -0,0 +1,27 @@
+const VERIFY_URLS = {
+  turnstile: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+  recaptcha: "https://www.google.com/recaptcha/api/siteverify",
+  hcaptcha: "https://api.hcaptcha.com/siteverify"
+};
+export async function verifyCaptcha(provider, secretKey, token, ip) {
+  const url = VERIFY_URLS[provider];
+  if (!url) {
+    console.warn(`[FeedbackWidget] Unknown CAPTCHA provider: ${provider}`);
+    return false;
+  }
+  try {
+    const params = {
+      secret: secretKey,
+      response: token
+    };
+    if (ip) params.remoteip = ip;
+    const result = await $fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(params).toString()
+    });
+    return result.success === true;
+  } catch {
+    return false;
+  }
+}

package/dist/runtime/server/utils/feedback-rate-limit.d.ts

@@ -0,0 +1,4 @@
+export declare function checkRateLimit(key: string, max: number, windowSeconds: number): {
+    allowed: boolean;
+    retryAfter?: number;
+};

package/dist/runtime/server/utils/feedback-rate-limit.js

@@ -0,0 +1,26 @@
+const store = /* @__PURE__ */ new Map();
+const cleanupTimer = setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of store) {
+    entry.timestamps = entry.timestamps.filter((t) => now - t < 72e5);
+    if (entry.timestamps.length === 0) store.delete(key);
+  }
+}, 6e5);
+cleanupTimer.unref();
+export function checkRateLimit(key, max, windowSeconds) {
+  const now = Date.now();
+  const windowMs = windowSeconds * 1e3;
+  let entry = store.get(key);
+  if (!entry) {
+    entry = { timestamps: [] };
+    store.set(key, entry);
+  }
+  entry.timestamps = entry.timestamps.filter((t) => now - t < windowMs);
+  if (entry.timestamps.length >= max) {
+    const oldestInWindow = entry.timestamps[0];
+    const retryAfter = Math.ceil((oldestInWindow + windowMs - now) / 1e3);
+    return { allowed: false, retryAfter };
+  }
+  entry.timestamps.push(now);
+  return { allowed: true };
+}

package/dist/runtime/types/event-calendar.d.ts

@@ -73,21 +73,25 @@ export interface MonthViewOptions {
 }
 /** Week view configuration */
 export interface WeekViewOptions {
-    /** First visible hour (0-23) @defaultValue 7 */
+    /** First visible hour (0-23) @defaultValue 0 */
     startHour?: number;
-    /** Last visible hour (0-23) @defaultValue 22 */
+    /** Last visible hour (0-24) @defaultValue 24 */
     endHour?: number;
     /** Minutes per time slot row @defaultValue 30 */
     slotDuration?: 15 | 30 | 60;
+    /** Hour to scroll to on initial render (0-23) @defaultValue 7 */
+    scrollTime?: number;
 }
 /** Day view configuration */
 export interface DayViewOptions {
-    /** First visible hour (0-23) @defaultValue 7 */
+    /** First visible hour (0-23) @defaultValue 0 */
     startHour?: number;
-    /** Last visible hour (0-23) @defaultValue 22 */
+    /** Last visible hour (0-24) @defaultValue 24 */
     endHour?: number;
     /** Minutes per time slot row @defaultValue 30 */
     slotDuration?: 15 | 30 | 60;
+    /** Hour to scroll to on initial render (0-23) @defaultValue 7 */
+    scrollTime?: number;
 }
 /** List/agenda view configuration */
 export interface ListViewOptions {
@@ -201,11 +205,13 @@ export interface EventCalendarContext {
         startHour: number;
         endHour: number;
         slotDuration: number;
+        scrollTime: number;
     }>;
     dayConfig: ComputedRef<{
         startHour: number;
         endHour: number;
         slotDuration: number;
+        scrollTime: number;
     }>;
     monthWeeks: ComputedRef<CalendarWeek[]>;
     monthWeekLayouts: ComputedRef<MonthWeekLayout[]>;

package/dist/runtime/types/feedback-widget.d.ts

@@ -0,0 +1,110 @@
+import type { ComputedRef, Ref } from "vue";
+/** Built-in feedback type identifiers */
+export type FeedbackTypeId = "bug" | "feature" | "general" | (string & {});
+/** A feedback type option shown in the type selector */
+export interface FeedbackType {
+    /** Unique identifier */
+    id: FeedbackTypeId;
+    /** Display label */
+    label: string;
+    /** Icon name (e.g., 'i-lucide-bug') */
+    icon?: string;
+    /** Description shown below label */
+    description?: string;
+}
+/** The data submitted in a feedback form */
+export interface FeedbackSubmission {
+    /** Feedback type ID */
+    type: FeedbackTypeId;
+    /** User email */
+    email: string;
+    /** Feedback message body */
+    message: string;
+    /** Optional screenshot as base64 data URL */
+    screenshot?: string;
+    /** Honeypot field value (should be empty for real users) */
+    _hp?: string;
+    /** CAPTCHA token (if captcha is enabled) */
+    captchaToken?: string;
+}
+/** Result from submission attempt */
+export interface FeedbackSubmitResult {
+    /** Whether submission succeeded */
+    success: boolean;
+    /** Optional error message */
+    error?: string;
+}
+/** Widget position on the screen */
+export type FeedbackWidgetPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left";
+export type CaptchaProvider = "turnstile" | "recaptcha" | "hcaptcha";
+export interface CaptchaConfig {
+    /** CAPTCHA provider */
+    provider: CaptchaProvider;
+    /** Public site key (exposed to client) */
+    siteKey: string;
+    /** Secret key (server-side only, never sent to client) */
+    secretKey: string;
+}
+export interface RateLimitConfig {
+    /** Maximum requests per window @defaultValue 5 */
+    max: number;
+    /** Window duration in seconds @defaultValue 3600 (1 hour) */
+    window: number;
+}
+export interface FeedbackEmailConfig {
+    /** Recipient email */
+    to: string;
+    /** Sender email */
+    from: string;
+    /** SMTP connection settings */
+    smtp: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        auth?: {
+            user: string;
+            pass: string;
+        };
+    };
+}
+export interface FeedbackModuleConfig {
+    /** Webhook URL to POST feedback JSON to */
+    webhook?: string;
+    /** Email delivery configuration */
+    email?: FeedbackEmailConfig;
+    /** CAPTCHA configuration */
+    captcha?: CaptchaConfig;
+    /** Rate limiting @defaultValue { max: 5, window: 3600 } */
+    rateLimit?: Partial<RateLimitConfig>;
+}
+export interface FeedbackWidgetContext {
+    isOpen: Ref<boolean>;
+    isSubmitting: Ref<boolean>;
+    isSubmitted: Ref<boolean>;
+    submitError: Ref<string | null>;
+    selectedType: Ref<FeedbackTypeId | null>;
+    email: Ref<string>;
+    message: Ref<string>;
+    screenshot: Ref<string | null>;
+    honeypot: Ref<string>;
+    feedbackTypes: ComputedRef<FeedbackType[]>;
+    position: ComputedRef<FeedbackWidgetPosition>;
+    showScreenshot: ComputedRef<boolean>;
+    emailPlaceholder: ComputedRef<string>;
+    messagePlaceholder: ComputedRef<string>;
+    captchaEnabled: ComputedRef<boolean>;
+    captchaProvider: ComputedRef<CaptchaProvider | null>;
+    captchaSiteKey: ComputedRef<string | null>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    reset: () => void;
+    submit: () => Promise<void>;
+    captureScreenshot: () => Promise<void>;
+    removeScreenshot: () => void;
+    setCaptchaToken: (token: string) => void;
+    isValid: ComputedRef<boolean>;
+    color: ComputedRef<string>;
+    ui: ComputedRef<any>;
+    propUi: ComputedRef<any>;
+}

package/dist/runtime/types/gantt-chart.d.ts

@@ -0,0 +1,223 @@
+import type { CalendarDate, DateValue } from "@internationalized/date";
+import type { ComputedRef, Ref } from "vue";
+/** All supported Gantt chart zoom levels */
+export type GanttZoomLevel = "day" | "week" | "month" | "quarter" | "year";
+/**
+ * A single task in the Gantt chart.
+ * Accepts flexible date inputs (Date, ISO string, or DateValue).
+ */
+export interface GanttTask {
+    /** Unique identifier */
+    id: string | number;
+    /** Display title */
+    title: string;
+    /** Task start date */
+    start: Date | string | DateValue;
+    /** Task end date (inclusive) */
+    end: Date | string | DateValue;
+    /** Parent task ID for hierarchy. Omit or set to null for top-level tasks. */
+    parentId?: string | number | null;
+    /** Nuxt UI color name (e.g., 'primary', 'success') */
+    color?: string;
+    /** Progress percentage 0-100 @defaultValue 0 */
+    progress?: number;
+    /** Whether this is a milestone (zero-duration marker). @defaultValue false */
+    milestone?: boolean;
+    /** Whether this task can be dragged. @defaultValue true */
+    draggable?: boolean;
+    /** Whether this task can be resized. @defaultValue true */
+    resizable?: boolean;
+    /** Arbitrary user-defined metadata passed through to slots */
+    metadata?: Record<string, unknown>;
+}
+/** A dependency link between two tasks */
+export interface GanttDependency {
+    /** Unique identifier for this dependency */
+    id: string | number;
+    /** Source task ID (predecessor — must finish before successor starts) */
+    fromId: string | number;
+    /** Target task ID (successor) */
+    toId: string | number;
+    /** Dependency type. @defaultValue 'finish-to-start' */
+    type?: "finish-to-start";
+}
+/** Internal normalized task with parsed CalendarDates */
+export interface NormalizedGanttTask {
+    id: string | number;
+    title: string;
+    start: CalendarDate;
+    end: CalendarDate;
+    parentId: string | number | null;
+    color: string;
+    progress: number;
+    milestone: boolean;
+    draggable: boolean;
+    resizable: boolean;
+    metadata: Record<string, unknown>;
+    original: GanttTask;
+}
+/** Internal tree node for hierarchical task groups */
+export interface GanttTaskTreeNode {
+    /** The normalized task data */
+    task: NormalizedGanttTask;
+    /** Direct children */
+    children: GanttTaskTreeNode[];
+    /** Depth in the tree (root-level = 0) */
+    depth: number;
+}
+/** Computed bar position for a single task */
+export interface GanttTaskBar {
+    /** The normalized task */
+    task: NormalizedGanttTask;
+    /** Row index in the flattened visible list */
+    rowIndex: number;
+    /** Depth (indent level) */
+    depth: number;
+    /** Is this a group (has children)? */
+    isGroup: boolean;
+    /** Is this group expanded? (only relevant if isGroup) */
+    isExpanded: boolean;
+    /** Number of direct children */
+    childCount: number;
+    /** Left offset in pixels from timeline start */
+    leftPx: number;
+    /** Width of the bar in pixels */
+    widthPx: number;
+    /** Whether this bar is a milestone diamond */
+    isMilestone: boolean;
+}
+/** A dependency arrow path */
+export interface GanttDependencyPath {
+    /** Original dependency data */
+    dependency: GanttDependency;
+    /** SVG path data string (d attribute) */
+    path: string;
+    /** Source task bar */
+    from: GanttTaskBar;
+    /** Target task bar */
+    to: GanttTaskBar;
+    /** Connection point on the source bar (right edge center) */
+    fromPoint: {
+        x: number;
+        y: number;
+    };
+    /** Connection point on the target bar (left edge center) */
+    toPoint: {
+        x: number;
+        y: number;
+    };
+}
+/** A column in the timeline header */
+export interface GanttTimelineColumn {
+    /** The date this column represents */
+    date: CalendarDate;
+    /** Display label for this column */
+    label: string;
+    /** Width in pixels */
+    widthPx: number;
+    /** Left offset in pixels */
+    leftPx: number;
+    /** Is today */
+    isToday: boolean;
+    /** Is weekend (Saturday or Sunday) */
+    isWeekend: boolean;
+}
+/** A header group (top-level grouping above columns) */
+export interface GanttHeaderGroup {
+    /** Display label (e.g., "January 2026", "Q1 2026") */
+    label: string;
+    /** Number of sub-columns this group spans */
+    span: number;
+    /** Left offset in pixels */
+    leftPx: number;
+    /** Total width in pixels */
+    widthPx: number;
+}
+/** Full layout result */
+export interface GanttLayout {
+    /** All visible task bars with positions */
+    taskBars: GanttTaskBar[];
+    /** All dependency arrow paths */
+    dependencyPaths: GanttDependencyPath[];
+    /** Timeline columns (bottom header row) */
+    columns: GanttTimelineColumn[];
+    /** Header groups (top header row) */
+    headerGroups: GanttHeaderGroup[];
+    /** Total timeline width in pixels */
+    totalWidth: number;
+    /** Total height in pixels (rows * rowHeight) */
+    totalHeight: number;
+    /** Today marker left offset in pixels, or null if not in view */
+    todayOffsetPx: number | null;
+}
+/** Per-zoom-level configuration */
+export interface GanttZoomConfig {
+    /** Pixel width per time unit at this zoom level */
+    unitWidth: number;
+}
+/** Resolved zoom presets (one entry per zoom level) */
+export type GanttZoomPresets = Record<GanttZoomLevel, GanttZoomConfig>;
+/** Payload emitted when a task is moved via drag */
+export interface GanttTaskDropPayload {
+    task: GanttTask;
+    oldStart: CalendarDate;
+    oldEnd: CalendarDate;
+    newStart: CalendarDate;
+    newEnd: CalendarDate;
+}
+/** Payload emitted when a task is resized */
+export interface GanttTaskResizePayload {
+    task: GanttTask;
+    oldStart: CalendarDate;
+    oldEnd: CalendarDate;
+    newStart: CalendarDate;
+    newEnd: CalendarDate;
+    /** Which handle was dragged */
+    edge: "start" | "end";
+}
+/** The context provided by GanttChart root to sub-components via provide/inject */
+export interface GanttChartContext {
+    zoomLevel: ComputedRef<GanttZoomLevel>;
+    locale: ComputedRef<string>;
+    editable: ComputedRef<boolean>;
+    loading: ComputedRef<boolean>;
+    color: ComputedRef<string>;
+    layout: ComputedRef<GanttLayout>;
+    rowHeight: ComputedRef<number>;
+    timelineStart: ComputedRef<CalendarDate>;
+    timelineEnd: ComputedRef<CalendarDate>;
+    headerTitle: ComputedRef<string>;
+    goToPrev: () => void;
+    goToNext: () => void;
+    goToToday: () => void;
+    setZoomLevel: (level: GanttZoomLevel) => void;
+    scrollToDate: (date: CalendarDate) => void;
+    scrollToTask: (taskId: string | number) => void;
+    zoomLevels: ComputedRef<GanttZoomLevel[]>;
+    expandedIds: Ref<Set<string | number>>;
+    toggleExpand: (id: string | number) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    isExpanded: (id: string | number) => boolean;
+    handleTaskClick: (task: NormalizedGanttTask, e: Event) => void;
+    getTaskStyle: (task: NormalizedGanttTask) => Record<string, string>;
+    draggedTaskId: Ref<string | number | null>;
+    dragPreview: Ref<{
+        leftPx: number;
+        widthPx: number;
+    } | null>;
+    onDragStart: (bar: GanttTaskBar, e: PointerEvent) => void;
+    resizingTaskId: Ref<string | number | null>;
+    resizeEdge: Ref<"start" | "end" | null>;
+    resizePreview: Ref<{
+        leftPx: number;
+        widthPx: number;
+    } | null>;
+    onResizePointerDown: (bar: GanttTaskBar, edge: "start" | "end", e: PointerEvent) => void;
+    focusedTaskId: Ref<string | number | null>;
+    onKeydown: (e: KeyboardEvent) => void;
+    dateToPixel: (date: CalendarDate) => number;
+    pixelToDate: (px: number) => CalendarDate;
+    ui: ComputedRef<any>;
+    propUi: ComputedRef<any>;
+}

package/dist/runtime/types/index.d.ts

@@ -2,3 +2,7 @@ export * from "./event-calendar.js";
 export * from "../components/EventCalendar.vue.js";
 export * from "./org-chart.js";
 export * from "../components/OrgChart.vue.js";
+export * from "./feedback-widget.js";
+export * from "../components/FeedbackWidget.vue.js";
+export * from "./gantt-chart.js";
+export * from "../components/GanttChart.vue.js";

package/dist/runtime/types/index.js

@@ -2,3 +2,7 @@ export * from "./event-calendar.js";
 export * from "../components/EventCalendar.vue";
 export * from "./org-chart.js";
 export * from "../components/OrgChart.vue";
+export * from "./feedback-widget.js";
+export * from "../components/FeedbackWidget.vue";
+export * from "./gantt-chart.js";
+export * from "../components/GanttChart.vue";

package/dist/runtime/utils/createComponentContext.d.ts

@@ -0,0 +1,15 @@
+import type { InjectionKey } from "vue";
+/**
+ * Creates a typed provide/inject context pair for compound components.
+ *
+ * @param componentName - Display name used in the Symbol key and error messages
+ *   (e.g. "EventCalendar", "FeedbackWidget").
+ * @returns An object with:
+ *   - `key`: An `InjectionKey<T>` symbol for `provide()` / `inject()`.
+ *   - `useContext`: A function that injects the context value and throws a
+ *     descriptive error when called outside the root component.
+ */
+export declare function createComponentContext<T>(componentName: string): {
+    key: InjectionKey<T>;
+    useContext: () => T;
+};

package/dist/runtime/utils/createComponentContext.js

@@ -0,0 +1,17 @@
+import { inject } from "vue";
+export function createComponentContext(componentName) {
+  const key = Symbol(`nuxt-ui-elements-pro.${kebab(componentName)}`);
+  function useContext() {
+    const ctx = inject(key);
+    if (!ctx) {
+      throw new Error(
+        `[${componentName}] use${componentName}Context() was called outside of a <UE${componentName}> root. Sub-components must be used as children of <UE${componentName}>.`
+      );
+    }
+    return ctx;
+  }
+  return { key, useContext };
+}
+function kebab(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}

package/dist/runtime/utils/date.d.ts

@@ -0,0 +1,10 @@
+import type { CalendarDate } from "@internationalized/date";
+/**
+ * Compute the start of the week for any weekStartsOn value (0=Sunday … 6=Saturday).
+ * Uses getDayOfWeek with a fixed locale ('en-US') so Sunday is always 0.
+ */
+export declare function startOfWeekByDay(date: CalendarDate, weekStartsOn: number): CalendarDate;
+/**
+ * Compute the end of the week for any weekStartsOn value.
+ */
+export declare function endOfWeekByDay(date: CalendarDate, weekStartsOn: number): CalendarDate;

package/dist/runtime/utils/date.js

@@ -0,0 +1,9 @@
+import { getDayOfWeek, toCalendarDate } from "@internationalized/date";
+export function startOfWeekByDay(date, weekStartsOn) {
+  const dow = getDayOfWeek(date, "en-US");
+  const diff = (dow - weekStartsOn + 7) % 7;
+  return toCalendarDate(date.subtract({ days: diff }));
+}
+export function endOfWeekByDay(date, weekStartsOn) {
+  return toCalendarDate(startOfWeekByDay(date, weekStartsOn).add({ days: 6 }));
+}