fancy-ui-react 0.2.0

package/dist/internals/ai-types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Shared data model for the AI component family.
+ *
+ * Every conversational and agent-activity component reads from these shapes, so
+ * one message object can flow from a thread list into a transcript, a tool
+ * timeline, or a citation card without translation at each boundary. Types only:
+ * nothing here runs, imports, or touches the DOM.
+ */
+/** Who produced a turn in a conversation. */
+export type ChatRole = "user" | "assistant" | "system";
+/** Lifecycle of a token stream, from the first chunk to its terminal state. */
+export type StreamStatus = "idle" | "streaming" | "done" | "error";
+/** Lifecycle of anything the model kicks off and can finish, fail, or abandon. */
+export type RunStatus = "pending" | "running" | "done" | "error" | "cancelled";
+/** One conversation turn — consumed by message bubbles, transcripts, and branch switchers. */
+export interface ChatMessageData {
+    id: string;
+    role: ChatRole;
+    content: string;
+    status?: StreamStatus;
+    createdAt?: Date | number;
+    branchIndex?: number;
+    branchCount?: number;
+}
+/** A single tool invocation — consumed by tool-call cards and their input/output panels. */
+export interface ToolCallData {
+    id: string;
+    name: string;
+    status: RunStatus;
+    input?: unknown;
+    output?: unknown;
+    error?: string;
+    durationMs?: number;
+}
+/** A document backing an answer — consumed by source lists and inline citations. */
+export interface SourceData {
+    id: string;
+    title: string;
+    url: string;
+    snippet?: string;
+    domain?: string;
+}
+/** One hit from a web lookup — consumed by search-result surfaces. */
+export interface SearchResultData {
+    id: string;
+    title: string;
+    url: string;
+    snippet?: string;
+}
+/** A file riding along with a turn — consumed by composer attachment chips and previews. */
+export interface AttachmentData {
+    id: string;
+    name: string;
+    size?: number;
+    type?: string;
+    previewUrl?: string;
+    progress?: number;
+    status?: "uploading" | "done" | "error";
+}
+/** A node in an agent's plan — consumed by plan trees and task checklists, nests via `substeps`. */
+export interface PlanStepData {
+    id: string;
+    label: string;
+    status: RunStatus;
+    detail?: string;
+    substeps?: PlanStepData[];
+}
+/** A delegated worker — consumed by subagent cards and fan-out activity views. */
+export interface SubagentData {
+    id: string;
+    name: string;
+    task: string;
+    status: RunStatus;
+    progress?: number;
+    model?: string;
+}
+/** A conversation in the sidebar — consumed by thread lists and history pickers. */
+export interface ThreadData {
+    id: string;
+    title: string;
+    preview?: string;
+    updatedAt: Date | number;
+    unread?: boolean;
+}
+/** A selectable action — consumed by slash-command menus and command palettes. */
+export interface CommandItemData {
+    id: string;
+    label: string;
+    description?: string;
+    hint?: string;
+}
+/** A model the user can switch to — consumed by model pickers in the composer. */
+export interface ModelOptionData {
+    id: string;
+    label: string;
+    badge?: string;
+    description?: string;
+}
+/** Context-window consumption — consumed by token meters and context rings. */
+export interface TokenUsageData {
+    used: number;
+    max: number;
+    breakdown?: Array<{
+        label: string;
+        tokens: number;
+    }>;
+}
+/** One line of agent activity — consumed by tool timelines that read as an action log. */
+export interface ToolTimelineItemData {
+    id: string;
+    verb: string;
+    target: string;
+    detail?: string;
+    additions?: number;
+    deletions?: number;
+    timestamp?: Date | number;
+}

package/dist/internals/anchor-position.d.ts

@@ -0,0 +1,79 @@
+export type Side = "top" | "bottom" | "left" | "right";
+export type Align = "start" | "center" | "end";
+export interface ComputePositionOptions {
+    /** Side of the anchor to place the floating element on. Defaults to "bottom". */
+    side?: Side;
+    /** Alignment along the cross axis of `side`. Defaults to "center". */
+    align?: Align;
+    /** Gap in pixels between the anchor and the floating element. Defaults to 8. */
+    offset?: number;
+    /** Viewport bounds used for flip/clamp. Defaults to `window` when available, otherwise unbounded (SSR). */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Flip to the opposite side when the requested side would overflow the viewport. Defaults to true. */
+    flip?: boolean;
+}
+export interface ComputePositionResult {
+    x: number;
+    y: number;
+    /** The side actually used, which may differ from the requested one when flipped. */
+    side: Side;
+    /**
+     * The cross-axis alignment the element actually ended up with, which
+     * differs from the requested one whenever clamping slid it along that
+     * axis. Read it — not the requested `align` — for anything that has to
+     * point back at the anchor, such as a transform origin or a caret.
+     */
+    align: Align;
+}
+/**
+ * Computes where to place a floating element relative to an anchor rect.
+ *
+ * Pure function — no DOM access, so it is testable with plain objects that
+ * satisfy the `DOMRect` shape.
+ */
+export declare function computePosition(anchor: DOMRect, floating: {
+    width: number;
+    height: number;
+}, opts?: ComputePositionOptions): ComputePositionResult;
+export interface AnchorPositionOptions {
+    /** Resolves the current anchor element. Called on every recompute so it can track a moving target. */
+    anchor: () => HTMLElement | null;
+    side?: Side;
+    align?: Align;
+    offset?: number;
+    /**
+     * Called with the side the element was actually placed on, which differs
+     * from the requested `side` whenever a flip occurred, and with the
+     * cross-axis alignment it actually ended up with, which differs from the
+     * requested `align` whenever clamping slid it along that axis. Fires once
+     * on the initial placement and thereafter only when either resolved value
+     * changes, so a consumer can react (move a caret, set a transform origin,
+     * mirror a submenu's open direction) without re-rendering on every scroll
+     * frame.
+     *
+     * Without this, `computePosition`'s resolved placement is computed and
+     * discarded here, and a consumer has no way to learn a flip or a clamp
+     * happened.
+     */
+    onPlacement?: (side: Side, align: Align) => void;
+}
+export interface AnchorPositionHandle {
+    /** Swaps the options and recomputes — the action's `update` under a new name. */
+    update(options: AnchorPositionOptions): void;
+    /** Recomputes against the current options, for a caller that knows the geometry moved. */
+    recompute(): void;
+    /** Detaches the scroll and resize listeners, and strips the position `update()` wrote. */
+    destroy(): void;
+}
+/**
+ * Positions `node` with `position: fixed` against a live anchor element, using
+ * `computePosition`. Recomputes on scroll and resize (passive, capturing
+ * listeners so nested scroll containers are caught too) and cleans up its
+ * listeners — and the position it wrote — on destroy.
+ *
+ * SSR-safe: does nothing when `window` is unavailable.
+ */
+export declare function attachAnchorPosition(node: HTMLElement, opts: AnchorPositionOptions): AnchorPositionHandle;

package/dist/internals/anchor-position.js

@@ -0,0 +1,154 @@
+"use client";
+const OPPOSITE_SIDE = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function isHorizontalSide(side) {
+  return side === "top" || side === "bottom";
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, max));
+}
+function getDefaultViewport() {
+  if (typeof window !== "undefined") {
+    return { width: window.innerWidth, height: window.innerHeight };
+  }
+  return { width: Number.POSITIVE_INFINITY, height: Number.POSITIVE_INFINITY };
+}
+function overflows(side, anchor, floating, offset, viewport) {
+  switch (side) {
+    case "top":
+      return anchor.top - floating.height - offset < 0;
+    case "bottom":
+      return anchor.bottom + offset + floating.height > viewport.height;
+    case "left":
+      return anchor.left - floating.width - offset < 0;
+    case "right":
+      return anchor.right + offset + floating.width > viewport.width;
+  }
+}
+function placeAt(side, anchor, floating, align, offset) {
+  if (isHorizontalSide(side)) {
+    const y2 = side === "top" ? anchor.top - floating.height - offset : anchor.bottom + offset;
+    let x2;
+    switch (align) {
+      case "start":
+        x2 = anchor.left;
+        break;
+      case "end":
+        x2 = anchor.right - floating.width;
+        break;
+      default:
+        x2 = anchor.left + anchor.width / 2 - floating.width / 2;
+    }
+    return { x: x2, y: y2 };
+  }
+  const x = side === "left" ? anchor.left - floating.width - offset : anchor.right + offset;
+  let y;
+  switch (align) {
+    case "start":
+      y = anchor.top;
+      break;
+    case "end":
+      y = anchor.bottom - floating.height;
+      break;
+    default:
+      y = anchor.top + anchor.height / 2 - floating.height / 2;
+  }
+  return { x, y };
+}
+function resolveAlign(side, anchor, floating, x, y, requested) {
+  const horizontal = isHorizontalSide(side);
+  const extent = horizontal ? floating.width : floating.height;
+  if (extent <= 0) return requested;
+  const anchorCentre = horizontal ? anchor.left + anchor.width / 2 : anchor.top + anchor.height / 2;
+  const ratio = (anchorCentre - (horizontal ? x : y)) / extent;
+  if (ratio < 1 / 3) return "start";
+  if (ratio > 2 / 3) return "end";
+  return "center";
+}
+function computePosition(anchor, floating, opts = {}) {
+  const { side = "bottom", align = "center", offset = 8, flip = true } = opts;
+  const viewport = opts.viewport ?? getDefaultViewport();
+  const resolvedSide = flip && overflows(side, anchor, floating, offset, viewport) ? OPPOSITE_SIDE[side] : side;
+  const { x, y } = placeAt(resolvedSide, anchor, floating, align, offset);
+  const maxX = Math.max(0, viewport.width - floating.width);
+  const maxY = Math.max(0, viewport.height - floating.height);
+  const clampedX = clamp(x, 0, maxX);
+  const clampedY = clamp(y, 0, maxY);
+  return {
+    x: clampedX,
+    y: clampedY,
+    side: resolvedSide,
+    align: resolveAlign(resolvedSide, anchor, floating, clampedX, clampedY, align)
+  };
+}
+function attachAnchorPosition(node, opts) {
+  if (typeof window === "undefined") {
+    return { update() {
+    }, recompute() {
+    }, destroy() {
+    } };
+  }
+  let options = opts;
+  let reportedSide = null;
+  let reportedAlign = null;
+  function measureFloating() {
+    const rect = node.getBoundingClientRect();
+    return {
+      width: node.offsetWidth || rect.width,
+      height: node.offsetHeight || rect.height
+    };
+  }
+  function update() {
+    const anchorEl = options.anchor();
+    if (!anchorEl) return;
+    const anchorRect = anchorEl.getBoundingClientRect();
+    const { x, y, side, align } = computePosition(anchorRect, measureFloating(), {
+      side: options.side,
+      align: options.align,
+      offset: options.offset,
+      viewport: { width: window.innerWidth, height: window.innerHeight }
+    });
+    node.style.position = "fixed";
+    node.style.left = `${x}px`;
+    node.style.top = `${y}px`;
+    if (side !== reportedSide || align !== reportedAlign) {
+      reportedSide = side;
+      reportedAlign = align;
+      options.onPlacement?.(side, align);
+    }
+  }
+  function reset() {
+    node.style.position = "";
+    node.style.left = "";
+    node.style.top = "";
+  }
+  update();
+  window.addEventListener("scroll", update, { passive: true, capture: true });
+  window.addEventListener("resize", update, { passive: true });
+  return {
+    update(newOpts) {
+      if (newOpts.onPlacement !== options.onPlacement) {
+        reportedSide = null;
+        reportedAlign = null;
+      }
+      options = newOpts;
+      update();
+    },
+    recompute() {
+      update();
+    },
+    destroy() {
+      window.removeEventListener("scroll", update, { capture: true });
+      window.removeEventListener("resize", update);
+      reset();
+    }
+  };
+}
+export {
+  attachAnchorPosition,
+  computePosition
+};

package/dist/internals/calendar-core.d.ts

@@ -0,0 +1,26 @@
+export type WeekStartsOn = 0 | 1;
+export interface MonthGridDay {
+    date: Date;
+    /** False for the leading/trailing days that pad the grid but belong to an adjacent month. */
+    inMonth: boolean;
+}
+/**
+ * Builds a 6-week x 7-day grid for `month` (0-11) of `year`, padded with the
+ * trailing days of the previous month and the leading days of the next one
+ * so every week is complete.
+ *
+ * @param weekStartsOn - 0 for Sunday, 1 for Monday. Defaults to 0.
+ */
+export declare function getMonthGrid(year: number, month: number, weekStartsOn?: WeekStartsOn): MonthGridDay[][];
+/**
+ * Returns a new date `n` months away from `date`. Clamps the day-of-month to
+ * the target month's length instead of letting it roll over (e.g. Jan 31 + 1
+ * month lands on Feb 28/29, not Mar 2/3).
+ */
+export declare function addMonths(date: Date, n: number): Date;
+/** Whether `a` and `b` fall on the same calendar day (year/month/date), ignoring time. */
+export declare function isSameDay(a: Date, b: Date): boolean;
+/** Clamps `date` into the `[min, max]` range (either bound optional). Always returns a new Date. */
+export declare function clampDate(date: Date, min?: Date, max?: Date): Date;
+/** Formats `date` as a "YYYY-MM-DD" string using its local date components. */
+export declare function formatISODate(date: Date): string;

package/dist/internals/calendar-core.js

@@ -0,0 +1,57 @@
+"use client";
+const DAYS_IN_WEEK = 7;
+const WEEKS_IN_GRID = 6;
+function getMonthGrid(year, month, weekStartsOn = 0) {
+  const reference = new Date(year, month, 1);
+  const firstWeekday = reference.getDay();
+  const leadingDays = (firstWeekday - weekStartsOn + 7) % 7;
+  const gridStart = new Date(reference.getFullYear(), reference.getMonth(), 1 - leadingDays);
+  const days = [];
+  for (let i = 0; i < WEEKS_IN_GRID * DAYS_IN_WEEK; i++) {
+    const date = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
+    days.push({
+      date,
+      inMonth: date.getMonth() === reference.getMonth() && date.getFullYear() === reference.getFullYear()
+    });
+  }
+  const weeks = [];
+  for (let w = 0; w < WEEKS_IN_GRID; w++) {
+    weeks.push(days.slice(w * DAYS_IN_WEEK, (w + 1) * DAYS_IN_WEEK));
+  }
+  return weeks;
+}
+function addMonths(date, n) {
+  const day = date.getDate();
+  const result = new Date(date);
+  result.setDate(1);
+  result.setMonth(result.getMonth() + n);
+  const daysInTargetMonth = new Date(result.getFullYear(), result.getMonth() + 1, 0).getDate();
+  result.setDate(Math.min(day, daysInTargetMonth));
+  result.setHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+  return result;
+}
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function clampDate(date, min, max) {
+  if (min && date.getTime() < min.getTime()) {
+    return new Date(min);
+  }
+  if (max && date.getTime() > max.getTime()) {
+    return new Date(max);
+  }
+  return new Date(date);
+}
+function formatISODate(date) {
+  const year = date.getFullYear().toString().padStart(4, "0");
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+export {
+  addMonths,
+  clampDate,
+  formatISODate,
+  getMonthGrid,
+  isSameDay
+};

package/dist/internals/diff.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Unified diff parser.
+ *
+ * Total and side-effect free: every input yields a value and nothing throws.
+ * Malformed, truncated or headerless patches degrade to a best-effort reading,
+ * so a patch that is still streaming in can be re-parsed on every chunk.
+ */
+export type DiffLineType = "add" | "del" | "context" | "meta";
+/**
+ * One line of a hunk. `text` drops the leading `+`/`-`/space marker; `meta`
+ * lines (``) keep their raw text. A line number is
+ * null on the side where the line does not exist.
+ */
+export interface DiffLine {
+    type: DiffLineType;
+    text: string;
+    oldLine: number | null;
+    newLine: number | null;
+}
+export interface DiffHunk {
+    header: string;
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: DiffLine[];
+}
+export interface DiffFile {
+    oldPath: string | null;
+    newPath: string | null;
+    hunks: DiffHunk[];
+    additions: number;
+    deletions: number;
+    isNew: boolean;
+    isDeleted: boolean;
+    isRename: boolean;
+}
+export declare function parseUnifiedDiff(src: string): DiffFile[];

package/dist/internals/diff.js

@@ -0,0 +1,176 @@
+"use client";
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+const FILE_HEADER = /^(?:---|\+\+\+) /;
+const GIT_HEADER = "diff --git ";
+function isBodyLine(line) {
+  const marker = line.charAt(0);
+  return marker === "+" || marker === "-" || marker === " ";
+}
+function cleanPath(raw, stripAffix) {
+  let path = raw.replace(/\s+$/, "");
+  const tab = path.indexOf("	");
+  if (tab !== -1) path = path.slice(0, tab).replace(/\s+$/, "");
+  if (path.length > 1 && path.startsWith('"') && path.endsWith('"')) path = path.slice(1, -1);
+  if (path === "/dev/null" || path === "") return null;
+  if (stripAffix && (path.startsWith("a/") || path.startsWith("b/"))) path = path.slice(2);
+  return path === "" ? null : path;
+}
+function gitHeaderPaths(line) {
+  const rest = line.slice(GIT_HEADER.length);
+  const paired = /^a\/(.*) b\/(.*)$/.exec(rest);
+  if (paired) return [cleanPath(paired[1], false), cleanPath(paired[2], false)];
+  const parts = rest.split(" ");
+  if (parts.length < 2) return [null, null];
+  return [cleanPath(parts[0], true), cleanPath(parts.slice(1).join(" "), true)];
+}
+function openFile(state) {
+  const file = {
+    oldPath: null,
+    newPath: null,
+    hunks: [],
+    additions: 0,
+    deletions: 0,
+    isNew: false,
+    isDeleted: false,
+    isRename: false
+  };
+  state.files.push(file);
+  state.file = file;
+  state.hunk = null;
+  return file;
+}
+function currentFile(state) {
+  return state.file ?? openFile(state);
+}
+function openHunk(state, hunk) {
+  currentFile(state).hunks.push(hunk);
+  state.hunk = hunk;
+  state.oldLine = hunk.oldStart;
+  state.newLine = hunk.newStart;
+  state.remainingOld = hunk.oldCount;
+  state.remainingNew = hunk.newCount;
+}
+function appendBody(state, raw) {
+  const hunk = state.hunk;
+  const file = state.file;
+  if (!hunk || !file) return;
+  const marker = raw.charAt(0);
+  const known = marker === "+" || marker === "-" || marker === " ";
+  const text = known ? raw.slice(1) : raw;
+  if (marker === "+") {
+    hunk.lines.push({ type: "add", text, oldLine: null, newLine: state.newLine++ });
+    file.additions++;
+    if (state.remainingNew > 0) state.remainingNew--;
+    return;
+  }
+  if (marker === "-") {
+    hunk.lines.push({ type: "del", text, oldLine: state.oldLine++, newLine: null });
+    file.deletions++;
+    if (state.remainingOld > 0) state.remainingOld--;
+    return;
+  }
+  hunk.lines.push({ type: "context", text, oldLine: state.oldLine++, newLine: state.newLine++ });
+  if (state.remainingOld > 0) state.remainingOld--;
+  if (state.remainingNew > 0) state.remainingNew--;
+}
+function parseUnifiedDiff(src) {
+  if (typeof src !== "string" || src.trim() === "") return [];
+  const state = {
+    files: [],
+    file: null,
+    hunk: null,
+    oldLine: 0,
+    newLine: 0,
+    remainingOld: 0,
+    remainingNew: 0
+  };
+  const lines = src.split(/\r?\n/);
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  for (const raw of lines) {
+    if (state.hunk) {
+      if (raw.startsWith("\\")) {
+        state.hunk.lines.push({ type: "meta", text: raw, oldLine: null, newLine: null });
+        continue;
+      }
+      const budget = state.remainingOld > 0 || state.remainingNew > 0;
+      const boundary = raw.startsWith(GIT_HEADER) || HUNK_HEADER.test(raw) || !budget && FILE_HEADER.test(raw);
+      if (!boundary && (budget || isBodyLine(raw))) {
+        appendBody(state, raw);
+        continue;
+      }
+      state.hunk = null;
+    }
+    const header = HUNK_HEADER.exec(raw);
+    if (header) {
+      openHunk(state, {
+        header: raw,
+        oldStart: Number(header[1]),
+        oldCount: header[2] === void 0 ? 1 : Number(header[2]),
+        newStart: Number(header[3]),
+        newCount: header[4] === void 0 ? 1 : Number(header[4]),
+        lines: []
+      });
+      continue;
+    }
+    if (raw.startsWith("@@")) continue;
+    if (raw.startsWith(GIT_HEADER)) {
+      const file = openFile(state);
+      [file.oldPath, file.newPath] = gitHeaderPaths(raw);
+      continue;
+    }
+    if (raw.startsWith("--- ")) {
+      const file = !state.file || state.file.hunks.length > 0 ? openFile(state) : state.file;
+      file.oldPath = cleanPath(raw.slice(4), true);
+      if (file.oldPath === null) file.isNew = true;
+      continue;
+    }
+    if (raw.startsWith("+++ ")) {
+      const file = currentFile(state);
+      file.newPath = cleanPath(raw.slice(4), true);
+      if (file.newPath === null) file.isDeleted = true;
+      continue;
+    }
+    if (raw.startsWith("rename from ")) {
+      const file = currentFile(state);
+      file.isRename = true;
+      file.oldPath = cleanPath(raw.slice("rename from ".length), false);
+      continue;
+    }
+    if (raw.startsWith("rename to ")) {
+      const file = currentFile(state);
+      file.isRename = true;
+      file.newPath = cleanPath(raw.slice("rename to ".length), false);
+      continue;
+    }
+    if (raw.startsWith("new file mode")) {
+      const file = currentFile(state);
+      file.isNew = true;
+      file.oldPath = null;
+      continue;
+    }
+    if (raw.startsWith("deleted file mode")) {
+      const file = currentFile(state);
+      file.isDeleted = true;
+      file.newPath = null;
+      continue;
+    }
+    if (isBodyLine(raw)) {
+      openHunk(state, {
+        header: "",
+        oldStart: 1,
+        oldCount: 0,
+        newStart: 1,
+        newCount: 0,
+        lines: []
+      });
+      appendBody(state, raw);
+      continue;
+    }
+  }
+  return state.files.filter(
+    (file) => file.hunks.length > 0 || file.oldPath !== null || file.newPath !== null || file.isNew || file.isDeleted || file.isRename
+  );
+}
+export {
+  parseUnifiedDiff
+};