nuxt-ui-elements-pro 0.1.5 → 0.1.7

package/dist/runtime/composables/useOrgChartSearch.js

@@ -0,0 +1,62 @@
+import { computed } from "vue";
+import { getAncestors } from "../utils/org-chart.js";
+export function useOrgChartSearch(options) {
+  const matchedIds = computed(() => {
+    const query = options.searchQuery().trim().toLowerCase();
+    if (!query) return /* @__PURE__ */ new Set();
+    const ids = /* @__PURE__ */ new Set();
+    for (const node of options.nodes()) {
+      const name = node.name.toLowerCase();
+      const title = (node.title ?? "").toLowerCase();
+      if (name.includes(query) || title.includes(query)) {
+        ids.add(node.id);
+      }
+    }
+    return ids;
+  });
+  const visibleAncestorIds = computed(() => {
+    const query = options.searchQuery().trim();
+    if (!query) return /* @__PURE__ */ new Set();
+    const ids = /* @__PURE__ */ new Set();
+    const map = options.nodeMap.value;
+    for (const matchedId of matchedIds.value) {
+      const ancestors = getAncestors(matchedId, map);
+      for (const a of ancestors) {
+        ids.add(a.data.id);
+      }
+    }
+    return ids;
+  });
+  const isSearchActive = computed(() => options.searchQuery().trim().length > 0);
+  function expandToMatches() {
+    if (!isSearchActive.value || matchedIds.value.size === 0) return;
+    const next = new Set(options.expandedIds.value);
+    for (const id of visibleAncestorIds.value) {
+      next.add(id);
+    }
+    options.expandedIds.value = next;
+    options.onUpdateExpanded([...next]);
+  }
+  let lastQuery = "";
+  function checkAndExpand() {
+    const query = options.searchQuery().trim();
+    if (query !== lastQuery) {
+      lastQuery = query;
+      if (query) expandToMatches();
+    }
+  }
+  function isMatched(id) {
+    return matchedIds.value.has(id);
+  }
+  function isDimmed(id) {
+    if (!isSearchActive.value) return false;
+    return !matchedIds.value.has(id) && !visibleAncestorIds.value.has(id);
+  }
+  return {
+    matchedIds,
+    isSearchActive,
+    isMatched,
+    isDimmed,
+    checkAndExpand
+  };
+}

package/dist/runtime/composables/useOrgChartZoom.d.ts

@@ -0,0 +1,26 @@
+import type { ComputedRef, Ref } from "vue";
+import type { OrgChartTreeNode, ResolvedZoomConfig, ResolvedLayoutConfig } from "../types/org-chart.js";
+export interface UseOrgChartZoomOptions {
+    config: () => ResolvedZoomConfig;
+    containerRef: Ref<HTMLElement | null>;
+    layoutWidth: ComputedRef<number>;
+    layoutHeight: ComputedRef<number>;
+    nodeMap: ComputedRef<Map<string | number, OrgChartTreeNode>>;
+    layoutConfig: () => ResolvedLayoutConfig;
+}
+export declare function useOrgChartZoom(options: UseOrgChartZoomOptions): {
+    scale: Ref<number, number>;
+    translateX: Ref<number, number>;
+    translateY: Ref<number, number>;
+    transformStyle: ComputedRef<{
+        transform: string;
+        transformOrigin: string;
+    }>;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomReset: () => void;
+    fitToView: () => void;
+    scrollToNode: (id: string | number) => void;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+};

package/dist/runtime/composables/useOrgChartZoom.js

@@ -0,0 +1,101 @@
+import { computed, ref } from "vue";
+export function useOrgChartZoom(options) {
+  const scale = ref(options.config().initial);
+  const translateX = ref(0);
+  const translateY = ref(0);
+  let isPanning = false;
+  let panStartX = 0;
+  let panStartY = 0;
+  let panStartTX = 0;
+  let panStartTY = 0;
+  const transformStyle = computed(() => ({
+    transform: `scale(${scale.value}) translate(${translateX.value}px, ${translateY.value}px)`,
+    transformOrigin: "0 0"
+  }));
+  function clampScale(s) {
+    const cfg = options.config();
+    return Math.min(Math.max(s, cfg.min), cfg.max);
+  }
+  function zoomIn() {
+    scale.value = clampScale(scale.value + options.config().step);
+  }
+  function zoomOut() {
+    scale.value = clampScale(scale.value - options.config().step);
+  }
+  function zoomReset() {
+    scale.value = options.config().initial;
+    translateX.value = 0;
+    translateY.value = 0;
+  }
+  function fitToView() {
+    const container = options.containerRef.value?.parentElement;
+    if (!container) return;
+    const lw = options.layoutWidth.value;
+    const lh = options.layoutHeight.value;
+    if (lw === 0 || lh === 0) return;
+    const cw = container.clientWidth;
+    const ch = container.clientHeight;
+    const sx = cw / lw;
+    const sy = ch / lh;
+    const s = clampScale(Math.min(sx, sy) * 0.9);
+    scale.value = s;
+    translateX.value = (cw / s - lw) / 2;
+    translateY.value = (ch / s - lh) / 2;
+  }
+  function scrollToNode(id) {
+    const node = options.nodeMap.value.get(id);
+    const container = options.containerRef.value?.parentElement;
+    if (!node || !container) return;
+    const cfg = options.layoutConfig();
+    const nodeCenterX = node.x + cfg.nodeWidth / 2;
+    const nodeCenterY = node.y + cfg.nodeHeight / 2;
+    const cw = container.clientWidth;
+    const ch = container.clientHeight;
+    translateX.value = cw / scale.value / 2 - nodeCenterX;
+    translateY.value = ch / scale.value / 2 - nodeCenterY;
+  }
+  function onWheel(e) {
+    if (!options.config().enabled) return;
+    e.preventDefault();
+    let delta = e.deltaY;
+    if (e.deltaMode === 1) delta *= 40;
+    const zoomDelta = -delta * 1e-3;
+    scale.value = clampScale(scale.value + zoomDelta);
+  }
+  function onPointerDown(e) {
+    if (!options.config().enabled) return;
+    if (e.button !== 1 && !e.metaKey && !e.ctrlKey) return;
+    isPanning = true;
+    panStartX = e.clientX;
+    panStartY = e.clientY;
+    panStartTX = translateX.value;
+    panStartTY = translateY.value;
+    const onMove = (ev) => {
+      if (!isPanning) return;
+      const dx = (ev.clientX - panStartX) / scale.value;
+      const dy = (ev.clientY - panStartY) / scale.value;
+      translateX.value = panStartTX + dx;
+      translateY.value = panStartTY + dy;
+    };
+    const onUp = () => {
+      isPanning = false;
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+  }
+  return {
+    scale,
+    translateX,
+    translateY,
+    transformStyle,
+    zoomIn,
+    zoomOut,
+    zoomReset,
+    fitToView,
+    scrollToNode,
+    onWheel,
+    onPointerDown
+  };
+}

package/dist/runtime/index.d.ts

@@ -1 +1,4 @@
 export * from "./types/index.js";
+export { expandRecurringEvents, expandRecurringEventsAsync, getVisibleRange } from "./utils/recurrence.js";
+export type { VisibleRange } from "./utils/recurrence.js";
+export { buildTree, computeLayout, computeFullLayout, computeConnectionPaths, flattenVisibleTree, buildNodeMap, getAllNodeIds, getAncestors, getDescendants } from "./utils/org-chart.js";

package/dist/runtime/index.js

@@ -1 +1,3 @@
 export * from "./types/index.js";
+export { expandRecurringEvents, expandRecurringEventsAsync, getVisibleRange } from "./utils/recurrence.js";
+export { buildTree, computeLayout, computeFullLayout, computeConnectionPaths, flattenVisibleTree, buildNodeMap, getAllNodeIds, getAncestors, getDescendants } from "./utils/org-chart.js";

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

@@ -1,4 +1,7 @@
 import type { CalendarDate, CalendarDateTime, DateValue } from "@internationalized/date";
+import type { ComputedRef, Ref, ShallowRef } from "vue";
+/** All supported calendar view modes */
+export type CalendarView = "month" | "week" | "day" | "list";
 /**
  * Represents an event on the calendar.
  * Accepts flexible date inputs (Date, ISO string, or DateValue).
@@ -18,6 +21,16 @@ export interface CalendarEvent {
     allDay?: boolean;
     /** Whether this event can be dragged. Defaults to true */
     draggable?: boolean;
+    /** Whether this event can be resized. Defaults to true */
+    resizable?: boolean;
+    /** RFC 5545 RRULE string, e.g. "FREQ=WEEKLY;BYDAY=MO,WE,FR". Requires the `rrule` package. */
+    rrule?: string;
+    /** Dates to exclude from the recurrence (RFC 5545 EXDATE) */
+    exdate?: (Date | string | DateValue)[];
+    /** Duration in minutes. Used to compute end for each occurrence. If absent, inferred from start/end. */
+    duration?: number;
+    /** ID of the parent recurring event. Present only on expanded occurrences (set internally). */
+    recurringEventId?: string | number;
 }
 /** Internal normalized event with parsed dates */
 export interface NormalizedEvent {
@@ -28,7 +41,10 @@ export interface NormalizedEvent {
     color: string;
     allDay: boolean;
     draggable: boolean;
+    resizable: boolean;
     original: CalendarEvent;
+    /** ID of the parent recurring event. Present only on expanded occurrences. */
+    recurringEventId?: string | number;
 }
 /** A single day cell in the calendar grid */
 export interface CalendarDay {
@@ -73,6 +89,9 @@ export interface DayViewOptions {
     /** Minutes per time slot row @defaultValue 30 */
     slotDuration?: 15 | 30 | 60;
 }
+/** List/agenda view configuration */
+export interface ListViewOptions {
+}
 /** A timed event with computed pixel positions and overlap column info */
 export interface PositionedEvent extends NormalizedEvent {
     topPx: number;
@@ -89,4 +108,155 @@ export interface EventDropPayload {
     oldEnd: CalendarDate | CalendarDateTime;
     newStart: CalendarDate | CalendarDateTime;
     newEnd: CalendarDate | CalendarDateTime;
+    /** Parent recurring event ID. Set when a recurring occurrence was dropped. */
+    recurringEventId?: string | number;
+    /** The specific occurrence date/time that was dragged. Set when a recurring occurrence was dropped. */
+    occurrenceDate?: CalendarDate | CalendarDateTime;
+}
+/** Payload emitted after a resize operation */
+export interface EventResizePayload {
+    event: CalendarEvent;
+    oldStart: CalendarDate | CalendarDateTime;
+    oldEnd: CalendarDate | CalendarDateTime;
+    newStart: CalendarDate | CalendarDateTime;
+    newEnd: CalendarDate | CalendarDateTime;
+}
+/** Payload emitted after a click or drag selection */
+export interface SelectPayload {
+    start: CalendarDate | CalendarDateTime;
+    end: CalendarDate | CalendarDateTime;
+    allDay: boolean;
+}
+/** A spanning event positioned within a week row of the month grid */
+export interface MonthSpanningEvent {
+    event: NormalizedEvent;
+    /** 0-based column index where this bar starts within the week */
+    startCol: number;
+    /** Number of columns this bar spans */
+    span: number;
+    /** 0-based lane (row) index assigned by the greedy algorithm */
+    lane: number;
+    /** Whether this bar includes the event's true start date */
+    isStart: boolean;
+    /** Whether this bar includes the event's true end date */
+    isEnd: boolean;
+}
+/** A single-day event positioned within a week row of the month grid */
+export interface MonthSingleDayEvent {
+    event: NormalizedEvent;
+    /** 0-based column index */
+    col: number;
+    /** 0-based row index among single-day events for this column */
+    row: number;
+    /** Pre-computed CSS grid row (accounts for per-column spanning offset) */
+    gridRow: number;
+}
+/** Per-day overflow info for "+N more" */
+export interface MonthDayOverflow {
+    col: number;
+    hiddenCount: number;
+    hiddenEvents: NormalizedEvent[];
+    /** Grid row index for the "+N more" chip */
+    gridRow: number;
+}
+/** Complete layout data for one week row in the month view */
+export interface MonthWeekLayout {
+    week: CalendarWeek;
+    spanning: MonthSpanningEvent[];
+    singleDay: MonthSingleDayEvent[];
+    overflow: MonthDayOverflow[];
+    /** Total event rows for grid-template-rows */
+    totalEventRows: number;
+    /** Number of spanning lanes used */
+    spanningLaneCount: number;
+}
+/** Layout for the all-day row in week/day time grid view */
+export interface AllDayLayout {
+    /** Spanning event bars with lane assignments */
+    spanning: MonthSpanningEvent[];
+    /** Total number of lanes used */
+    laneCount: number;
+}
+/** A day column in the week/day time grid view */
+export interface TimeGridDay extends CalendarDay {
+    dateKey: string;
+    allDayEvents: NormalizedEvent[];
+    timedEvents: PositionedEvent[];
+}
+/** The context provided by EventCalendar root to sub-components via provide/inject */
+export interface EventCalendarContext {
+    displayDate: ComputedRef<CalendarDate>;
+    view: ComputedRef<CalendarView>;
+    locale: ComputedRef<string>;
+    weekStartsOn: ComputedRef<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    editable: ComputedRef<boolean>;
+    loading: ComputedRef<boolean>;
+    color: ComputedRef<string>;
+    views: ComputedRef<CalendarView[]>;
+    monthConfig: ComputedRef<{
+        maxEvents: number;
+        fixedWeeks: boolean;
+    }>;
+    weekConfig: ComputedRef<{
+        startHour: number;
+        endHour: number;
+        slotDuration: number;
+    }>;
+    dayConfig: ComputedRef<{
+        startHour: number;
+        endHour: number;
+        slotDuration: number;
+    }>;
+    monthWeeks: ComputedRef<CalendarWeek[]>;
+    monthWeekLayouts: ComputedRef<MonthWeekLayout[]>;
+    weekdayLabels: ComputedRef<string[]>;
+    weekDays: ComputedRef<CalendarDay[]>;
+    dayViewDate: ComputedRef<CalendarDay>;
+    listDays: ComputedRef<CalendarDay[]>;
+    timeGridDays: ComputedRef<TimeGridDay[]>;
+    allDayLayout: ComputedRef<AllDayLayout>;
+    timeGridSlots: ComputedRef<TimeSlot[]>;
+    headerTitle: ComputedRef<string>;
+    formatTime: (d: CalendarDate | CalendarDateTime) => string;
+    formatTimeRange: (start: CalendarDate | CalendarDateTime, end: CalendarDate | CalendarDateTime) => string;
+    getEventStyle: (event: NormalizedEvent, bgOpacity?: number) => Record<string, string>;
+    isEventStart: (event: NormalizedEvent, date: CalendarDate) => boolean;
+    goToPrev: () => void;
+    goToNext: () => void;
+    goToToday: () => void;
+    setView: (v: CalendarView) => void;
+    handleDateClick: (day: CalendarDay) => void;
+    handleEventClick: (event: NormalizedEvent, e: Event) => void;
+    ui: ComputedRef<any>;
+    propUi: ComputedRef<any>;
+    draggedEventId: Ref<string | number | null>;
+    dropTargetKey: Ref<string | null>;
+    dragSnapSlot: Ref<string | null>;
+    onDragStart: (event: NormalizedEvent, e: DragEvent) => void;
+    onDragEnd: (e: DragEvent) => void;
+    onDragOver: (key: string, e: DragEvent) => void;
+    onDragLeave: () => void;
+    onTimeGridDragOver: (dateKey: string, e: DragEvent) => void;
+    onSlotDragOver: (slotKey: string, e: DragEvent) => void;
+    onDropMonthCell: (targetDate: CalendarDate, e: DragEvent) => void;
+    onDropTimeGrid: (targetDate: CalendarDate, e: DragEvent) => void;
+    resizingEventId: Ref<string | number | null>;
+    resizePreviewHeightPx: Ref<number | null>;
+    onResizePointerDown: (event: PositionedEvent, e: PointerEvent) => void;
+    focusedDate: ShallowRef<CalendarDate>;
+    isFocusedDate: (date: CalendarDate) => boolean;
+    onGridKeydown: (e: KeyboardEvent) => void;
+    formatDateAriaLabel: (date: CalendarDate) => string;
+    formatEventAriaLabel: (event: NormalizedEvent) => string;
+    selectable: ComputedRef<boolean>;
+    isSelecting: Ref<boolean>;
+    isSlotInSelection: (date: CalendarDate, hour: number, minute: number) => boolean;
+    isDateInSelection: (date: CalendarDate) => boolean;
+    onSlotPointerDown: (date: CalendarDate, hour: number, minute: number, e: PointerEvent) => void;
+    onSlotPointerMove: (date: CalendarDate, hour: number, minute: number) => void;
+    onDayCellPointerDown: (date: CalendarDate, e: PointerEvent) => void;
+    onDayCellPointerMove: (date: CalendarDate) => void;
+    onSelectionPointerUp: () => void;
+    preventNextClick: Ref<boolean>;
+    SLOT_HEIGHT: number;
 }

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

@@ -1,2 +1,4 @@
 export * from "./event-calendar.js";
 export * from "../components/EventCalendar.vue.js";
+export * from "./org-chart.js";
+export * from "../components/OrgChart.vue.js";

package/dist/runtime/types/index.js

@@ -1,2 +1,4 @@
 export * from "./event-calendar.js";
 export * from "../components/EventCalendar.vue";
+export * from "./org-chart.js";
+export * from "../components/OrgChart.vue";

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

@@ -0,0 +1,181 @@
+import type { ComputedRef, Ref } from "vue";
+/** A single node in the org chart flat data */
+export interface OrgChartNode {
+    /** Unique identifier */
+    id: string | number;
+    /** Parent node ID. `null` for the root node. */
+    parentId: string | number | null;
+    /** Display name */
+    name: string;
+    /** Optional secondary text (e.g., job title) */
+    title?: string;
+    /** Avatar image URL */
+    avatar?: string;
+    /** Icon name (e.g., `i-lucide-user`) */
+    icon?: string;
+    /** Nuxt UI color override for this node */
+    color?: string;
+    /** Arbitrary user-defined metadata passed through to slots */
+    metadata?: Record<string, unknown>;
+}
+/** Layout direction */
+export type OrgChartDirection = "vertical" | "horizontal" | "bottom-up" | "right-to-left";
+/** Connector line style */
+export type OrgChartConnectorStyle = "right-angle" | "curved" | "straight";
+/** Selection mode */
+export type OrgChartSelectionMode = "none" | "single" | "multiple";
+/** Tree node with computed relationships and layout position */
+export interface OrgChartTreeNode {
+    /** Original flat node data */
+    data: OrgChartNode;
+    /** Parent tree node (null for root) */
+    parent: OrgChartTreeNode | null;
+    /** Direct children */
+    children: OrgChartTreeNode[];
+    /** Depth in the tree (root = 0) */
+    depth: number;
+    /** 0-based index among siblings */
+    indexInSiblings: number;
+    /** Total sibling count */
+    siblingCount: number;
+    /** Count of all descendants */
+    descendantCount: number;
+    /** Layout x position (top-left of node) */
+    x: number;
+    /** Layout y position (top-left of node) */
+    y: number;
+}
+/** Connector line segment between parent and child */
+export interface OrgChartConnector {
+    /** Parent node ID */
+    fromId: string | number;
+    /** Child node ID */
+    toId: string | number;
+    /** SVG path data string (d attribute) */
+    path: string;
+}
+/** Non-hierarchical connection between any two nodes (e.g., dotted-line reporting) */
+export interface OrgChartConnection {
+    /** Unique identifier for this connection */
+    id: string | number;
+    /** Source node ID */
+    fromId: string | number;
+    /** Target node ID */
+    toId: string | number;
+    /** Optional label displayed on the connection */
+    label?: string;
+    /** Line style @defaultValue 'dashed' */
+    style?: "dashed" | "dotted" | "solid";
+    /** Nuxt UI color for this connection */
+    color?: string;
+    /** Arbitrary metadata passed through to slots */
+    metadata?: Record<string, unknown>;
+}
+/** Computed connection path for rendering */
+export interface OrgChartConnectionPath {
+    /** Original connection data */
+    connection: OrgChartConnection;
+    /** SVG path data string */
+    path: string;
+    /** Label position (midpoint of path) */
+    labelX: number;
+    labelY: number;
+}
+/** Computed layout result */
+export interface OrgChartLayout {
+    /** All visible tree nodes with x, y positions */
+    nodes: OrgChartTreeNode[];
+    /** All connector paths (hierarchical parent-child) */
+    connectors: OrgChartConnector[];
+    /** Non-hierarchical connection paths */
+    connectionPaths: OrgChartConnectionPath[];
+    /** Total width of the layout (px) */
+    width: number;
+    /** Total height of the layout (px) */
+    height: number;
+}
+export interface OrgChartLayoutConfig {
+    /** Horizontal gap between sibling nodes (px) @defaultValue 40 */
+    siblingGap?: number;
+    /** Vertical gap between levels (px) @defaultValue 60 */
+    levelGap?: number;
+    /** Node width (px) @defaultValue 200 */
+    nodeWidth?: number;
+    /** Node height (px) @defaultValue 80 */
+    nodeHeight?: number;
+    /** Corner radius for right-angle connectors (px). Set to 0 for sharp corners. @defaultValue 8 */
+    connectorRadius?: number;
+}
+export type ResolvedLayoutConfig = Required<OrgChartLayoutConfig>;
+export interface OrgChartZoomConfig {
+    /** Enable zoom/pan @defaultValue false */
+    enabled?: boolean;
+    /** Minimum zoom scale @defaultValue 0.25 */
+    min?: number;
+    /** Maximum zoom scale @defaultValue 2 */
+    max?: number;
+    /** Initial zoom scale @defaultValue 1 */
+    initial?: number;
+    /** Zoom step per scroll tick @defaultValue 0.1 */
+    step?: number;
+    /** Show zoom controls overlay @defaultValue true */
+    controls?: boolean;
+}
+export type ResolvedZoomConfig = Required<OrgChartZoomConfig>;
+export interface OrgChartContext {
+    tree: ComputedRef<OrgChartTreeNode | null>;
+    layout: ComputedRef<OrgChartLayout>;
+    flatVisibleNodes: ComputedRef<OrgChartTreeNode[]>;
+    nodeMap: ComputedRef<Map<string | number, OrgChartTreeNode>>;
+    direction: ComputedRef<OrgChartDirection>;
+    connectorStyle: ComputedRef<OrgChartConnectorStyle>;
+    selectionMode: ComputedRef<OrgChartSelectionMode>;
+    compact: ComputedRef<boolean>;
+    animated: ComputedRef<boolean>;
+    draggable: ComputedRef<boolean>;
+    layoutConfig: ComputedRef<ResolvedLayoutConfig>;
+    zoomConfig: ComputedRef<ResolvedZoomConfig>;
+    expandedIds: Ref<Set<string | number>>;
+    selectedIds: Ref<Set<string | number>>;
+    focusedId: Ref<string | number | null>;
+    searchQuery: ComputedRef<string>;
+    matchedIds: ComputedRef<Set<string | number>>;
+    isMatched: (id: string | number) => boolean;
+    isDimmed: (id: string | number) => boolean;
+    isExpanded: (id: string | number) => boolean;
+    isSelected: (id: string | number) => boolean;
+    isFocused: (id: string | number) => boolean;
+    getDescendantCount: (id: string | number) => number;
+    getNode: (id: string | number) => OrgChartTreeNode | undefined;
+    getChildren: (id: string | number) => OrgChartTreeNode[];
+    getAncestors: (id: string | number) => OrgChartTreeNode[];
+    toggleExpand: (id: string | number) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    selectNode: (id: string | number) => void;
+    deselectNode: (id: string | number) => void;
+    scrollToNode: (id: string | number) => void;
+    fitToView: () => void;
+    handleNodeClick: (node: OrgChartTreeNode, e: Event) => void;
+    onKeydown: (e: KeyboardEvent) => void;
+    draggedNodeId: Ref<string | number | null>;
+    dropTargetId: Ref<string | number | null>;
+    onDragStart: (nodeId: string | number, e: DragEvent) => void;
+    onDragOver: (nodeId: string | number, e: DragEvent) => void;
+    onDragLeave: (e: DragEvent) => void;
+    onDrop: (nodeId: string | number, e: DragEvent) => void;
+    onDragEnd: (e: DragEvent) => void;
+    connectionPaths: ComputedRef<OrgChartConnectionPath[]>;
+    handleConnectionClick: (connection: OrgChartConnection, e: Event) => void;
+    ui: ComputedRef<any>;
+    propUi: ComputedRef<any>;
+    scale: Ref<number>;
+    translateX: Ref<number>;
+    translateY: Ref<number>;
+    transformStyle: ComputedRef<Record<string, string>>;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    zoomReset: () => void;
+    onWheel: (e: WheelEvent) => void;
+    onPointerDown: (e: PointerEvent) => void;
+}

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

@@ -1,5 +1,14 @@
 import type { CalendarDate, CalendarDateTime } from "@internationalized/date";
-import type { NormalizedEvent, PositionedEvent } from "../types/event-calendar.js";
+import type { NormalizedEvent, PositionedEvent, CalendarWeek, MonthWeekLayout, AllDayLayout, TimeGridDay } from "../types/event-calendar.js";
+/**
+ * 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;
 /** Check whether a DateValue has hour/minute (CalendarDateTime vs CalendarDate) */
 export declare function hasTimeComponent(d: CalendarDate | CalendarDateTime): boolean;
 /**
@@ -14,3 +23,15 @@ export declare function layoutTimedEvents(events: NormalizedEvent[], config: {
     endHour: number;
     slotDuration: number;
 }, slotHeight: number): PositionedEvent[];
+/**
+ * Compute layout for one week row in the month view.
+ *
+ * Assigns spanning (all-day / multi-day) events to horizontal lanes,
+ * then positions single-day events below. Returns grid row info for rendering.
+ */
+export declare function layoutMonthWeekEvents(week: CalendarWeek, maxEvents: number): MonthWeekLayout;
+/**
+ * Layout algorithm for the all-day row in week/day time grid views.
+ * Same greedy lane assignment as month view but without maxEvents cap or single-day partitioning.
+ */
+export declare function layoutAllDayEvents(days: TimeGridDay[]): AllDayLayout;