nuxt-ui-elements-pro 0.1.5 → 0.1.7

package/dist/runtime/utils/event-calendar.js

@@ -1,4 +1,12 @@
-import { toCalendarDateTime } from "@internationalized/date";
+import { getDayOfWeek, toCalendarDate, toCalendarDateTime } 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 }));
+}
 export function hasTimeComponent(d) {
   return "hour" in d;
 }
@@ -65,3 +73,193 @@ export function layoutTimedEvents(events, config, slotHeight) {
   }
   return timed;
 }
+export function layoutMonthWeekEvents(week, maxEvents) {
+  const days = week.days;
+  const weekStartDate = days[0].date;
+  const weekEndDate = days[6].date;
+  const seenSpanning = /* @__PURE__ */ new Set();
+  const spanningCandidates = [];
+  const singleDayByCol = Array.from({ length: 7 }, () => []);
+  for (let col = 0; col < 7; col++) {
+    const day = days[col];
+    for (const event of day.events) {
+      const eventStartDate = toCalendarDate(event.start);
+      const eventEndDate = toCalendarDate(event.end);
+      const isMultiDay = eventStartDate.compare(eventEndDate) !== 0;
+      const isSpanning = event.allDay || isMultiDay;
+      if (isSpanning) {
+        if (!seenSpanning.has(event.id)) {
+          seenSpanning.add(event.id);
+          const clampedStart = eventStartDate.compare(weekStartDate) < 0 ? weekStartDate : eventStartDate;
+          const clampedEnd = eventEndDate.compare(weekEndDate) > 0 ? weekEndDate : eventEndDate;
+          let startCol = 0;
+          let endCol = 6;
+          for (let i = 0; i < 7; i++) {
+            if (days[i].date.compare(clampedStart) === 0) startCol = i;
+            if (days[i].date.compare(clampedEnd) === 0) endCol = i;
+          }
+          spanningCandidates.push({
+            event,
+            startCol,
+            endCol,
+            isStart: eventStartDate.compare(weekStartDate) >= 0,
+            isEnd: eventEndDate.compare(weekEndDate) <= 0
+          });
+        }
+      } else {
+        singleDayByCol[col].push(event);
+      }
+    }
+  }
+  spanningCandidates.sort((a, b) => {
+    if (a.startCol !== b.startCol) return a.startCol - b.startCol;
+    const spanA = a.endCol - a.startCol;
+    const spanB = b.endCol - b.startCol;
+    if (spanA !== spanB) return spanB - spanA;
+    return String(a.event.id).localeCompare(String(b.event.id));
+  });
+  const laneOccupancy = [];
+  const spanning = [];
+  for (const candidate of spanningCandidates) {
+    const { event, startCol, endCol, isStart, isEnd } = candidate;
+    const span = endCol - startCol + 1;
+    let assignedLane = -1;
+    for (let lane = 0; lane < laneOccupancy.length; lane++) {
+      let free = true;
+      for (let col = startCol; col <= endCol; col++) {
+        if (laneOccupancy[lane][col]) {
+          free = false;
+          break;
+        }
+      }
+      if (free) {
+        assignedLane = lane;
+        break;
+      }
+    }
+    if (assignedLane === -1) {
+      assignedLane = laneOccupancy.length;
+      laneOccupancy.push(new Array(7).fill(false));
+    }
+    for (let col = startCol; col <= endCol; col++) {
+      laneOccupancy[assignedLane][col] = true;
+    }
+    spanning.push({ event, startCol, span, lane: assignedLane, isStart, isEnd });
+  }
+  const perColSpanningOffset = new Array(7).fill(0);
+  for (let lane = 0; lane < laneOccupancy.length; lane++) {
+    for (let col = 0; col < 7; col++) {
+      if (laneOccupancy[lane][col]) {
+        perColSpanningOffset[col] = lane + 1;
+      }
+    }
+  }
+  const perColVisibleOffset = perColSpanningOffset.map((o) => Math.min(o, maxEvents));
+  const singleDay = [];
+  const overflow = [];
+  let totalEventRows = 0;
+  for (let col = 0; col < 7; col++) {
+    const colSingleDay = singleDayByCol[col];
+    const colOffset = perColVisibleOffset[col];
+    const colRemainingSlots = Math.max(0, maxEvents - colOffset);
+    const visibleSingle = colSingleDay.slice(0, colRemainingSlots);
+    for (let row = 0; row < visibleSingle.length; row++) {
+      singleDay.push({ event: visibleSingle[row], col, row, gridRow: colOffset + row + 2 });
+    }
+    totalEventRows = Math.max(totalEventRows, colOffset + visibleSingle.length);
+    const hiddenSpanning = [];
+    for (const s of spanning) {
+      if (s.lane >= maxEvents && s.startCol <= col && s.startCol + s.span - 1 >= col) {
+        hiddenSpanning.push(s.event);
+      }
+    }
+    const hiddenSingle = colSingleDay.slice(colRemainingSlots);
+    const hiddenCount = hiddenSpanning.length + hiddenSingle.length;
+    if (hiddenCount > 0) {
+      overflow.push({
+        col,
+        hiddenCount,
+        hiddenEvents: [...hiddenSpanning, ...hiddenSingle],
+        gridRow: 0
+        // set after loop
+      });
+    }
+  }
+  for (const item of overflow) {
+    item.gridRow = totalEventRows + 2;
+  }
+  return {
+    week,
+    spanning,
+    singleDay,
+    overflow,
+    totalEventRows,
+    spanningLaneCount: Math.min(laneOccupancy.length, maxEvents)
+  };
+}
+export function layoutAllDayEvents(days) {
+  const colCount = days.length;
+  if (colCount === 0) return { spanning: [], laneCount: 0 };
+  const startDate = days[0].date;
+  const endDate = days[colCount - 1].date;
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (let col = 0; col < colCount; col++) {
+    for (const event of days[col].allDayEvents) {
+      if (seen.has(event.id)) continue;
+      seen.add(event.id);
+      const eventStartDate = toCalendarDate(event.start);
+      const eventEndDate = toCalendarDate(event.end);
+      const clampedStart = eventStartDate.compare(startDate) < 0 ? startDate : eventStartDate;
+      const clampedEnd = eventEndDate.compare(endDate) > 0 ? endDate : eventEndDate;
+      let sc = 0;
+      let ec = colCount - 1;
+      for (let i = 0; i < colCount; i++) {
+        if (days[i].date.compare(clampedStart) === 0) sc = i;
+        if (days[i].date.compare(clampedEnd) === 0) ec = i;
+      }
+      candidates.push({
+        event,
+        startCol: sc,
+        endCol: ec,
+        isStart: eventStartDate.compare(startDate) >= 0,
+        isEnd: eventEndDate.compare(endDate) <= 0
+      });
+    }
+  }
+  candidates.sort((a, b) => {
+    if (a.startCol !== b.startCol) return a.startCol - b.startCol;
+    const spanA = a.endCol - a.startCol;
+    const spanB = b.endCol - b.startCol;
+    if (spanA !== spanB) return spanB - spanA;
+    return String(a.event.id).localeCompare(String(b.event.id));
+  });
+  const laneOccupancy = [];
+  const spanning = [];
+  for (const { event, startCol, endCol, isStart, isEnd } of candidates) {
+    const span = endCol - startCol + 1;
+    let assignedLane = -1;
+    for (let lane = 0; lane < laneOccupancy.length; lane++) {
+      let free = true;
+      for (let col = startCol; col <= endCol; col++) {
+        if (laneOccupancy[lane][col]) {
+          free = false;
+          break;
+        }
+      }
+      if (free) {
+        assignedLane = lane;
+        break;
+      }
+    }
+    if (assignedLane === -1) {
+      assignedLane = laneOccupancy.length;
+      laneOccupancy.push(new Array(colCount).fill(false));
+    }
+    for (let col = startCol; col <= endCol; col++) {
+      laneOccupancy[assignedLane][col] = true;
+    }
+    spanning.push({ event, startCol, span, lane: assignedLane, isStart, isEnd });
+  }
+  return { spanning, laneCount: laneOccupancy.length };
+}

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

@@ -0,0 +1,55 @@
+import type { OrgChartNode, OrgChartTreeNode, OrgChartConnector, OrgChartConnection, OrgChartConnectionPath, OrgChartLayout, OrgChartDirection, OrgChartConnectorStyle, ResolvedLayoutConfig } from "../types/org-chart.js";
+/**
+ * Build a tree from a flat node list.
+ * Validates exactly one root (parentId === null). Returns null for empty input.
+ */
+export declare function buildTree(nodes: OrgChartNode[]): OrgChartTreeNode | null;
+/**
+ * Compute full layout for the tree.
+ * Returns positioned nodes, connector paths, and total dimensions.
+ */
+export declare function computeLayout(root: OrgChartTreeNode, config: ResolvedLayoutConfig, direction: OrgChartDirection, expandedIds: Set<string | number>): OrgChartLayout;
+/** Overloaded layout that also accepts connector style */
+export declare function computeFullLayout(root: OrgChartTreeNode, config: ResolvedLayoutConfig, direction: OrgChartDirection, connectorStyle: OrgChartConnectorStyle, expandedIds: Set<string | number>, connections?: OrgChartConnection[]): OrgChartLayout;
+/**
+ * Compute SVG path data for connectors between parent-child pairs.
+ */
+export declare function computeConnectors(nodes: OrgChartTreeNode[], config: ResolvedLayoutConfig, direction: OrgChartDirection, style: OrgChartConnectorStyle): OrgChartConnector[];
+/**
+ * Compute SVG paths for non-hierarchical connections between arbitrary nodes.
+ * These are rendered as curved bezier paths offset from the straight line to
+ * avoid overlapping with hierarchical connectors.
+ */
+export declare function computeConnectionPaths(nodes: OrgChartTreeNode[], config: ResolvedLayoutConfig, direction: OrgChartDirection, connections: OrgChartConnection[]): OrgChartConnectionPath[];
+/**
+ * Flatten visible tree in DFS order, skipping collapsed subtrees.
+ * The root is always included.
+ */
+export declare function flattenVisibleTree(root: OrgChartTreeNode, expandedIds: Set<string | number>): OrgChartTreeNode[];
+/**
+ * Get ancestors of a node (from immediate parent to root).
+ */
+export declare function getAncestors(nodeId: string | number, nodeMap: Map<string | number, OrgChartTreeNode>): OrgChartTreeNode[];
+/**
+ * Get all descendants of a node (DFS, not including the node itself).
+ */
+export declare function getDescendants(node: OrgChartTreeNode): OrgChartTreeNode[];
+/**
+ * Collect all node IDs in the tree.
+ */
+export declare function getAllNodeIds(root: OrgChartTreeNode): Set<string | number>;
+/**
+ * Build a Map from node ID to OrgChartTreeNode for O(1) lookups.
+ */
+export declare function buildNodeMap(root: OrgChartTreeNode): Map<string | number, OrgChartTreeNode>;
+/** Default layout config values */
+export declare const DEFAULT_LAYOUT_CONFIG: ResolvedLayoutConfig;
+/** Default zoom config values */
+export declare const DEFAULT_ZOOM_CONFIG: {
+    readonly enabled: false;
+    readonly min: 0.25;
+    readonly max: 2;
+    readonly initial: 1;
+    readonly step: 0.1;
+    readonly controls: true;
+};

package/dist/runtime/utils/org-chart.js

@@ -0,0 +1,367 @@
+export function buildTree(nodes) {
+  if (nodes.length === 0) return null;
+  const ROOT_KEY = Symbol("root");
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const key = node.parentId === null ? ROOT_KEY : node.parentId;
+    const list = childrenMap.get(key);
+    if (list) list.push(node);
+    else childrenMap.set(key, [node]);
+  }
+  const roots = childrenMap.get(ROOT_KEY);
+  if (!roots || roots.length === 0) {
+    throw new Error("[OrgChart] No root node found (parentId === null).");
+  }
+  if (roots.length > 1) {
+    throw new Error(`[OrgChart] Multiple root nodes found: ${roots.map((r) => r.id).join(", ")}. Only one root is supported.`);
+  }
+  function build(data, parent, depth, indexInSiblings, siblingCount) {
+    const node = {
+      data,
+      parent,
+      children: [],
+      depth,
+      indexInSiblings,
+      siblingCount,
+      descendantCount: 0,
+      x: 0,
+      y: 0
+    };
+    const childData = childrenMap.get(data.id) ?? [];
+    node.children = childData.map((child, i) => build(child, node, depth + 1, i, childData.length));
+    node.descendantCount = node.children.reduce((sum, c) => sum + 1 + c.descendantCount, 0);
+    return node;
+  }
+  return build(roots[0], null, 0, 0, 1);
+}
+function buildLayoutTree(root, expandedIds) {
+  const children = expandedIds.has(root.data.id) ? root.children.map((c) => buildLayoutTree(c, expandedIds)) : [];
+  return { treeNode: root, children, prelim: 0, mod: 0, x: 0 };
+}
+function layoutChildren(node, siblingGap, nodeWidth) {
+  if (node.children.length === 0) return;
+  let nextX = 0;
+  for (const child of node.children) {
+    child.prelim = nextX;
+    layoutChildren(child, siblingGap, nodeWidth);
+    nextX = getRightContour(child, child.prelim) + nodeWidth + siblingGap;
+  }
+  const first = node.children[0];
+  const last = node.children[node.children.length - 1];
+  const mid = (first.prelim + last.prelim) / 2;
+  node.mod = mid;
+}
+function getRightContour(node, offset) {
+  let max = offset;
+  for (const child of node.children) {
+    max = Math.max(max, getRightContour(child, offset + child.prelim));
+  }
+  return max;
+}
+function isVerticalFlow(direction) {
+  return direction === "vertical" || direction === "bottom-up";
+}
+function assignPositions(root, config, direction) {
+  const vertical = isVerticalFlow(direction);
+  layoutChildren(root, config.siblingGap, vertical ? config.nodeWidth : config.nodeHeight);
+  function absolutePositions(node, offsetX, depth) {
+    const absX = offsetX + node.prelim;
+    if (vertical) {
+      node.treeNode.x = absX;
+      node.treeNode.y = depth * (config.nodeHeight + config.levelGap);
+    } else {
+      node.treeNode.x = depth * (config.nodeWidth + config.levelGap);
+      node.treeNode.y = absX;
+    }
+    for (const child of node.children) {
+      absolutePositions(child, absX - node.mod, depth + 1);
+    }
+  }
+  absolutePositions(root, 0, 0);
+}
+function normalizePositions(nodes, padding = 20) {
+  if (nodes.length === 0) return;
+  let minX = Infinity;
+  let minY = Infinity;
+  for (const n of nodes) {
+    if (n.x < minX) minX = n.x;
+    if (n.y < minY) minY = n.y;
+  }
+  const dx = padding - minX;
+  const dy = padding - minY;
+  for (const n of nodes) {
+    n.x += dx;
+    n.y += dy;
+  }
+}
+export function computeLayout(root, config, direction, expandedIds) {
+  const layoutRoot = buildLayoutTree(root, expandedIds);
+  assignPositions(layoutRoot, config, direction);
+  const nodes = flattenAll(layoutRoot);
+  const treeNodes = nodes.map((ln) => ln.treeNode);
+  if (direction === "bottom-up") {
+    flipVertical(treeNodes, config);
+  } else if (direction === "right-to-left") {
+    flipHorizontal(treeNodes, config);
+  }
+  normalizePositions(treeNodes);
+  const connectors = computeConnectors(treeNodes, config, direction, "right-angle");
+  const w = config.nodeWidth;
+  const h = config.nodeHeight;
+  let maxX = 0;
+  let maxY = 0;
+  for (const n of treeNodes) {
+    if (n.x + w > maxX) maxX = n.x + w;
+    if (n.y + h > maxY) maxY = n.y + h;
+  }
+  return {
+    nodes: treeNodes,
+    connectors,
+    connectionPaths: [],
+    width: maxX + 20,
+    height: maxY + 20
+  };
+}
+function flipVertical(nodes, config) {
+  if (nodes.length === 0) return;
+  let maxY = 0;
+  for (const n of nodes) {
+    const bottom = n.y + config.nodeHeight;
+    if (bottom > maxY) maxY = bottom;
+  }
+  for (const n of nodes) {
+    n.y = maxY - n.y - config.nodeHeight;
+  }
+}
+function flipHorizontal(nodes, config) {
+  if (nodes.length === 0) return;
+  let maxX = 0;
+  for (const n of nodes) {
+    const right = n.x + config.nodeWidth;
+    if (right > maxX) maxX = right;
+  }
+  for (const n of nodes) {
+    n.x = maxX - n.x - config.nodeWidth;
+  }
+}
+export function computeFullLayout(root, config, direction, connectorStyle, expandedIds, connections) {
+  const layoutRoot = buildLayoutTree(root, expandedIds);
+  assignPositions(layoutRoot, config, direction);
+  const nodes = flattenAll(layoutRoot);
+  const treeNodes = nodes.map((ln) => ln.treeNode);
+  if (direction === "bottom-up") {
+    flipVertical(treeNodes, config);
+  } else if (direction === "right-to-left") {
+    flipHorizontal(treeNodes, config);
+  }
+  normalizePositions(treeNodes);
+  const connectors = computeConnectors(treeNodes, config, direction, connectorStyle);
+  const connectionPaths = connections && connections.length > 0 ? computeConnectionPaths(treeNodes, config, direction, connections) : [];
+  let maxX = 0;
+  let maxY = 0;
+  for (const n of treeNodes) {
+    const right = n.x + config.nodeWidth;
+    const bottom = n.y + config.nodeHeight;
+    if (right > maxX) maxX = right;
+    if (bottom > maxY) maxY = bottom;
+  }
+  return {
+    nodes: treeNodes,
+    connectors,
+    connectionPaths,
+    width: maxX + 20,
+    height: maxY + 20
+  };
+}
+function flattenAll(node) {
+  const result = [node];
+  for (const child of node.children) {
+    result.push(...flattenAll(child));
+  }
+  return result;
+}
+function getConnectorEndpoints(parent, child, config, direction) {
+  switch (direction) {
+    case "vertical":
+      return {
+        px: parent.x + config.nodeWidth / 2,
+        py: parent.y + config.nodeHeight,
+        cx: child.x + config.nodeWidth / 2,
+        cy: child.y
+      };
+    case "bottom-up":
+      return {
+        px: parent.x + config.nodeWidth / 2,
+        py: parent.y,
+        cx: child.x + config.nodeWidth / 2,
+        cy: child.y + config.nodeHeight
+      };
+    case "horizontal":
+      return {
+        px: parent.x + config.nodeWidth,
+        py: parent.y + config.nodeHeight / 2,
+        cx: child.x,
+        cy: child.y + config.nodeHeight / 2
+      };
+    case "right-to-left":
+      return {
+        px: parent.x,
+        py: parent.y + config.nodeHeight / 2,
+        cx: child.x + config.nodeWidth,
+        cy: child.y + config.nodeHeight / 2
+      };
+  }
+}
+export function computeConnectors(nodes, config, direction, style) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) nodeMap.set(n.data.id, n);
+  const connectors = [];
+  for (const node of nodes) {
+    if (!node.parent) continue;
+    const parent = nodeMap.get(node.parent.data.id);
+    if (!parent) continue;
+    const { px, py, cx, cy } = getConnectorEndpoints(parent, node, config, direction);
+    const path = buildConnectorPath(px, py, cx, cy, style, isVerticalFlow(direction), config.connectorRadius);
+    connectors.push({
+      fromId: parent.data.id,
+      toId: node.data.id,
+      path
+    });
+  }
+  return connectors;
+}
+function buildConnectorPath(px, py, cx, cy, style, vertical, radius = 0) {
+  if (style === "straight") {
+    return `M ${px} ${py} L ${cx} ${cy}`;
+  }
+  if (style === "curved") {
+    if (vertical) {
+      const midY = py + (cy - py) / 2;
+      return `M ${px} ${py} C ${px} ${midY}, ${cx} ${midY}, ${cx} ${cy}`;
+    }
+    const midX2 = px + (cx - px) / 2;
+    return `M ${px} ${py} C ${midX2} ${py}, ${midX2} ${cy}, ${cx} ${cy}`;
+  }
+  if (vertical) {
+    const midY = py + (cy - py) / 2;
+    if (radius <= 0 || px === cx) {
+      return `M ${px} ${py} L ${px} ${midY} L ${cx} ${midY} L ${cx} ${cy}`;
+    }
+    const r2 = Math.min(radius, Math.abs(cy - py) / 4, Math.abs(cx - px) / 2);
+    const dx = cx > px ? r2 : -r2;
+    const dy1 = midY > py ? r2 : -r2;
+    const dy2 = cy > midY ? r2 : -r2;
+    return [
+      `M ${px} ${py}`,
+      `L ${px} ${midY - dy1}`,
+      `Q ${px} ${midY}, ${px + dx} ${midY}`,
+      `L ${cx - dx} ${midY}`,
+      `Q ${cx} ${midY}, ${cx} ${midY + dy2}`,
+      `L ${cx} ${cy}`
+    ].join(" ");
+  }
+  const midX = px + (cx - px) / 2;
+  if (radius <= 0 || py === cy) {
+    return `M ${px} ${py} L ${midX} ${py} L ${midX} ${cy} L ${cx} ${cy}`;
+  }
+  const r = Math.min(radius, Math.abs(cx - px) / 4, Math.abs(cy - py) / 2);
+  const dx1 = midX > px ? r : -r;
+  const dx2 = cx > midX ? r : -r;
+  const dy = cy > py ? r : -r;
+  return [
+    `M ${px} ${py}`,
+    `L ${midX - dx1} ${py}`,
+    `Q ${midX} ${py}, ${midX} ${py + dy}`,
+    `L ${midX} ${cy - dy}`,
+    `Q ${midX} ${cy}, ${midX + dx2} ${cy}`,
+    `L ${cx} ${cy}`
+  ].join(" ");
+}
+export function computeConnectionPaths(nodes, config, direction, connections) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) nodeMap.set(n.data.id, n);
+  const result = [];
+  for (const conn of connections) {
+    const from = nodeMap.get(conn.fromId);
+    const to = nodeMap.get(conn.toId);
+    if (!from || !to) continue;
+    const fromCx = from.x + config.nodeWidth / 2;
+    const fromCy = from.y + config.nodeHeight / 2;
+    const toCx = to.x + config.nodeWidth / 2;
+    const toCy = to.y + config.nodeHeight / 2;
+    const dx = toCx - fromCx;
+    const dy = toCy - fromCy;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const offset = Math.min(dist * 0.3, 80);
+    const nx = dist > 0 ? -dy / dist : 0;
+    const ny = dist > 0 ? dx / dist : 1;
+    const cpX = (fromCx + toCx) / 2 + nx * offset;
+    const cpY = (fromCy + toCy) / 2 + ny * offset;
+    const path = `M ${fromCx} ${fromCy} Q ${cpX} ${cpY}, ${toCx} ${toCy}`;
+    const labelX = (fromCx + 2 * cpX + toCx) / 4;
+    const labelY = (fromCy + 2 * cpY + toCy) / 4;
+    result.push({ connection: conn, path, labelX, labelY });
+  }
+  return result;
+}
+export function flattenVisibleTree(root, expandedIds) {
+  const result = [root];
+  if (expandedIds.has(root.data.id)) {
+    for (const child of root.children) {
+      result.push(...flattenVisibleTree(child, expandedIds));
+    }
+  }
+  return result;
+}
+export function getAncestors(nodeId, nodeMap) {
+  const result = [];
+  let current = nodeMap.get(nodeId);
+  if (!current) return result;
+  current = current.parent ?? void 0;
+  while (current) {
+    result.push(current);
+    current = current.parent ?? void 0;
+  }
+  return result;
+}
+export function getDescendants(node) {
+  const result = [];
+  for (const child of node.children) {
+    result.push(child);
+    result.push(...getDescendants(child));
+  }
+  return result;
+}
+export function getAllNodeIds(root) {
+  const ids = /* @__PURE__ */ new Set();
+  function walk(node) {
+    ids.add(node.data.id);
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return ids;
+}
+export function buildNodeMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  function walk(node) {
+    map.set(node.data.id, node);
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return map;
+}
+export const DEFAULT_LAYOUT_CONFIG = {
+  siblingGap: 40,
+  levelGap: 60,
+  nodeWidth: 200,
+  nodeHeight: 80,
+  connectorRadius: 8
+};
+export const DEFAULT_ZOOM_CONFIG = {
+  enabled: false,
+  min: 0.25,
+  max: 2,
+  initial: 1,
+  step: 0.1,
+  controls: true
+};

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

@@ -0,0 +1,30 @@
+import type { CalendarDate } from "@internationalized/date";
+import type { CalendarEvent } from "../types/event-calendar.js";
+/** Visible date range for the calendar grid */
+export interface VisibleRange {
+    start: CalendarDate;
+    end: CalendarDate;
+}
+/**
+ * Compute the date range the calendar grid actually renders.
+ * Includes padding for multi-day event bleed.
+ */
+export declare function getVisibleRange(displayDate: CalendarDate, view: "month" | "week" | "day" | "list", weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6, fixedWeeks: boolean): VisibleRange;
+/**
+ * Expand recurring events within a visible date range.
+ * Synchronous — requires the rrule module to be pre-loaded.
+ *
+ * @param events - Array of CalendarEvent (recurring and non-recurring mixed)
+ * @param range - Visible date range to expand within
+ * @param rruleLib - The pre-loaded rrule module (`import('rrule')`)
+ * @returns Flat array of CalendarEvent with occurrences expanded
+ */
+export declare function expandRecurringEvents(events: CalendarEvent[], range: VisibleRange, rruleLib: typeof import("rrule")): CalendarEvent[];
+/**
+ * Async convenience wrapper for standalone use (auto-imports rrule).
+ *
+ * @param events - Array of CalendarEvent
+ * @param range - Visible date range
+ * @returns Flat array of CalendarEvent with occurrences expanded
+ */
+export declare function expandRecurringEventsAsync(events: CalendarEvent[], range: VisibleRange): Promise<CalendarEvent[]>;