@vectramindnpm/unified-design-system 0.1.0

package/dist/index.js

@@ -0,0 +1,2983 @@
+// src/tokens/designTokens.js
+var font = {
+  family: {
+    base: "Inter, Helvetica, Arial, sans-serif"
+  },
+  // Single source of truth for the type scale — also exported below as `text` (alias)
+  // so any existing consumer of designTokens.text keeps working unchanged.
+  size: {
+    "2xs": "0.625rem",
+    xs: "0.6875rem",
+    sm: "0.8125rem",
+    base: "1rem",
+    md: "1.0625rem",
+    lg: "1.125rem",
+    xl: "1.3125rem",
+    "2xl": "1.5rem",
+    "3xl": "1.75rem",
+    "4xl": "2rem",
+    hero: "2.5rem"
+  },
+  lineHeight: {
+    tight: "1",
+    snug: "1.15",
+    normal: "1.3"
+  },
+  weight: {
+    regular: "400",
+    medium: "500",
+    semibold: "600",
+    bold: "700"
+  }
+};
+var radiusXs = "0.375rem";
+var radiusLg = "1.25rem";
+var designTokens = Object.freeze({
+  color: {
+    brand: {
+      purple: "#5D62B5",
+      purple700: "#424784",
+      purple600: "#4A4F99",
+      red: "#ff686a",
+      blue: "#5c62bc"
+    },
+    // Numeric shades ordered light -> dark by real lightness. `white`, `gray` and `muted`
+    // are kept as named exceptions alongside the ramp (matching how Tailwind separates
+    // white/black from its numeric gray scale).
+    neutral: {
+      white: "#ffffff",
+      100: "#f9fafb",
+      200: "#f3f4f6",
+      300: "#e9eef6",
+      muted: "#f1f1f1",
+      350: "#e5e7eb",
+      400: "#dddddd",
+      450: "#d1d5db",
+      500: "#ced4da",
+      600: "#9ca3af",
+      gray: "#6b7280",
+      700: "#374151",
+      800: "#263238",
+      900: "#111827"
+    },
+    status: {
+      success: "#63B58F",
+      danger: "#F2726F",
+      warning: "#F5A623"
+    },
+    gradient: {
+      brand: "linear-gradient(145deg, #5D62B5 0%, #7B7FD4 50%, #8E92DD 100%)"
+    }
+    // Chart/dashboard palette colors intentionally do NOT live here — this shared design-token
+    // architecture (variables.css / designTokens.js / semanticTokens.js / componentTokens.js) is
+    // scoped to common application UI only. Chart-only colors live in
+    // src/pages/shared/chartColors.ts, isolated within the Dashboard/Charts implementation.
+  },
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "0.75rem",
+    lg: "1rem",
+    xl: "1.3125rem",
+    xxl: "2rem"
+  },
+  font,
+  // Deprecated alias of font.size — do not add new entries here, extend font.size instead.
+  text: font.size,
+  ctrl: {
+    xs: "1.5rem",
+    sm: "1.75rem",
+    md: "2.25rem",
+    lg: "2.75rem",
+    xl: "3rem",
+    "2xl": "3.5rem"
+  },
+  radius: {
+    xs: radiusXs,
+    sm: radiusXs,
+    // alias of xs — identical value, kept for backward compatibility
+    md: "0.625rem",
+    lg: radiusLg,
+    xl: radiusLg,
+    // alias of lg — identical value, kept for backward compatibility
+    "2xl": "1.5rem",
+    pill: "9999px"
+  },
+  shadow: {
+    sm: "0 1px 2px rgba(0,0,0,0.05)",
+    md: "0 4px 16px rgba(0,0,0,0.10)",
+    lg: "0 4px 24px rgba(0,0,0,0.08)"
+  },
+  opacity: {
+    low: "0.10",
+    mid: "0.18"
+  },
+  zIndex: {
+    overlay: 9999,
+    modal: 1111,
+    dropdown: 1021
+  },
+  motion: {
+    duration: {
+      fast: "150ms",
+      normal: "200ms",
+      slow: "300ms"
+    },
+    easing: {
+      standard: "ease-in-out",
+      accel: "ease-out"
+    }
+  }
+});
+var designTokens_default = designTokens;
+
+// src/tokens/semanticTokens.js
+var { color, radius, spacing, font: font2, shadow, zIndex, motion, opacity } = designTokens_default;
+var semanticTokens = Object.freeze({
+  color: {
+    text: {
+      primary: color.neutral[900],
+      // realigned to match the production value already live in variables.css (--color-text-primary)
+      muted: color.neutral[600],
+      // realigned to match the production value already live in variables.css (--color-text-muted)
+      refreshIcon: color.brand.purple,
+      cancel: color.brand.red,
+      gray: color.neutral.gray,
+      blue: color.brand.blue,
+      secondary: color.neutral[700],
+      white: color.neutral.white
+    },
+    background: {
+      surface: color.neutral.white,
+      card: color.neutral[100]
+    },
+    border: {
+      default: color.neutral.muted,
+      // matches --color-border-default already declared in variables.css
+      card: color.neutral[450],
+      // matches --component-card-border-color, the value actually used across the app
+      primary: color.neutral[350]
+      // corrected — was neutral[900] before the neutral scale was reordered
+    },
+    interactive: {
+      brand: color.brand.purple,
+      brandHover: color.brand.purple700,
+      brandActive: color.brand.purple600
+      // fills the previously-missing pressed/active state
+    },
+    status: {
+      success: color.status.success,
+      danger: color.status.danger,
+      warning: color.status.warning
+    },
+    gradient: {
+      brand: color.gradient.brand
+    }
+  },
+  spacing: {
+    componentGap: spacing.md,
+    formControl: spacing.sm,
+    buttonX: spacing.xl,
+    cardPadding: spacing.lg
+  },
+  font: {
+    bodySize: font2.size.sm,
+    labelSize: font2.size.xs,
+    headingSize: font2.size.lg
+  },
+  radius: {
+    card: radius.lg,
+    control: radius.md,
+    modal: radius.lg
+    // lets componentTokens source modal radius from the semantic layer instead of designTokens directly
+  },
+  shadow: {
+    elevation1: shadow.sm,
+    elevation2: shadow.md
+  },
+  zIndex: {
+    modal: zIndex.modal,
+    overlay: zIndex.overlay
+  },
+  motion: {
+    duration: {
+      short: motion.duration.fast,
+      default: motion.duration.normal
+    }
+  },
+  disabled: {
+    opacity: opacity.mid
+  },
+  focus: {
+    ring: color.brand.purple
+  }
+});
+var semanticTokens_default = semanticTokens;
+
+// src/tokens/componentTokens.js
+var { color: color2, spacing: spacing2, shadow: shadow2, zIndex: zIndex2, radius: radius2 } = semanticTokens_default;
+var componentTokens = Object.freeze({
+  component: {
+    button: {
+      paddingX: spacing2.buttonX,
+      paddingY: spacing2.formControl,
+      background: color2.interactive.brand,
+      backgroundHover: color2.interactive.brandHover,
+      textColor: color2.background.surface,
+      radius: radius2.control,
+      shadow: shadow2.elevation1
+    },
+    card: {
+      padding: spacing2.cardPadding,
+      background: color2.background.card,
+      borderColor: color2.border.card,
+      radius: radius2.card,
+      shadow: shadow2.elevation1
+    },
+    modal: {
+      overlayZ: zIndex2.overlay,
+      z: zIndex2.modal,
+      contentRadius: radius2.modal
+    },
+    // The tokens below are utility CSS custom properties defined in responsive.css / tailwind.css.
+    // They sit outside the designTokens -> semanticTokens -> componentTokens hierarchy and are
+    // re-exposed here for convenience only; there is no backing JS design/semantic token for them.
+    panel: {
+      xs: "var(--panel-xs)",
+      sm: "var(--panel-sm)",
+      md: "var(--panel-md)",
+      lg: "var(--panel-lg)",
+      xl: "var(--panel-xl)",
+      "2xl": "var(--panel-2xl)",
+      dash: "var(--panel-dash)"
+    },
+    sticky: {
+      table: {
+        top: "var(--sticky-table-top)"
+      }
+    },
+    sp: {
+      0: "var(--sp-0)",
+      "0-5": "var(--sp-0-5)",
+      1: "var(--sp-1)",
+      "1-5": "var(--sp-1-5)",
+      2: "var(--sp-2)",
+      "2-5": "var(--sp-2-5)",
+      3: "var(--sp-3)",
+      4: "var(--sp-4)",
+      5: "var(--sp-5)",
+      6: "var(--sp-6)",
+      7: "var(--sp-7)",
+      8: "var(--sp-8)",
+      10: "var(--sp-10)",
+      12: "var(--sp-12)",
+      16: "var(--sp-16)",
+      20: "var(--sp-20)",
+      px: "var(--sp-px)"
+    },
+    radius: {
+      full: "var(--radius-full)"
+    },
+    z: {
+      base: "var(--z-base)",
+      dropdown: "var(--z-dropdown)",
+      sticky: "var(--z-sticky)",
+      overlay: "var(--z-overlay)",
+      drawer: "var(--z-drawer)",
+      modal: "var(--z-modal)",
+      toast: "var(--z-toast)"
+    },
+    animation: {
+      delay: "var(--animation-delay)"
+    },
+    duration: "var(--duration)",
+    animate: {
+      spin: "var(--animate-spin)"
+    },
+    shimmer: {
+      width: "var(--shimmer-width)"
+    },
+    space: {
+      page: {
+        x: "var(--space-page-x)",
+        y: "var(--space-page-y)"
+      },
+      card: "var(--space-card)"
+    },
+    content: {
+      max: {
+        width: "var(--content-max-width)"
+      }
+    }
+  }
+});
+var componentTokens_default = componentTokens;
+
+// src/types/view-mode.ts
+var EViewMode = /* @__PURE__ */ ((EViewMode2) => {
+  EViewMode2["GRID"] = "grid";
+  EViewMode2["LIST"] = "list";
+  return EViewMode2;
+})(EViewMode || {});
+
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/components/ui/avatar.tsx
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+var Avatar = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ref,
+    className: cn(
+      "relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
+      className
+    ),
+    ...props
+  }
+));
+Avatar.displayName = "Avatar";
+var AvatarImage = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "img",
+  {
+    ref,
+    className: cn("aspect-square h-full w-full object-cover", className),
+    ...props
+  }
+));
+AvatarImage.displayName = "AvatarImage";
+var AvatarFallback = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    ref,
+    className: cn(
+      "flex h-full w-full items-center justify-center rounded-full bg-muted",
+      className
+    ),
+    ...props
+  }
+));
+AvatarFallback.displayName = "AvatarFallback";
+
+// src/components/ui/badge.tsx
+import { cva } from "class-variance-authority";
+import "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var badgeVariants = cva(
+  "",
+  {
+    variants: {
+      variant: {
+        default: "",
+        secondary: "",
+        destructive: "",
+        outline: "",
+        hold: "",
+        transfer: "",
+        noShow: "",
+        success: "",
+        normal: "",
+        pending: "",
+        tag: "",
+        active: "",
+        inactive: "",
+        count: "",
+        code: ""
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+function Badge({ className, variant, style, dot, children, ...props }) {
+  const base = "inline-flex items-center justify-center px-2 py-0.5 rounded-full text-xs font-medium";
+  const variantClass = variant === "destructive" ? "text-status-danger bg-status-danger/10" : variant === "secondary" ? "text-text-muted bg-transparent" : variant === "outline" ? "border border-border-default text-foreground bg-transparent" : variant === "hold" ? "text-[var(--component-table-pill-hold-text)] bg-[var(--component-table-pill-hold-bg)]" : variant === "transfer" ? "text-[var(--component-table-pill-transfer-text)] bg-[var(--component-table-pill-transfer-bg)]" : variant === "noShow" ? "text-[var(--component-table-pill-noshow-text)] bg-[var(--component-table-pill-noshow-bg)]" : variant === "success" ? "text-[var(--component-table-pill-success-text)] bg-[var(--component-table-pill-success-bg)]" : variant === "pending" ? "text-[var(--component-table-pill-hold-text)] bg-[var(--component-table-pill-hold-bg)] border border-[var(--component-table-pill-hold-border)] font-[700] text-[0.625rem] !py-[0.125rem] !px-[0.5rem]" : variant === "normal" ? "text-[var(--component-table-pill-neutral-text)] bg-[var(--color-neutral-200)]" : variant === "tag" ? "text-[var(--component-pill-tag-text)] bg-[var(--component-pill-tag-bg)] border border-[var(--component-pill-tag-border)] gap-1 font-semibold text-[0.6875rem] leading-none !rounded-md !px-2 !py-0.5" : variant === "active" ? "text-[var(--component-pill-active-text)] bg-[var(--component-pill-active-bg)] border border-[var(--component-pill-active-border)] gap-1.5 font-medium text-[0.6875rem] leading-none !px-[0.625rem] !py-1" : variant === "inactive" ? "text-[var(--component-pill-inactive-text)] bg-[var(--component-pill-inactive-bg)] border border-[var(--component-pill-inactive-border)] gap-1.5 font-medium text-[0.6875rem] leading-none !px-[0.625rem] !py-1" : variant === "count" ? "text-white bg-[var(--color-brand-purple)] font-medium leading-none !w-[1.125rem] !h-[1.125rem] !px-0 !py-0 !text-[0.625rem]" : variant === "code" ? "text-[var(--color-brand-teal)] bg-[var(--color-brand-teal-tint)] font-medium uppercase truncate shrink-0 !px-3 !py-1" : "";
+  return /* @__PURE__ */ jsxs("div", { className: cn(base, variantClass, badgeVariants({ variant }), className), style, ...props, children: [
+    dot && /* @__PURE__ */ jsx2("span", { className: "w-1.5 h-1.5 rounded-full bg-current shrink-0" }),
+    children
+  ] });
+}
+
+// src/components/ui/button.tsx
+import { cva as cva2 } from "class-variance-authority";
+import * as React4 from "react";
+
+// src/components/ui/tooltip.tsx
+import * as React3 from "react";
+import { createPortal } from "react-dom";
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+var TooltipContext = React3.createContext(void 0);
+function useTooltip() {
+  const context = React3.useContext(TooltipContext);
+  if (!context) {
+    throw new Error("Tooltip components must be used within Tooltip");
+  }
+  return context;
+}
+var TooltipProvider = ({ children }) => {
+  return /* @__PURE__ */ jsx3(Fragment, { children });
+};
+var Tooltip = ({ open: controlledOpen, onOpenChange, children, delayDuration = 200 }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React3.useState(false);
+  const triggerRef = React3.useRef(null);
+  const open = controlledOpen !== void 0 ? controlledOpen : uncontrolledOpen;
+  const setOpen = onOpenChange || setUncontrolledOpen;
+  return /* @__PURE__ */ jsx3(TooltipContext.Provider, { value: { open, setOpen, triggerRef, delayDuration }, children });
+};
+var TooltipTrigger = React3.forwardRef(({ children, asChild = false, ...props }, ref) => {
+  const { setOpen, triggerRef, delayDuration } = useTooltip();
+  const timeoutRef = React3.useRef(void 0);
+  const handleMouseEnter = () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      setOpen(true);
+    }, delayDuration);
+  };
+  const handleMouseLeave = () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    setOpen(false);
+  };
+  React3.useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  if (asChild && React3.isValidElement(children)) {
+    return React3.cloneElement(children, {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (ref) {
+          if (typeof ref === "function") {
+            ref(node);
+          } else {
+            ref.current = node;
+          }
+        }
+      },
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      ...props
+    });
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (ref) {
+          if (typeof ref === "function") {
+            ref(node);
+          } else {
+            ref.current = node;
+          }
+        }
+      },
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      ...props,
+      children
+    }
+  );
+});
+TooltipTrigger.displayName = "TooltipTrigger";
+var TooltipContent = React3.forwardRef(({ className, sideOffset = 8, side = "top", ...props }, ref) => {
+  const { open, setOpen, triggerRef } = useTooltip();
+  const contentRef = React3.useRef(null);
+  const [tooltipPosition, setTooltipPosition] = React3.useState({ top: 0, left: 0 });
+  const [isPositioned, setIsPositioned] = React3.useState(false);
+  React3.useImperativeHandle(ref, () => contentRef.current);
+  React3.useEffect(() => {
+    if (!open || !triggerRef.current) {
+      setIsPositioned(false);
+      return;
+    }
+    const updatePosition = () => {
+      if (!triggerRef.current || !contentRef.current) return;
+      const triggerRect = triggerRef.current.getBoundingClientRect();
+      const contentRect = contentRef.current.getBoundingClientRect();
+      if (contentRect.width === 0 || contentRect.height === 0) {
+        return;
+      }
+      let top = 0;
+      let left = 0;
+      switch (side) {
+        case "top":
+          top = triggerRect.top - contentRect.height - sideOffset;
+          left = triggerRect.left + (triggerRect.width - contentRect.width) / 2;
+          break;
+        case "bottom":
+          top = triggerRect.bottom + sideOffset;
+          left = triggerRect.left + (triggerRect.width - contentRect.width) / 2;
+          break;
+        case "left":
+          top = triggerRect.top + (triggerRect.height - contentRect.height) / 2;
+          left = triggerRect.left - contentRect.width - sideOffset;
+          break;
+        case "right":
+          top = triggerRect.top + (triggerRect.height - contentRect.height) / 2;
+          left = triggerRect.right + sideOffset;
+          break;
+      }
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      if (left + contentRect.width > viewportWidth - 8) {
+        left = viewportWidth - contentRect.width - 8;
+      }
+      if (left < 8) {
+        left = 8;
+      }
+      if (top + contentRect.height > viewportHeight - 8) {
+        if (side === "bottom") {
+          top = triggerRect.top - contentRect.height - sideOffset;
+        } else if (side === "right" || side === "left") {
+          top = viewportHeight - contentRect.height - 8;
+        }
+      }
+      if (top < 8) {
+        top = 8;
+      }
+      setTooltipPosition({ top, left });
+      setIsPositioned(true);
+    };
+    requestAnimationFrame(() => {
+      updatePosition();
+      const timer1 = setTimeout(updatePosition, 10);
+      const timer2 = setTimeout(updatePosition, 50);
+      const timer3 = setTimeout(updatePosition, 100);
+      return () => {
+        clearTimeout(timer1);
+        clearTimeout(timer2);
+        clearTimeout(timer3);
+      };
+    });
+    window.addEventListener("scroll", updatePosition, true);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      window.removeEventListener("scroll", updatePosition, true);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [open, sideOffset, side, triggerRef]);
+  React3.useEffect(() => {
+    if (!open) return;
+    const handleMouseEnter = () => {
+      setOpen(true);
+    };
+    const handleMouseLeave = () => {
+      setOpen(false);
+    };
+    const contentEl = contentRef.current;
+    if (contentEl) {
+      contentEl.addEventListener("mouseenter", handleMouseEnter);
+      contentEl.addEventListener("mouseleave", handleMouseLeave);
+      return () => {
+        contentEl.removeEventListener("mouseenter", handleMouseEnter);
+        contentEl.removeEventListener("mouseleave", handleMouseLeave);
+      };
+    }
+  }, [open, setOpen]);
+  const isMobileOrTablet = typeof window !== "undefined" && window.innerWidth < 1024;
+  if (isMobileOrTablet) return null;
+  if (!open) return null;
+  const portalRoot = document.getElementById("fpneo") || document.body;
+  return createPortal(
+    /* @__PURE__ */ jsx3(
+      "div",
+      {
+        ref: contentRef,
+        className: cn(
+          "fixed z-[var(--zindex-overlay)] overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-body text-popover-foreground shadow-md transition-opacity duration-150 max-w-[25ch]",
+          isPositioned ? "opacity-100" : "opacity-0",
+          className
+        ),
+        style: {
+          top: `${tooltipPosition.top}px`,
+          left: `${tooltipPosition.left}px`,
+          fontSize: "0.75rem",
+          whiteSpace: "pre-line",
+          wordBreak: "break-word",
+          lineHeight: 1
+        },
+        ...props
+      }
+    ),
+    portalRoot
+  );
+});
+TooltipContent.displayName = "TooltipContent";
+
+// src/components/ui/button.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var { color: color3 } = semanticTokens_default;
+var buttonVariants = cva2(
+  "",
+  {
+    variants: {
+      variant: {
+        primary: "",
+        secondary: "",
+        destructive: "",
+        outline: "",
+        ghost: "",
+        link: ""
+      },
+      size: {
+        default: "",
+        sm: "",
+        lg: "",
+        icon: "",
+        iconLg: ""
+      },
+      shape: {
+        default: "",
+        pill: "rounded-full"
+      },
+      selected: {
+        true: "",
+        false: ""
+      }
+    },
+    defaultVariants: {
+      variant: "primary",
+      size: "default",
+      shape: "default"
+    }
+  }
+);
+var variantClasses = {
+  primary: "bg-interactive-brand text-white hover:bg-interactive-brand-hover",
+  secondary: "bg-neutral-white border border-[var(--btn-secondary-color)] text-[var(--btn-secondary-color)] hover:bg-popover",
+  destructive: "bg-destructive text-destructive-foreground hover:brightness-95",
+  outline: "bg-transparent border border-border-default text-foreground hover:bg-popover",
+  ghost: "bg-transparent text-foreground hover:bg-popover",
+  link: "bg-transparent text-interactive-brand underline-offset-4 hover:underline"
+};
+var variantStyles = {
+  secondary: { ["--btn-secondary-color"]: color3.text.cancel }
+};
+var sizeClasses = {
+  default: "px-4 py-1",
+  sm: "h-8 px-3 py-2 rounded-md",
+  lg: "h-10 px-8 py-2 text-lg rounded-lg",
+  icon: "p-[0.5rem] rounded-lg",
+  iconLg: "h-9 w-9 p-0"
+};
+var pillSizeClasses = {
+  default: "px-3.5 py-2 text-[0.8125rem]",
+  sm: "px-3 py-1 text-[0.75rem]",
+  lg: "px-4 py-2 text-[0.9375rem]",
+  icon: "h-10 w-10 p-0",
+  iconLg: "h-12 w-12 p-0"
+};
+var pillUnselected = "bg-neutral-white border border-neutral-350 text-neutral-600 hover:border-interactive-brand hover:text-interactive-brand";
+var pillSelected = "bg-[var(--pill-selected-bg)] border border-interactive-brand text-interactive-brand";
+var pillDisabled = "opacity-50 cursor-not-allowed";
+var selectedGradient = "border border-interactive-brand bg-gradient-to-r from-[var(--color-button-selected-gradient-start)] via-[var(--color-button-selected-gradient-mid)] to-interactive-brand text-white font-extrabold";
+var Button = React4.forwardRef(
+  ({ className, variant, size, shape, asChild = false, children, style, selected, tooltipText, ...props }, ref) => {
+    const finalVariant = variant ?? "primary";
+    const finalSize = size ?? "default";
+    const isPill = shape === "pill";
+    const isLink = finalVariant === "link";
+    const isIconButton = finalSize === "icon" || finalSize === "iconLg";
+    const baseClasses2 = cn(
+      "inline-flex items-center justify-center gap-2 font-medium text-body rounded-md disabled:opacity-50",
+      isIconButton ? "focus:outline-none focus:ring-0 focus:ring-offset-0 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0 focus-within:ring-0" : "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-interactive-brand"
+    );
+    const composed = cn(
+      baseClasses2,
+      isPill ? "rounded-full" : "",
+      variantClasses[finalVariant],
+      // Link never carries the size scale's own padding/height — it reads as inline text.
+      isLink ? "h-auto p-0" : isPill ? pillSizeClasses[finalSize] : sizeClasses[finalSize],
+      isPill ? selected ? pillSelected : pillUnselected : selected ? selectedGradient : "",
+      isPill && props.disabled ? pillDisabled : "",
+      buttonVariants({ variant: finalVariant, size: finalSize, shape, className })
+    );
+    const mergedStyle = {
+      ...variantStyles[finalVariant],
+      ...isPill && selected ? { ["--pill-selected-bg"]: `${color3.text.blue}24` } : void 0,
+      ...style
+    };
+    const element = asChild && React4.isValidElement(children) ? React4.cloneElement(children, {
+      className: cn(composed, children.props?.className),
+      ref,
+      ...props
+    }) : /* @__PURE__ */ jsx4("button", { className: cn(composed), ref, style: mergedStyle, ...props, children });
+    if (!tooltipText) {
+      return element;
+    }
+    return /* @__PURE__ */ jsxs2(Tooltip, { children: [
+      /* @__PURE__ */ jsx4(TooltipTrigger, { asChild: true, children: element }),
+      /* @__PURE__ */ jsx4(TooltipContent, { children: /* @__PURE__ */ jsx4("small", { children: tooltipText }) })
+    ] });
+  }
+);
+Button.displayName = "Button";
+
+// src/components/ui/buttonIcon.tsx
+import * as React5 from "react";
+import "class-variance-authority";
+
+// src/components/ui/iconTokens.ts
+import { cva as cva3 } from "class-variance-authority";
+var { color: color4 } = semanticTokens_default;
+var iconVariants = cva3(
+  "inline-flex items-center justify-center transition-all duration-200",
+  {
+    variants: {
+      variant: {
+        plain: "",
+        ghost: "bg-transparent",
+        outlined: "p-2 rounded-lg border border-border-default bg-neutral-white",
+        filled: "p-2 rounded-lg bg-interactive-brand text-neutral-white hover:opacity-[0.85]",
+        circle: "w-8 h-8 rounded-full",
+        modalClose: "p-2 rounded-lg border border-border-default bg-neutral-white mt-0.5",
+        refresh: "p-2 rounded-lg border border-border-default bg-neutral-white"
+      },
+      size: {
+        xs: "text-[0.625rem]",
+        sm: "text-[0.875rem]",
+        md: "text-[0.9375rem]",
+        lg: "text-[1.125rem]",
+        xl: "text-[1.5rem]"
+      }
+    },
+    defaultVariants: {
+      variant: "outlined",
+      size: "md"
+    }
+  }
+);
+var colorTokens = {
+  primary: {
+    base: color4.text.gray,
+    hover: color4.text.blue,
+    hoverBg: `${color4.interactive.brand}10`,
+    hoverBorder: color4.interactive.brand
+  },
+  secondary: {
+    base: color4.text.secondary,
+    hover: color4.text.secondary
+  },
+  muted: {
+    base: color4.text.muted,
+    hover: color4.text.primary
+  },
+  danger: {
+    base: color4.status.danger,
+    hover: color4.status.danger,
+    hoverBg: `${color4.status.danger}1A`,
+    hoverBorder: `${color4.status.danger}66`
+  },
+  success: {
+    base: color4.status.success,
+    hover: color4.status.success,
+    hoverBg: `${color4.status.success}1A`,
+    hoverBorder: `${color4.status.success}66`
+  },
+  warning: {
+    base: color4.status.warning,
+    hover: color4.status.warning,
+    hoverBg: `${color4.status.warning}1A`,
+    hoverBorder: `${color4.status.warning}66`
+  },
+  white: {
+    base: color4.text.white,
+    hover: color4.text.white
+  }
+};
+var actionColorTokens = {
+  call: { base: "var(--component-table-action-call-bg)", hover: "var(--component-table-action-call-hover)" },
+  end: { base: "var(--component-table-action-end-bg)", hover: "var(--component-table-action-end-hover)" },
+  hold: { base: "var(--component-table-action-hold-bg)", hover: "var(--component-table-action-hold-hover)" },
+  transfer: { base: "var(--component-table-action-transfer-bg)", hover: "var(--component-table-action-transfer-hover)" },
+  noShow: { base: "var(--component-table-action-noshow-bg)", hover: "var(--component-table-action-noshow-hover)" },
+  activate: { base: "var(--component-table-action-activate-bg)", hover: "var(--component-table-action-activate-hover)" },
+  success: { base: "var(--component-table-action-success-bg)", hover: "var(--component-table-action-success-hover)" }
+};
+function getIconColorProps(colorName, hoverColorName, bgColor) {
+  if (bgColor) {
+    const classes2 = ["text-neutral-white", "bg-[var(--icon-bg-color)]", "hover:opacity-[0.85]"];
+    const style2 = { "--icon-bg-color": bgColor.base };
+    return { className: classes2.join(" "), style: style2 };
+  }
+  const classes = ["text-[var(--icon-color)]"];
+  const style = {
+    "--icon-color": colorTokens[colorName].base
+  };
+  if (hoverColorName) {
+    const hoverEntry = colorTokens[hoverColorName];
+    classes.push("hover:text-[var(--icon-hover-color)]");
+    style["--icon-hover-color"] = hoverEntry.hover;
+    if (hoverEntry.hoverBg && hoverEntry.hoverBorder) {
+      classes.push("hover:bg-[var(--icon-hover-bg)] hover:border-[var(--icon-hover-border)]");
+      style["--icon-hover-bg"] = hoverEntry.hoverBg;
+      style["--icon-hover-border"] = hoverEntry.hoverBorder;
+    }
+  }
+  return { className: classes.join(" "), style };
+}
+
+// src/components/ui/buttonIcon.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var ButtonIcon = React5.forwardRef(
+  ({
+    name,
+    variant,
+    size,
+    color: color6 = "primary",
+    hoverColor,
+    bgColor,
+    bgHoverColor,
+    actionColor,
+    tooltipText,
+    showTooltip = false,
+    disabled,
+    className,
+    type = "button",
+    // Prevent accidental form submission
+    style,
+    children,
+    ...props
+  }, ref) => {
+    const isModalClose = variant === "modalClose";
+    const isRefresh = variant === "refresh";
+    const resolvedBg = bgColor ? { base: bgColor, hover: bgHoverColor } : actionColor ? actionColorTokens[actionColor] : void 0;
+    const effectiveSize = isRefresh ? "sm" : size;
+    const effectiveColor = isRefresh ? "primary" : color6;
+    const effectiveHoverColor = isRefresh ? "primary" : isModalClose ? "danger" : hoverColor;
+    const effectiveShowTooltip = isRefresh ? true : showTooltip;
+    const effectiveTooltipText = tooltipText;
+    const colorProps = getIconColorProps(effectiveColor, effectiveHoverColor, resolvedBg);
+    const icon = /* @__PURE__ */ jsx5(
+      "button",
+      {
+        ref,
+        type,
+        disabled,
+        style: { ...colorProps.style, ...style },
+        "aria-label": effectiveTooltipText,
+        className: cn(
+          iconVariants({ variant, size: effectiveSize }),
+          colorProps.className,
+          "inline-flex items-center justify-center",
+          // No icon button ever shows a focus ring/outline/shadow — keyboard focusability and
+          // click behavior are unaffected, only the visual ring is suppressed.
+          "focus:outline-none focus:ring-0 focus:ring-offset-0 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0 focus-visible:shadow-none focus-within:ring-0",
+          !disabled && "cursor-pointer",
+          disabled && "cursor-not-allowed opacity-50",
+          className
+        ),
+        ...props,
+        children: children ?? /* @__PURE__ */ jsx5("i", { className: name, "aria-hidden": "true" })
+      }
+    );
+    if (!effectiveShowTooltip) {
+      return icon;
+    }
+    return /* @__PURE__ */ jsxs3(Tooltip, { children: [
+      /* @__PURE__ */ jsx5(TooltipTrigger, { asChild: true, children: icon }),
+      /* @__PURE__ */ jsx5(TooltipContent, { children: /* @__PURE__ */ jsx5("small", { children: effectiveTooltipText }) })
+    ] });
+  }
+);
+ButtonIcon.displayName = "ButtonIcon";
+
+// src/components/ui/card.tsx
+import * as React6 from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var Card = React6.forwardRef(
+  ({ className, editing, ...props }, ref) => /* @__PURE__ */ jsx6(
+    "div",
+    {
+      ref,
+      className: cn(editing && "app-card--editing", className),
+      ...props
+    }
+  )
+);
+Card.displayName = "Card";
+var CardHeader = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6(
+  "div",
+  {
+    ref,
+    className: cn("flex flex-col space-y-1.5 p-6", className),
+    ...props
+  }
+));
+CardHeader.displayName = "CardHeader";
+var CardTitle = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6(
+  "div",
+  {
+    ref,
+    className: cn("font-semibold leading-none tracking-tight", className),
+    ...props
+  }
+));
+CardTitle.displayName = "CardTitle";
+var CardDescription = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6(
+  "div",
+  {
+    ref,
+    className: cn("text-body text-muted-foreground", className),
+    ...props
+  }
+));
+CardDescription.displayName = "CardDescription";
+var CardContent = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6("div", { ref, className: cn("", className), ...props }));
+CardContent.displayName = "CardContent";
+var CardFooter = React6.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx6(
+  "div",
+  {
+    ref,
+    className: cn("flex items-center", className),
+    ...props
+  }
+));
+CardFooter.displayName = "CardFooter";
+
+// src/components/ui/checkbox.tsx
+import * as React7 from "react";
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var { color: color5 } = semanticTokens_default;
+var boxSizeClasses = {
+  sm: "w-3.5 h-3.5",
+  md: "w-4 h-4",
+  lg: "w-5 h-5",
+  xl: "w-10 h-10",
+  "2xl": "w-8 h-8",
+  "3xl": "w-9 h-9"
+};
+var iconSizeClasses = {
+  sm: "text-[0.5rem]",
+  md: "text-[0.625rem]",
+  lg: "text-[0.75rem]",
+  xl: "text-[0.875rem]",
+  "2xl": "text-[1rem]",
+  "3xl": "text-[1.125rem]"
+};
+var dashSizeClasses = {
+  sm: "w-1.5 h-[0.09375rem]",
+  md: "w-2 h-0.5",
+  lg: "w-2.5 h-0.5",
+  xl: "w-3 h-[0.1875rem]",
+  "2xl": "w-3.5 h-[0.1875rem]",
+  "3xl": "w-4 h-[0.1875rem]"
+};
+var roundedClasses = {
+  sm: "rounded-sm",
+  md: "rounded-md",
+  lg: "rounded-lg",
+  xl: "rounded-xl",
+  "2xl": "rounded-2xl",
+  "3xl": "rounded-3xl"
+};
+function getCheckboxVisualProps(active, disabled, colorVariant, roundedVariant) {
+  const style = colorVariant === "blue" ? { ["--checkbox-checked-color"]: color5.text.blue } : colorVariant === "purple" ? { ["--checkbox-checked-color"]: color5.interactive.brand } : void 0;
+  const activeClasses = colorVariant === "blue" || colorVariant === "purple" ? "bg-[var(--checkbox-checked-color)] border-[var(--checkbox-checked-color)]" : "bg-status-success border-status-success";
+  const roundedClass = roundedVariant ? roundedClasses[roundedVariant] : "rounded";
+  const boxClasses = cn(
+    // "rounded border-2 flex items-center justify-center transition-colors",
+    ` ${roundedClass} border flex items-center justify-center transition-colors`,
+    active ? disabled ? "bg-neutral-600 border-neutral-600 opacity-60" : cn(activeClasses, "border-transparent") : disabled ? "bg-neutral-200 border-neutral-350 opacity-60" : "bg-neutral-white border-neutral-450"
+  );
+  return { style, boxClasses };
+}
+var CheckboxGlyph = ({ checked, indeterminate, size = "md" }) => {
+  if (indeterminate) {
+    return /* @__PURE__ */ jsx7("span", { className: cn("block rounded-sm bg-neutral-white", dashSizeClasses[size]) });
+  }
+  if (checked) {
+    return /* @__PURE__ */ jsx7("i", { className: cn("icon-neo-check text-neutral-white", iconSizeClasses[size]) });
+  }
+  return null;
+};
+var CheckboxIndicator = React7.forwardRef(
+  ({ checked, indeterminate = false, disabled, colorVariant = "blue", size = "md", className, roundedVariant }, ref) => {
+    const active = !!checked || indeterminate;
+    const { style, boxClasses } = getCheckboxVisualProps(active, disabled, colorVariant, roundedVariant);
+    return /* @__PURE__ */ jsx7(
+      "span",
+      {
+        ref,
+        "aria-hidden": "true",
+        className: cn(boxSizeClasses[size], boxClasses, "shrink-0", className),
+        style,
+        children: /* @__PURE__ */ jsx7(CheckboxGlyph, { checked, indeterminate, size })
+      }
+    );
+  }
+);
+CheckboxIndicator.displayName = "CheckboxIndicator";
+var Checkbox = React7.forwardRef(
+  ({
+    className,
+    wrapperClassName,
+    labelClassName,
+    colorVariant = "blue",
+    size = "md",
+    indeterminate = false,
+    disabled,
+    checked,
+    label,
+    style,
+    roundedVariant,
+    ...props
+  }, ref) => {
+    const internalRef = React7.useRef(null);
+    React7.useImperativeHandle(ref, () => internalRef.current);
+    React7.useEffect(() => {
+      if (internalRef.current) internalRef.current.indeterminate = indeterminate;
+    }, [indeterminate]);
+    const active = !!checked || indeterminate;
+    const { style: colorStyle, boxClasses } = getCheckboxVisualProps(active, disabled, colorVariant, roundedVariant);
+    const Wrapper = label ? "label" : "span";
+    return /* @__PURE__ */ jsxs4(
+      Wrapper,
+      {
+        className: cn(
+          "inline-flex items-center gap-2.5 select-none",
+          label && "cursor-pointer",
+          disabled && "cursor-not-allowed",
+          wrapperClassName
+        ),
+        children: [
+          /* @__PURE__ */ jsxs4(
+            "span",
+            {
+              className: cn("relative inline-flex shrink-0", boxSizeClasses[size]),
+              style: { ...colorStyle, ...style },
+              children: [
+                /* @__PURE__ */ jsx7(
+                  "input",
+                  {
+                    ref: internalRef,
+                    type: "checkbox",
+                    checked,
+                    disabled,
+                    className: cn(
+                      "peer absolute inset-0 w-full h-full opacity-0 cursor-pointer disabled:cursor-not-allowed",
+                      className
+                    ),
+                    ...props
+                  }
+                ),
+                /* @__PURE__ */ jsx7(
+                  "span",
+                  {
+                    "aria-hidden": "true",
+                    className: cn(
+                      boxClasses,
+                      "w-full h-full peer-focus-visible:ring-2 peer-focus-visible:ring-interactive-brand peer-focus-visible:ring-offset-2"
+                    ),
+                    children: /* @__PURE__ */ jsx7(CheckboxGlyph, { checked, indeterminate, size })
+                  }
+                )
+              ]
+            }
+          ),
+          label && /* @__PURE__ */ jsx7("span", { className: cn("text-[0.8125rem] text-neutral-700 font-normal", labelClassName), children: label })
+        ]
+      }
+    );
+  }
+);
+Checkbox.displayName = "Checkbox";
+
+// src/components/ui/delete-action.tsx
+import "react";
+
+// src/components/ui/icon.tsx
+import * as React8 from "react";
+import "class-variance-authority";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var Icon = React8.forwardRef(
+  ({
+    name,
+    variant,
+    size,
+    color: color6 = "primary",
+    hoverColor,
+    tooltipText,
+    showTooltip = false,
+    disabled,
+    className,
+    onClick,
+    style,
+    ...props
+  }, ref) => {
+    const colorProps = getIconColorProps(color6, hoverColor);
+    const icon = /* @__PURE__ */ jsx8(
+      "i",
+      {
+        ref,
+        className: cn(
+          `${name}`,
+          iconVariants({ variant, size }),
+          colorProps.className,
+          onClick && !disabled && "cursor-pointer",
+          className
+        ),
+        onClick,
+        style: { ...colorProps.style, ...style },
+        role: onClick ? "button" : void 0,
+        tabIndex: onClick ? 0 : void 0,
+        "aria-label": tooltipText || name,
+        onKeyDown: (e) => {
+          if (!onClick) return;
+          if (e.key === "Enter" || e.key === " ") {
+            e.preventDefault();
+            onClick(
+              e
+            );
+          }
+        },
+        ...props
+      }
+    );
+    if (!showTooltip) {
+      return icon;
+    }
+    return /* @__PURE__ */ jsxs5(Tooltip, { children: [
+      /* @__PURE__ */ jsx8(TooltipTrigger, { asChild: true, children: icon }),
+      /* @__PURE__ */ jsx8(TooltipContent, { children: /* @__PURE__ */ jsx8("small", { children: tooltipText || name }) })
+    ] });
+  }
+);
+Icon.displayName = "Icon";
+
+// src/components/ui/delete-action.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var DeleteAction = ({ onClick, tooltipText, showTooltip = true, className }) => {
+  return /* @__PURE__ */ jsx9(
+    Icon,
+    {
+      name: "icon-neo-trash",
+      hoverColor: "danger",
+      onClick,
+      showTooltip,
+      tooltipText: tooltipText || "Delete",
+      className
+    }
+  );
+};
+var delete_action_default = DeleteAction;
+
+// src/components/ui/dialog.tsx
+import * as React10 from "react";
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var DialogContext = React10.createContext(void 0);
+function useDialog() {
+  const context = React10.useContext(DialogContext);
+  if (!context) {
+    throw new Error("Dialog components must be used within Dialog");
+  }
+  return context;
+}
+var Dialog = ({ open: controlledOpen, onOpenChange, children }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React10.useState(false);
+  const open = controlledOpen !== void 0 ? controlledOpen : uncontrolledOpen;
+  const setOpen = onOpenChange || setUncontrolledOpen;
+  return /* @__PURE__ */ jsx10(DialogContext.Provider, { value: { open, onOpenChange: setOpen }, children });
+};
+var DialogTrigger = React10.forwardRef(({ onClick, ...props }, ref) => {
+  const { onOpenChange } = useDialog();
+  return /* @__PURE__ */ jsx10(
+    Button,
+    {
+      ref,
+      onClick: (e) => {
+        onOpenChange(true);
+        onClick?.(e);
+      },
+      variant: "ghost",
+      size: "default",
+      ...props
+    }
+  );
+});
+DialogTrigger.displayName = "DialogTrigger";
+var DialogPortal = ({ children }) => {
+  const { open } = useDialog();
+  if (!open) return null;
+  return /* @__PURE__ */ jsx10(Fragment2, { children });
+};
+var DialogClose = React10.forwardRef(({ onClick, ...props }, ref) => {
+  const { onOpenChange } = useDialog();
+  return /* @__PURE__ */ jsx10(
+    Button,
+    {
+      ref,
+      onClick: (e) => {
+        onOpenChange(false);
+        onClick?.(e);
+      },
+      variant: "ghost",
+      size: "default",
+      ...props
+    }
+  );
+});
+DialogClose.displayName = "DialogClose";
+var DialogOverlay = React10.forwardRef(({ className, onClick, closeOnClick = true, ...props }, ref) => {
+  const { onOpenChange } = useDialog();
+  return /* @__PURE__ */ jsx10(
+    "div",
+    {
+      ref,
+      className: cn(
+        "fixed inset-0 z-[var(--zindex-modal)] bg-[var(--color-ext-00000080)] animate-in fade-in-0",
+        className
+      ),
+      onClick: (e) => {
+        if (closeOnClick) onOpenChange(false);
+        onClick?.(e);
+      },
+      ...props
+    }
+  );
+});
+DialogOverlay.displayName = "DialogOverlay";
+var DialogContent = React10.forwardRef(({ className, children, showCloseButton = true, closeOnEscape = true, closeOnOverlayClick = true, ...props }, ref) => {
+  const { onOpenChange } = useDialog();
+  React10.useEffect(() => {
+    if (!closeOnEscape) return;
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        onOpenChange(false);
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    return () => document.removeEventListener("keydown", handleEscape);
+  }, [onOpenChange, closeOnEscape]);
+  return /* @__PURE__ */ jsxs6(DialogPortal, { children: [
+    /* @__PURE__ */ jsx10(DialogOverlay, { closeOnClick: closeOnOverlayClick }),
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        ref,
+        className: cn(
+          "fixed left-[50%] top-[50%] z-[var(--zindex-modal)] grid w-full max-w-6xl translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 animate-in fade-in-0 zoom-in-95 rounded-lg",
+          className
+        ),
+        onClick: (e) => e.stopPropagation(),
+        ...props,
+        children: [
+          children,
+          showCloseButton && /* @__PURE__ */ jsx10(
+            ButtonIcon,
+            {
+              type: "button",
+              name: "icon-neo-close",
+              variant: "modalClose",
+              className: "absolute right-4 top-4",
+              onClick: () => onOpenChange(false)
+            }
+          )
+        ]
+      }
+    )
+  ] });
+});
+DialogContent.displayName = "DialogContent";
+var DialogHeader = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx10(
+  "div",
+  {
+    className: cn(
+      "flex flex-col space-y-1.5 text-center sm:text-left",
+      className
+    ),
+    ...props
+  }
+);
+DialogHeader.displayName = "DialogHeader";
+var DialogFooter = ({
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx10(
+  "div",
+  {
+    className: cn(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      className
+    ),
+    ...props
+  }
+);
+DialogFooter.displayName = "DialogFooter";
+var DialogTitle = React10.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx10(
+  "h2",
+  {
+    ref,
+    className: cn(
+      "text-heading font-semibold leading-none tracking-tight",
+      className
+    ),
+    ...props
+  }
+));
+DialogTitle.displayName = "DialogTitle";
+var DialogDescription = React10.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx10(
+  "p",
+  {
+    ref,
+    className: cn("text-body text-muted-foreground", className),
+    ...props
+  }
+));
+DialogDescription.displayName = "DialogDescription";
+
+// src/components/ui/dropdown-menu.tsx
+import * as React11 from "react";
+import { createPortal as createPortal2 } from "react-dom";
+import { Check, ChevronRight, Circle } from "lucide-react";
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var DropdownMenuContext = React11.createContext(void 0);
+function useDropdownMenu() {
+  const context = React11.useContext(DropdownMenuContext);
+  if (!context) {
+    throw new Error("DropdownMenu components must be used within DropdownMenu");
+  }
+  return context;
+}
+var DropdownMenu = ({ open: controlledOpen, onOpenChange, children }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React11.useState(false);
+  const open = controlledOpen !== void 0 ? controlledOpen : uncontrolledOpen;
+  const setOpen = onOpenChange || setUncontrolledOpen;
+  const triggerRef = React11.useRef(null);
+  return /* @__PURE__ */ jsx11(DropdownMenuContext.Provider, { value: { open, setOpen, triggerRef }, children });
+};
+var DropdownMenuTrigger = React11.forwardRef(({ onClick, children, asChild, ...props }, ref) => {
+  const { setOpen, open, triggerRef } = useDropdownMenu();
+  if (asChild && React11.isValidElement(children)) {
+    return React11.cloneElement(children, {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (ref) {
+          if (typeof ref === "function") {
+            ref(node);
+          } else {
+            ref.current = node;
+          }
+        }
+      },
+      onClick: (e) => {
+        setOpen(!open);
+        const childOnClick = children.props?.onClick;
+        childOnClick?.(e);
+        onClick?.(e);
+      }
+    });
+  }
+  return /* @__PURE__ */ jsx11(
+    Button,
+    {
+      ref: (node) => {
+        triggerRef.current = node;
+        if (ref) {
+          if (typeof ref === "function") {
+            ref(node);
+          } else {
+            ref.current = node;
+          }
+        }
+      },
+      onClick: (e) => {
+        setOpen(!open);
+        onClick?.(e);
+      },
+      variant: "ghost",
+      ...props,
+      children
+    }
+  );
+});
+DropdownMenuTrigger.displayName = "DropdownMenuTrigger";
+var DropdownMenuGroup = ({ children }) => {
+  return /* @__PURE__ */ jsx11("div", { role: "group", children });
+};
+var DropdownMenuPortal = ({ children }) => {
+  const portalRoot = document.getElementById("fpneo") || document.body;
+  return createPortal2(children, portalRoot);
+};
+var DropdownMenuSub = ({ children }) => {
+  return /* @__PURE__ */ jsx11(Fragment3, { children });
+};
+var DropdownMenuRadioGroup = ({ children }) => {
+  return /* @__PURE__ */ jsx11("div", { role: "radiogroup", children });
+};
+var DropdownMenuSubTrigger = React11.forwardRef(({ className, inset, children, ...props }, ref) => /* @__PURE__ */ jsxs7(
+  "div",
+  {
+    ref,
+    className: cn(
+      "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-body outline-none focus:bg-accent",
+      inset && "pl-8",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsx11(ChevronRight, { className: "ml-auto h-4 w-4" })
+    ]
+  }
+));
+DropdownMenuSubTrigger.displayName = "DropdownMenuSubTrigger";
+var DropdownMenuSubContent = React11.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx11(
+  "div",
+  {
+    ref,
+    className: cn(
+      "z-[var(--zindex-modal)] min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuSubContent.displayName = "DropdownMenuSubContent";
+var DropdownMenuContent = React11.forwardRef(({ className, sideOffset = 4, align = "end", ...props }, ref) => {
+  const { open, setOpen, triggerRef } = useDropdownMenu();
+  const contentRef = React11.useRef(null);
+  const [position, setPosition] = React11.useState({ top: 0, left: 0 });
+  const [isPositioned, setIsPositioned] = React11.useState(false);
+  React11.useImperativeHandle(ref, () => contentRef.current);
+  React11.useEffect(() => {
+    if (!open || !triggerRef.current) {
+      setIsPositioned(false);
+      return;
+    }
+    const updatePosition = () => {
+      if (!triggerRef.current || !contentRef.current) return;
+      const contentWidth = contentRef.current.offsetWidth || 0;
+      const contentHeight = contentRef.current.offsetHeight || 0;
+      if (contentWidth === 0 || contentHeight === 0) {
+        return;
+      }
+      const triggerRect = triggerRef.current.getBoundingClientRect();
+      let left = triggerRect.left;
+      let top = triggerRect.bottom + sideOffset;
+      if (align === "end") {
+        left = triggerRect.right - contentWidth;
+      } else if (align === "center") {
+        left = triggerRect.left + (triggerRect.width - contentWidth) / 2;
+      }
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      if (left + contentWidth > viewportWidth - 8) {
+        left = viewportWidth - contentWidth - 8;
+      }
+      if (left < 8) {
+        left = 8;
+      }
+      if (top + contentHeight > viewportHeight - 8) {
+        top = triggerRect.top - contentHeight - sideOffset;
+      }
+      if (top < 8) {
+        top = triggerRect.bottom + sideOffset;
+      }
+      setPosition({ top, left });
+      setIsPositioned(true);
+    };
+    requestAnimationFrame(() => {
+      updatePosition();
+      const timer1 = setTimeout(updatePosition, 10);
+      const timer2 = setTimeout(updatePosition, 50);
+      const timer3 = setTimeout(updatePosition, 100);
+      return () => {
+        clearTimeout(timer1);
+        clearTimeout(timer2);
+        clearTimeout(timer3);
+      };
+    });
+    window.addEventListener("scroll", updatePosition, true);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      window.removeEventListener("scroll", updatePosition, true);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [open, sideOffset, align, triggerRef]);
+  React11.useEffect(() => {
+    if (!open) return;
+    const handleClickOutside = (e) => {
+      if (contentRef.current && !contentRef.current.contains(e.target) && triggerRef.current && !triggerRef.current.contains(e.target)) {
+        setOpen(false);
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        setOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [open, setOpen, triggerRef]);
+  if (!open) return null;
+  return /* @__PURE__ */ jsx11(DropdownMenuPortal, { children: /* @__PURE__ */ jsx11(
+    "div",
+    {
+      ref: contentRef,
+      className: cn(
+        "dropdownHead",
+        isPositioned ? "opacity-100" : "opacity-0",
+        className
+      ),
+      style: {
+        top: `${position.top}px`,
+        left: `${position.left}px`
+      },
+      ...props
+    }
+  ) });
+});
+DropdownMenuContent.displayName = "DropdownMenuContent";
+var DropdownMenuItem = React11.forwardRef(({ className, inset, onClick, ...props }, ref) => {
+  const { setOpen } = useDropdownMenu();
+  return /* @__PURE__ */ jsx11(
+    "div",
+    {
+      ref,
+      className: cn(
+        "dropdownInner",
+        inset && "pl-8",
+        className
+      ),
+      onClick: (e) => {
+        onClick?.(e);
+        setOpen(false);
+      },
+      ...props
+    }
+  );
+});
+DropdownMenuItem.displayName = "DropdownMenuItem";
+var DropdownMenuCheckboxItem = React11.forwardRef(({ className, children, checked, ...props }, ref) => /* @__PURE__ */ jsxs7(
+  "div",
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-body transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx11("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: checked && /* @__PURE__ */ jsx11(Check, { className: "h-4 w-4" }) }),
+      children
+    ]
+  }
+));
+DropdownMenuCheckboxItem.displayName = "DropdownMenuCheckboxItem";
+var DropdownMenuRadioItem = React11.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxs7(
+  "div",
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-body outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props,
+    children: [
+      /* @__PURE__ */ jsx11("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ jsx11(Circle, { className: "h-2 w-2 fill-current" }) }),
+      children
+    ]
+  }
+));
+DropdownMenuRadioItem.displayName = "DropdownMenuRadioItem";
+var DropdownMenuLabel = React11.forwardRef(({ className, inset, ...props }, ref) => /* @__PURE__ */ jsx11(
+  "div",
+  {
+    ref,
+    className: cn(
+      "px-2 py-1.5 text-label font-semibold",
+      inset && "pl-8",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuLabel.displayName = "DropdownMenuLabel";
+var DropdownMenuSeparator = React11.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx11(
+  "div",
+  {
+    ref,
+    className: cn("my-1 h-px bg-neutral-350", className),
+    ...props
+  }
+));
+DropdownMenuSeparator.displayName = "DropdownMenuSeparator";
+var DropdownMenuShortcut = ({
+  className,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx11(
+    "span",
+    {
+      className: cn("ml-auto text-label tracking-widest opacity-60", className),
+      ...props
+    }
+  );
+};
+DropdownMenuShortcut.displayName = "DropdownMenuShortcut";
+
+// src/components/ui/expandable-search.tsx
+import { useEffect as useEffect6, useRef as useRef5, useState as useState4 } from "react";
+
+// src/components/ui/input.tsx
+import * as React12 from "react";
+import { Field } from "formik";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var baseClasses = [
+  "flex h-[2.571rem] w-full items-center rounded-[0.65rem] px-4 py-0",
+  "text-[0.8125rem] text-[var(--color-neutral-800)]",
+  "placeholder:text-[0.8125rem]",
+  "placeholder:text-neutral-400",
+  "bg-background-card",
+  "border border-neutral-300",
+  "transition-colors",
+  "file:border-0 file:bg-transparent file:text-body file:font-medium",
+  "focus-visible:outline-none",
+  "focus-visible:border-[var(--focus-ring-color)]",
+  "focus-visible:ring-1",
+  "focus-visible:ring-[var(--focus-ring-color-soft)]",
+  "disabled:cursor-not-allowed",
+  "disabled:opacity-50"
+].join(" ");
+var Input = React12.forwardRef(
+  ({
+    as = "input",
+    className,
+    error,
+    type = "text",
+    style,
+    autoFocus = false,
+    innerRef,
+    ...props
+  }, ref) => {
+    const internalRef = React12.useRef(null);
+    React12.useImperativeHandle(ref, () => internalRef.current);
+    React12.useImperativeHandle(innerRef, () => internalRef.current);
+    React12.useEffect(() => {
+      if (autoFocus) {
+        internalRef.current?.focus();
+      }
+    }, [autoFocus]);
+    const classes = cn(
+      baseClasses,
+      error && "border-status-danger focus-visible:ring-status-danger",
+      className
+    );
+    if (as === "field") {
+      return /* @__PURE__ */ jsx12(
+        Field,
+        {
+          innerRef: internalRef,
+          type,
+          className: classes,
+          style,
+          autoFocus,
+          ...props
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx12(
+      "input",
+      {
+        ref: internalRef,
+        type,
+        className: classes,
+        style,
+        autoFocus,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/components/ui/expandable-search.tsx
+import { jsx as jsx13, jsxs as jsxs8 } from "react/jsx-runtime";
+var ExpandableSearch = ({ onSearch, placeholder = "Search...", className = "" }) => {
+  const [isExpanded, setIsExpanded] = useState4(false);
+  const [searchValue, setSearchValue] = useState4("");
+  const inputRef = useRef5(null);
+  useEffect6(() => {
+    if (isExpanded && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [isExpanded]);
+  const handleToggle = () => {
+    if (isExpanded && searchValue) {
+      setSearchValue("");
+      onSearch("");
+    }
+    setIsExpanded(!isExpanded);
+  };
+  const handleChange = (e) => {
+    const value = e.target.value;
+    setSearchValue(value);
+    onSearch(value);
+  };
+  const handleClear = () => {
+    setSearchValue("");
+    onSearch("");
+    if (inputRef.current) {
+      inputRef.current.focus();
+    }
+  };
+  return /* @__PURE__ */ jsx13("div", { className: `flex items-center ${className}`, children: isExpanded ? /* @__PURE__ */ jsxs8("div", { className: "flex items-center gap-2 transition-all duration-300 ease-in-out", children: [
+    /* @__PURE__ */ jsxs8("div", { className: "relative flex justify-center items-center", children: [
+      /* @__PURE__ */ jsx13(
+        Input,
+        {
+          ref: inputRef,
+          type: "text",
+          value: searchValue,
+          onChange: handleChange,
+          placeholder,
+          className: "formfield__search"
+        }
+      ),
+      searchValue && /* @__PURE__ */ jsx13(
+        Button,
+        {
+          onClick: handleClear,
+          variant: "ghost",
+          size: "icon",
+          className: "absolute right-3 top-1/2 -translate-y-1/2 text-neutral-600 hover:text-[var(--color-ext-4b5563)] transition-colors",
+          children: /* @__PURE__ */ jsx13("i", { className: "icon-neo-close text-[0.875rem]" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx13(Button, { variant: "ghost", size: "icon", onClick: handleToggle, children: /* @__PURE__ */ jsx13("i", { className: "icon-neo-close text-[0.875rem]" }) })
+  ] }) : /* @__PURE__ */ jsx13(Button, { variant: "ghost", size: "icon", onClick: handleToggle, className: "header__round-btn", children: /* @__PURE__ */ jsx13("i", { className: "icon-neo-search" }) }) });
+};
+
+// src/components/ui/file-input.tsx
+import * as React14 from "react";
+import { Fragment as Fragment4, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+var FileInput = React14.forwardRef(
+  ({
+    id,
+    className,
+    wrapperClassName,
+    labelClassName,
+    labelStyle,
+    labelProps,
+    children,
+    disabled,
+    ...props
+  }, ref) => {
+    const generatedId = React14.useId();
+    const inputId = id ?? generatedId;
+    const content = /* @__PURE__ */ jsxs9(Fragment4, { children: [
+      /* @__PURE__ */ jsx14(
+        "input",
+        {
+          ref,
+          type: "file",
+          id: inputId,
+          disabled,
+          className: cn("hidden", className),
+          ...props
+        }
+      ),
+      children && /* @__PURE__ */ jsx14("label", { htmlFor: inputId, className: labelClassName, style: labelStyle, ...labelProps, children })
+    ] });
+    return wrapperClassName ? /* @__PURE__ */ jsx14("div", { className: wrapperClassName, children: content }) : content;
+  }
+);
+FileInput.displayName = "FileInput";
+
+// src/components/ui/form-field.tsx
+import "react";
+import { ErrorMessage } from "formik";
+import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
+var FormField = ({
+  label,
+  required,
+  errorName,
+  error,
+  hint,
+  children,
+  className
+}) => /* @__PURE__ */ jsxs10("div", { className: cn("form__field", className), children: [
+  label && /* @__PURE__ */ jsxs10("label", { className: "formfield__label", children: [
+    label,
+    required && /* @__PURE__ */ jsx15("span", { className: "required-field", children: "*" })
+  ] }),
+  children,
+  hint && /* @__PURE__ */ jsx15("p", { className: "text-[0.75rem] text-neutral-600 mt-1", children: hint }),
+  errorName && /* @__PURE__ */ jsx15(ErrorMessage, { name: errorName, component: "p", className: "form-error" }),
+  !errorName && error && /* @__PURE__ */ jsx15("p", { className: "form-error", children: error })
+] });
+var form_field_default = FormField;
+
+// src/components/ui/list.tsx
+import * as React16 from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+var AppList = React16.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx16("div", { ref, className: cn("app-list-wrapper", className), ...props }));
+AppList.displayName = "AppList";
+var AppListHeader = React16.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx16("div", { ref, className: cn("app-list-header", className), ...props }));
+AppListHeader.displayName = "AppListHeader";
+var AppListBody = React16.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx16("div", { ref, className: cn("app-list-body", className), ...props }));
+AppListBody.displayName = "AppListBody";
+var AppListItem = React16.forwardRef(
+  ({ className, editing, ...props }, ref) => /* @__PURE__ */ jsx16(
+    "div",
+    {
+      ref,
+      className: cn(
+        "app-list-row",
+        editing && "app-list-row--editing",
+        className
+      ),
+      ...props
+    }
+  )
+);
+AppListItem.displayName = "AppListItem";
+var AppListCell = React16.forwardRef(
+  ({ className, muted, actions, ...props }, ref) => /* @__PURE__ */ jsx16(
+    "div",
+    {
+      ref,
+      className: cn(
+        "app-list-cell",
+        muted && "app-list-cell--muted",
+        actions && "app-list-cell--actions",
+        className
+      ),
+      ...props
+    }
+  )
+);
+AppListCell.displayName = "AppListCell";
+
+// src/components/ui/loader.tsx
+import "react";
+
+// src/assets/fp-loader.gif
+var fp_loader_default = "data:image/gif;base64,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";
+
+// src/components/ui/loader.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+var Loader = ({ isLoading }) => {
+  if (!isLoading) return null;
+  return /* @__PURE__ */ jsx17("div", { className: "fp-loader-overlay fp-loader-overlay--visible", children: /* @__PURE__ */ jsx17("div", { className: "fp-loader-content", children: /* @__PURE__ */ jsx17(
+    "img",
+    {
+      src: fp_loader_default,
+      alt: "",
+      className: "fp-loader-gif"
+    }
+  ) }) });
+};
+var loader_default = Loader;
+
+// src/components/ui/popover.tsx
+import * as React18 from "react";
+import { createPortal as createPortal3 } from "react-dom";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var PopoverContext = React18.createContext(void 0);
+function usePopoverContext() {
+  const context = React18.useContext(PopoverContext);
+  if (!context) {
+    throw new Error("Popover components must be used within a Popover");
+  }
+  return context;
+}
+function Popover({ open: controlledOpen, onOpenChange, children }) {
+  const [uncontrolledOpen, setUncontrolledOpen] = React18.useState(false);
+  const triggerRef = React18.useRef(null);
+  const open = controlledOpen ?? uncontrolledOpen;
+  const handleOpenChange = onOpenChange ?? setUncontrolledOpen;
+  return /* @__PURE__ */ jsx18(PopoverContext.Provider, { value: { open, onOpenChange: handleOpenChange, triggerRef }, children });
+}
+var PopoverTrigger = React18.forwardRef(
+  ({ asChild = false, children, ...props }, ref) => {
+    const { triggerRef } = usePopoverContext();
+    const combinedRef = React18.useCallback(
+      (node) => {
+        triggerRef.current = node;
+        if (typeof ref === "function") {
+          ref(node);
+        } else if (ref) {
+          ref.current = node;
+        }
+      },
+      [ref, triggerRef]
+    );
+    if (asChild && React18.isValidElement(children)) {
+      return React18.cloneElement(children, {
+        ...props,
+        ...children.props,
+        ref: combinedRef
+      });
+    }
+    return children;
+  }
+);
+PopoverTrigger.displayName = "PopoverTrigger";
+var PopoverContent = React18.forwardRef(
+  ({ className, side = "bottom", align = "center", sideOffset = 4, children, onMouseEnter, onMouseLeave, ...props }, ref) => {
+    const { open, triggerRef } = usePopoverContext();
+    const contentRef = React18.useRef(null);
+    const [position, setPosition] = React18.useState({ top: 0, left: 0 });
+    const [isPositioned, setIsPositioned] = React18.useState(false);
+    React18.useEffect(() => {
+      if (!open || !triggerRef.current) {
+        setIsPositioned(false);
+        return;
+      }
+      const updatePosition = () => {
+        if (!triggerRef.current || !contentRef.current) return;
+        const triggerRect = triggerRef.current.getBoundingClientRect();
+        const contentRect = contentRef.current.getBoundingClientRect();
+        if (contentRect.width === 0 || contentRect.height === 0) {
+          return;
+        }
+        let top = 0;
+        let left = 0;
+        switch (side) {
+          case "top":
+            top = triggerRect.top - contentRect.height - sideOffset;
+            break;
+          case "bottom":
+            top = triggerRect.bottom + sideOffset;
+            break;
+          case "left":
+            left = triggerRect.left - contentRect.width - sideOffset;
+            break;
+          case "right":
+            left = triggerRect.right + sideOffset;
+            break;
+        }
+        if (side === "top" || side === "bottom") {
+          switch (align) {
+            case "start":
+              left = triggerRect.left;
+              break;
+            case "center":
+              left = triggerRect.left + triggerRect.width / 2 - contentRect.width / 2;
+              break;
+            case "end":
+              left = triggerRect.right - contentRect.width;
+              break;
+          }
+        } else {
+          switch (align) {
+            case "start":
+              top = triggerRect.top;
+              break;
+            case "center":
+              top = triggerRect.top + triggerRect.height / 2 - contentRect.height / 2;
+              break;
+            case "end":
+              top = triggerRect.bottom - contentRect.height;
+              break;
+          }
+        }
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        if (left + contentRect.width > viewportWidth - 8) {
+          left = viewportWidth - contentRect.width - 8;
+        }
+        if (left < 8) {
+          left = 8;
+        }
+        if (top + contentRect.height > viewportHeight - 8) {
+          if (side === "bottom") {
+            top = triggerRect.top - contentRect.height - sideOffset;
+          } else if (side === "right" || side === "left") {
+            top = viewportHeight - contentRect.height - 8;
+          }
+        }
+        if (top < 8) {
+          top = 8;
+        }
+        setPosition({ top, left });
+        setIsPositioned(true);
+      };
+      requestAnimationFrame(() => {
+        updatePosition();
+        const timer1 = setTimeout(updatePosition, 10);
+        const timer2 = setTimeout(updatePosition, 50);
+        const timer3 = setTimeout(updatePosition, 100);
+        return () => {
+          clearTimeout(timer1);
+          clearTimeout(timer2);
+          clearTimeout(timer3);
+        };
+      });
+      window.addEventListener("scroll", updatePosition, true);
+      window.addEventListener("resize", updatePosition);
+      return () => {
+        window.removeEventListener("scroll", updatePosition, true);
+        window.removeEventListener("resize", updatePosition);
+      };
+    }, [open, side, align, sideOffset]);
+    if (!open) return null;
+    const portalRoot = document.getElementById("fpneo") || document.body;
+    return createPortal3(
+      /* @__PURE__ */ jsx18(
+        "div",
+        {
+          ref: (node) => {
+            contentRef.current = node;
+            if (typeof ref === "function") {
+              ref(node);
+            } else if (ref) {
+              ref.current = node;
+            }
+          },
+          className: cn(
+            "fixed z-[var(--zindex-overlay)] w-72 rounded-[0.625rem] border border-neutral-350 bg-neutral-white p-4 shadow-lg outline-none transition-opacity duration-150",
+            isPositioned ? "opacity-100" : "opacity-0",
+            className
+          ),
+          style: {
+            top: `${position.top}px`,
+            left: `${position.left}px`
+          },
+          onMouseEnter,
+          onMouseLeave,
+          ...props,
+          children
+        }
+      ),
+      portalRoot
+    );
+  }
+);
+PopoverContent.displayName = "PopoverContent";
+
+// src/components/ui/radio.tsx
+import * as React19 from "react";
+import { jsx as jsx19, jsxs as jsxs11 } from "react/jsx-runtime";
+var sizeClasses2 = {
+  sm: "w-3.5 h-3.5",
+  md: "w-4 h-4",
+  lg: "w-5 h-5"
+};
+var colorClasses = {
+  brand: "accent-interactive-brand",
+  blue: "text-[var(--color-ext-2563eb)] focus:ring-[var(--color-ext-3b82f6)]"
+};
+var RadioButton = React19.forwardRef(
+  ({
+    className,
+    wrapperClassName,
+    labelClassName,
+    colorVariant = "brand",
+    size = "md",
+    label,
+    disabled,
+    ...props
+  }, ref) => {
+    const input = /* @__PURE__ */ jsx19(
+      "input",
+      {
+        ref,
+        type: "radio",
+        disabled,
+        className: cn(sizeClasses2[size], colorClasses[colorVariant], className),
+        ...props
+      }
+    );
+    if (!label) return input;
+    return /* @__PURE__ */ jsxs11(
+      "label",
+      {
+        className: cn(
+          "inline-flex items-center gap-2 select-none cursor-pointer",
+          disabled && "cursor-not-allowed",
+          wrapperClassName
+        ),
+        children: [
+          input,
+          /* @__PURE__ */ jsx19("span", { className: cn("text-[0.8125rem] text-neutral-700 font-normal", labelClassName), children: label })
+        ]
+      }
+    );
+  }
+);
+RadioButton.displayName = "RadioButton";
+
+// src/components/ui/scroll-area.tsx
+import * as React20 from "react";
+import { jsx as jsx20 } from "react/jsx-runtime";
+var ScrollArea = React20.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsx20(
+  "div",
+  {
+    ref,
+    className: cn(
+      "relative overflow-y-auto overflow-x-hidden",
+      "[&::-webkit-scrollbar]:w-[0.375rem]",
+      "[&::-webkit-scrollbar-track]:bg-transparent",
+      "[&::-webkit-scrollbar-thumb]:bg-[var(--color-ext-d1d5db80)]",
+      "[&::-webkit-scrollbar-thumb]:rounded-full",
+      "[&::-webkit-scrollbar-thumb]:border-2",
+      "[&::-webkit-scrollbar-thumb]:border-solid",
+      "[&::-webkit-scrollbar-thumb]:border-transparent",
+      "[&::-webkit-scrollbar-thumb]:bg-clip-padding",
+      "hover:[&::-webkit-scrollbar-thumb]:bg-[var(--color-ext-9ca3afb3)]",
+      "[&::-webkit-scrollbar-thumb]:transition-colors",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx20("div", { className: "h-full w-full", children })
+  }
+));
+ScrollArea.displayName = "ScrollArea";
+var ScrollBar = React20.forwardRef(({ className, orientation = "vertical", ...props }, ref) => /* @__PURE__ */ jsx20(
+  "div",
+  {
+    ref,
+    className: cn(
+      "flex touch-none select-none transition-colors",
+      orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent p-[0.0625rem]",
+      orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-[0.0625rem]",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsx20("div", { className: "relative flex-1 rounded-full bg-border" })
+  }
+));
+ScrollBar.displayName = "ScrollBar";
+
+// src/components/ui/scroll-to-field-error.tsx
+import { useEffect as useEffect8, useRef as useRef7 } from "react";
+import { useFormikContext } from "formik";
+var ScrollToFieldError = () => {
+  const { submitCount, errors } = useFormikContext();
+  const prevSubmitCount = useRef7(submitCount);
+  useEffect8(() => {
+    if (submitCount === prevSubmitCount.current) return;
+    prevSubmitCount.current = submitCount;
+    const timer = setTimeout(() => {
+      const errorKeys = Object.keys(errors);
+      if (errorKeys.length === 0) return;
+      const firstErrorKey = errorKeys[0];
+      const el = document.querySelector(`[name="${firstErrorKey}"]`) || document.getElementById(firstErrorKey);
+      if (!el) return;
+      const scrollable = el.closest(".edit-panel__body") || el.closest(".dept-modal__panel-backdrop") || el.closest(".dept-modal__backdrop") || el.closest("[class*='overflow-y-auto']");
+      if (scrollable && scrollable.id !== "scroll") {
+        const elRect = el.getBoundingClientRect();
+        const scrollRect = scrollable.getBoundingClientRect();
+        const offset = elRect.top - scrollRect.top - scrollable.clientHeight / 2 + el.clientHeight / 2;
+        scrollable.scrollBy({ top: offset, behavior: "smooth" });
+      } else {
+        el.scrollIntoView({ behavior: "smooth", block: "center" });
+      }
+      setTimeout(() => el.focus(), 350);
+    }, 100);
+    return () => clearTimeout(timer);
+  }, [submitCount, errors]);
+  return null;
+};
+var scroll_to_field_error_default = ScrollToFieldError;
+
+// src/components/ui/switch.tsx
+import * as React21 from "react";
+import { jsx as jsx21, jsxs as jsxs12 } from "react/jsx-runtime";
+var Switch = React21.forwardRef(
+  ({ className, checked, disabled, onCheckedChange, ...props }, ref) => {
+    const [internalChecked, setInternalChecked] = React21.useState(false);
+    const isControlled = checked !== void 0;
+    const isChecked = isControlled ? checked : internalChecked;
+    const handleChange = (e) => {
+      const newValue = e.target.checked;
+      if (!isControlled) {
+        setInternalChecked(newValue);
+      }
+      onCheckedChange?.(newValue);
+    };
+    return /* @__PURE__ */ jsxs12(
+      "label",
+      {
+        ref,
+        className: cn(
+          "switch-pill",
+          isChecked ? "switch-pill--on" : "switch-pill--off",
+          disabled && "switch-pill--disabled",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx21(
+            "input",
+            {
+              type: "checkbox",
+              className: "switch-pill__input",
+              checked: isChecked,
+              disabled,
+              onChange: handleChange
+            }
+          ),
+          /* @__PURE__ */ jsx21(
+            "span",
+            {
+              className: cn(
+                "switch-pill__thumb",
+                isChecked ? "switch-pill__thumb--on" : "switch-pill__thumb--off"
+              )
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Switch.displayName = "Switch";
+
+// src/components/ui/tab.tsx
+import * as React22 from "react";
+import { cva as cva4 } from "class-variance-authority";
+import { jsx as jsx22, jsxs as jsxs13 } from "react/jsx-runtime";
+var tabVariants = cva4(
+  [
+    "relative inline-flex items-center justify-center gap-2",
+    "whitespace-nowrap select-none",
+    "transition-all duration-200",
+    "outline-none",
+    "cursor-pointer",
+    "font-medium",
+    "focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:ring-interactive-brand",
+    "disabled:pointer-events-none disabled:opacity-50"
+  ].join(" "),
+  {
+    variants: {
+      variant: {
+        default: "text-text-muted hover:text-text-primary",
+        active: "text-text-primary",
+        primary: "text-primary hover:text-primary",
+        secondary: "text-muted-foreground hover:text-foreground"
+      },
+      size: {
+        sm: "min-w-[6.25rem] py-2 px-3 text-sm",
+        md: "min-w-[8.125rem] py-3 px-4 text-sm",
+        lg: "min-w-[10rem] py-4 px-5 text-base"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "md"
+    }
+  }
+);
+var Tab = React22.forwardRef(
+  ({
+    active = false,
+    icon,
+    children,
+    className,
+    variant,
+    size,
+    disabled,
+    onClick
+  }, ref) => {
+    const handleKeyDown = (e) => {
+      if (disabled) return;
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        onClick?.();
+      }
+    };
+    return /* @__PURE__ */ jsxs13(
+      "div",
+      {
+        ref,
+        role: "tab",
+        "aria-selected": active,
+        "aria-disabled": disabled,
+        tabIndex: disabled ? -1 : active ? 0 : -1,
+        onClick: !disabled ? onClick : void 0,
+        onKeyDown: handleKeyDown,
+        className: cn(
+          tabVariants({
+            variant: active ? "active" : variant,
+            size
+          }),
+          className
+        ),
+        children: [
+          icon,
+          /* @__PURE__ */ jsx22("span", { children }),
+          active && /* @__PURE__ */ jsx22("span", { className: "absolute bottom-0 left-0 h-[0.1875rem] w-full rounded-full bg-interactive-brand" })
+        ]
+      }
+    );
+  }
+);
+Tab.displayName = "Tab";
+
+// src/components/ui/table.tsx
+import * as React23 from "react";
+import InfiniteScroll from "react-infinite-scroll-component";
+import { cva as cva5 } from "class-variance-authority";
+import { Fragment as Fragment5, jsx as jsx23, jsxs as jsxs14 } from "react/jsx-runtime";
+var tableVariants = cva5("item-table__head", {
+  variants: {
+    variant: {
+      default: "",
+      flows: "flows-cols",
+      users: "users-cols",
+      departments: "dept-cols",
+      queues: "queue-cols",
+      devices: "devices-cols",
+      reports: "reports-cols",
+      appointments: "appt-cols",
+      doctors: "doctors-cols",
+      roles: "roles-cols",
+      feedbackForms: "feedback-forms-list-cols",
+      feedbackConfig: "feedback-config-cols",
+      alertConfig: "alert-config-list-cols",
+      escalationConfig: "escalation-config-list-cols",
+      kiosks: "kiosk-cols",
+      displayBoards: "displayboard-cols",
+      reportDownloadLinks: "reports-download-links-cols",
+      activeUsers: "active-users-cols",
+      servingTokens: "serving-cols",
+      tokenServing: "token-serving-cols",
+      floatingTokens: "floating-tokens-cols",
+      ordersPending: "orders-pending-cols"
+    },
+    density: {
+      compact: "",
+      comfortable: "item-table__head--comfortable"
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    density: "compact"
+  }
+});
+var Table = React23.forwardRef(
+  ({
+    variant,
+    density,
+    headers,
+    children,
+    className,
+    wrapperClassName,
+    wrapperId,
+    bodyClassName,
+    infiniteScrollProps,
+    stickyHeader,
+    enableHorizontalScroll,
+    contentClassName,
+    headerClassName,
+    headerInsideScroll = false,
+    ...props
+  }, ref) => {
+    const renderHeader = React23.useCallback(() => {
+      return /* @__PURE__ */ jsx23(
+        "div",
+        {
+          className: cn(
+            tableVariants({ variant, density }),
+            density === "comfortable" && enableHorizontalScroll && "item-table__head--scrollable",
+            stickyHeader && "sticky top-0 z-[var(--z-sticky)] bg-background-surface",
+            headerClassName
+          ),
+          children: headers.map((header) => /* @__PURE__ */ jsx23(
+            "div",
+            {
+              className: cn(
+                header.className,
+                header.sticky === "left" && "sticky left-0 z-20 bg-background-surface",
+                header.sticky === "right" && "sticky right-0 z-20 bg-background-surface"
+              ),
+              style: header.style,
+              children: header.title
+            },
+            header.key
+          ))
+        }
+      );
+    }, [
+      headers,
+      variant,
+      density,
+      stickyHeader,
+      headerClassName,
+      enableHorizontalScroll
+    ]);
+    return /* @__PURE__ */ jsx23(
+      "div",
+      {
+        ref,
+        className: cn("item-table", className),
+        ...props,
+        children: !headerInsideScroll ? /* @__PURE__ */ jsxs14(Fragment5, { children: [
+          renderHeader(),
+          /* @__PURE__ */ jsx23(
+            "div",
+            {
+              id: wrapperId,
+              className: cn(
+                "item-table__wrapper",
+                density === "comfortable" && "item-table__wrapper--comfortable",
+                enableHorizontalScroll && "overflow-x-auto",
+                wrapperClassName
+              ),
+              children: /* @__PURE__ */ jsx23(
+                "div",
+                {
+                  className: cn(
+                    "item-table__body",
+                    bodyClassName
+                  ),
+                  children: /* @__PURE__ */ jsx23(
+                    InfiniteScroll,
+                    {
+                      ...infiniteScrollProps,
+                      style: {
+                        overflow: "visible",
+                        display: "contents"
+                      },
+                      children: /* @__PURE__ */ jsx23(
+                        "div",
+                        {
+                          className: cn(
+                            density === "comfortable" && "item-table__content--comfortable px-3",
+                            contentClassName
+                          ),
+                          children
+                        }
+                      )
+                    }
+                  )
+                }
+              )
+            }
+          )
+        ] }) : /* @__PURE__ */ jsx23(
+          "div",
+          {
+            id: wrapperId,
+            className: cn(
+              "item-table__wrapper",
+              density === "comfortable" && "item-table__wrapper--comfortable",
+              enableHorizontalScroll && "overflow-x-auto",
+              wrapperClassName
+            ),
+            children: /* @__PURE__ */ jsx23(
+              InfiniteScroll,
+              {
+                ...infiniteScrollProps,
+                style: {
+                  overflow: "visible",
+                  display: "contents"
+                },
+                children: /* @__PURE__ */ jsxs14(
+                  "div",
+                  {
+                    className: cn(
+                      "item-table__body",
+                      bodyClassName
+                    ),
+                    children: [
+                      renderHeader(),
+                      /* @__PURE__ */ jsx23(
+                        "div",
+                        {
+                          className: cn(
+                            density === "comfortable" && "item-table__content--comfortable px-3",
+                            contentClassName
+                          ),
+                          children
+                        }
+                      )
+                    ]
+                  }
+                )
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+Table.displayName = "Table";
+
+// src/components/ui/textarea.tsx
+import * as React24 from "react";
+import { Field as Field2 } from "formik";
+import { jsx as jsx24 } from "react/jsx-runtime";
+var Textarea = React24.forwardRef(
+  ({
+    className,
+    style,
+    error,
+    as = "textarea",
+    rows = 4,
+    ...props
+  }, ref) => {
+    const classes = cn(
+      // Layout
+      "w-full rounded-lg",
+      "px-3 py-2",
+      "min-h-24 max-h-[12.5rem]",
+      "resize-y overflow-auto",
+      // Typography
+      "!text-[0.8125rem] font-normal text-body",
+      "placeholder:!text-[0.8125rem]",
+      "placeholder:text-neutral-500",
+      // Appearance
+      "bg-background-surface",
+      "border border-neutral-300",
+      "ring-offset-background",
+      // Focus
+      "focus-visible:outline-none",
+      "focus-visible:ring-2",
+      "focus-visible:ring-ring",
+      "focus-visible:ring-offset-2",
+      // Disabled
+      "disabled:cursor-not-allowed",
+      "disabled:opacity-50",
+      // Error
+      error && "border-status-danger focus-visible:ring-status-danger",
+      // Consumer overrides
+      className
+    );
+    if (as === "field") {
+      return /* @__PURE__ */ jsx24(
+        Field2,
+        {
+          as: "textarea",
+          innerRef: ref,
+          rows,
+          className: classes,
+          style,
+          ...props
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx24(
+      "textarea",
+      {
+        ref,
+        rows,
+        className: classes,
+        style,
+        ...props
+      }
+    );
+  }
+);
+Textarea.displayName = "Textarea";
+
+// src/components/ui/time-picker.tsx
+import React25 from "react";
+import dayjs from "dayjs";
+import { jsx as jsx25, jsxs as jsxs15 } from "react/jsx-runtime";
+var HOURS = Array.from({ length: 24 }, (_, i) => i);
+var pad = (n) => String(n).padStart(2, "0");
+var TimePicker = ({
+  value,
+  onChange,
+  placeholder,
+  isClearable = true,
+  minTime,
+  maxTime,
+  disabled,
+  minuteInterval = 1
+}) => {
+  const [open, setOpen] = React25.useState(false);
+  const [openUpward, setOpenUpward] = React25.useState(false);
+  const ref = React25.useRef(null);
+  const popupRef = React25.useRef(null);
+  const hourListRef = React25.useRef(null);
+  const minuteListRef = React25.useRef(null);
+  const minutes = React25.useMemo(
+    () => Array.from({ length: Math.ceil(60 / minuteInterval) }, (_, i) => i * minuteInterval),
+    [minuteInterval]
+  );
+  React25.useEffect(() => {
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) setOpen(false);
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  React25.useLayoutEffect(() => {
+    if (!open || !ref.current) return;
+    const rect = ref.current.getBoundingClientRect();
+    const estimatedPopupHeight = popupRef.current?.offsetHeight ?? 216;
+    const spaceBelow = window.innerHeight - rect.bottom;
+    setOpenUpward(spaceBelow < estimatedPopupHeight + 8 && rect.top > estimatedPopupHeight + 8);
+  }, [open]);
+  React25.useEffect(() => {
+    if (!open) return;
+    hourListRef.current?.querySelector('[data-selected="true"]')?.scrollIntoView({ block: "center" });
+    minuteListRef.current?.querySelector('[data-selected="true"]')?.scrollIntoView({ block: "center" });
+  }, [open]);
+  const isHourDisabled = (h) => !!minTime && h < minTime.getHours() || !!maxTime && h > maxTime.getHours();
+  const isMinuteDisabled = (h, m) => isHourDisabled(h) || !!minTime && h === minTime.getHours() && m < minTime.getMinutes() || !!maxTime && h === maxTime.getHours() && m > maxTime.getMinutes();
+  const clamp = (d) => {
+    if (minTime && d < minTime) return minTime;
+    if (maxTime && d > maxTime) return maxTime;
+    return d;
+  };
+  const selectHour = (h) => {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(h, value ? value.getMinutes() : 0, 0, 0);
+    onChange(clamp(d));
+  };
+  const selectMinute = (m) => {
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(value ? value.getHours() : 0, m, 0, 0);
+    onChange(clamp(d));
+  };
+  const selectedLabel = value ? dayjs(value).format("HH:mm") : null;
+  return /* @__PURE__ */ jsxs15("div", { ref, className: "relative", children: [
+    /* @__PURE__ */ jsxs15(
+      "div",
+      {
+        className: `shared-time-picker__field${disabled ? " pointer-events-none" : ""}`,
+        "data-open": open,
+        "data-disabled": disabled,
+        onClick: () => !disabled && setOpen(!open),
+        onKeyDown: (e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            e.preventDefault();
+            if (!disabled) setOpen(!open);
+          }
+          if (e.key === "Escape") setOpen(false);
+        },
+        role: "button",
+        tabIndex: 0,
+        children: [
+          /* @__PURE__ */ jsx25("span", { className: "shared-time-picker__value", "data-filled": !!selectedLabel, children: selectedLabel ?? placeholder }),
+          /* @__PURE__ */ jsxs15("div", { className: "flex shrink-0 items-center gap-2", children: [
+            isClearable && value && /* @__PURE__ */ jsx25(
+              ButtonIcon,
+              {
+                onClick: (e) => {
+                  e.stopPropagation();
+                  onChange(null);
+                },
+                name: "icon-neo-close",
+                color: "muted",
+                size: "xs"
+              }
+            ),
+            /* @__PURE__ */ jsx25("i", { className: "icon-neo-time-four shared-time-picker__icon" })
+          ] })
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsx25(
+      "div",
+      {
+        ref: popupRef,
+        className: `shared-time-picker__popup${openUpward ? " shared-time-picker__popup--up" : ""}`,
+        children: [
+          { list: HOURS, ref: hourListRef, current: value?.getHours(), disabledFn: isHourDisabled, onPick: selectHour },
+          {
+            list: minutes,
+            ref: minuteListRef,
+            current: value?.getMinutes(),
+            disabledFn: (m) => isMinuteDisabled(value ? value.getHours() : 0, m),
+            onPick: selectMinute
+          }
+        ].map((col, colIdx) => /* @__PURE__ */ jsxs15(React25.Fragment, { children: [
+          colIdx === 1 && /* @__PURE__ */ jsx25("div", { className: "shared-time-picker__sep", children: ":" }),
+          /* @__PURE__ */ jsx25("div", { ref: col.ref, className: "shared-time-picker__col", children: col.list.map((n) => {
+            const isSelected = value != null && col.current === n;
+            const isDisabled = col.disabledFn(n);
+            return /* @__PURE__ */ jsx25(
+              "div",
+              {
+                "data-selected": isSelected ? "true" : "false",
+                "data-disabled": isDisabled ? "true" : "false",
+                className: "shared-time-picker__option",
+                onClick: () => !isDisabled && col.onPick(n),
+                children: pad(n)
+              },
+              n
+            );
+          }) })
+        ] }, colIdx))
+      }
+    )
+  ] });
+};
+var time_picker_default = React25.memo(TimePicker);
+
+// src/components/ui/toast.tsx
+import * as React26 from "react";
+import { jsx as jsx26, jsxs as jsxs16 } from "react/jsx-runtime";
+function Toast({
+  description,
+  type = "success",
+  duration = 3e3,
+  isRTL = false,
+  onClose
+}) {
+  const [isVisible, setIsVisible] = React26.useState(false);
+  React26.useEffect(() => {
+    const enterTimeout = setTimeout(() => setIsVisible(true), 10);
+    const closeTimeout = setTimeout(() => {
+      handleClose();
+    }, duration);
+    return () => {
+      clearTimeout(enterTimeout);
+      clearTimeout(closeTimeout);
+    };
+  }, [duration]);
+  const handleClose = () => {
+    setIsVisible(false);
+    setTimeout(onClose, 300);
+  };
+  return /* @__PURE__ */ jsx26(
+    "div",
+    {
+      className: "fixed top-20 z-[var(--zindex-overlay)] max-w-[24.375rem] w-[calc(100vw-3rem)] sm:w-[24.375rem]",
+      style: isRTL ? { left: "1.5rem" } : { right: "1.5rem" },
+      children: /* @__PURE__ */ jsx26(
+        "div",
+        {
+          className: cn(
+            "pointer-events-auto w-full rounded-xl shadow-lg transition-all duration-300 ease-out",
+            type === "success" && "bg-[var(--color-toast-success-bg)]",
+            type === "error" && "bg-[var(--color-toast-danger-bg)]",
+            type === "info" && "bg-[var(--color-toast-info-bg)]",
+            type === "warning" && "bg-[var(--color-toast-warning-bg)]",
+            isVisible ? "translate-y-0 opacity-100" : "-translate-y-4 opacity-0"
+          ),
+          children: /* @__PURE__ */ jsxs16("div", { className: `flex items-center gap-4 px-5 py-2 text-white`, children: [
+            type === "success" && /* @__PURE__ */ jsx26("i", { className: "icon-neo-check" }),
+            type === "error" && /* @__PURE__ */ jsx26("i", { className: "icon-neo-close_solid" }),
+            type === "warning" && /* @__PURE__ */ jsx26("i", { className: "icon-neo-warning" }),
+            /* @__PURE__ */ jsx26("div", { className: "flex-1 min-w-0", children: description && /* @__PURE__ */ jsx26("div", { className: "text-sm leading-snug", children: description }) }),
+            /* @__PURE__ */ jsx26(
+              ButtonIcon,
+              {
+                onClick: handleClose,
+                name: "icon-neo-close",
+                color: "danger",
+                size: "xs"
+              }
+            )
+          ] })
+        }
+      )
+    }
+  );
+}
+
+// src/components/ui/truncated-text.tsx
+import * as React27 from "react";
+import { jsx as jsx27, jsxs as jsxs17 } from "react/jsx-runtime";
+var CARD_TEXT_LIMIT = 20;
+var TruncatedText = ({ text, maxLength, className, viewMode = "grid" /* GRID */ }) => {
+  maxLength = viewMode === "list" /* LIST */ ? maxLength : CARD_TEXT_LIMIT;
+  if (maxLength === void 0) {
+    return /* @__PURE__ */ jsx27(TruncatedTextByWidth, { text, className });
+  }
+  if (!text || text.length <= maxLength) {
+    return /* @__PURE__ */ jsx27("span", { className: cn("cursor-default", className), children: text || "" });
+  }
+  return /* @__PURE__ */ jsxs17(Tooltip, { children: [
+    /* @__PURE__ */ jsx27(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs17("span", { children: [
+      text.slice(0, maxLength),
+      "\u2026"
+    ] }) }),
+    /* @__PURE__ */ jsx27(
+      TooltipContent,
+      {
+        side: "top",
+        sideOffset: 0,
+        className: "max-w-[21.875rem] max-h-[18.75rem] overflow-y-auto whitespace-normal break-words pointer-events-auto",
+        children: /* @__PURE__ */ jsx27("small", { className: "text-label text-text-muted", children: text })
+      }
+    )
+  ] });
+};
+var TruncatedTextByWidth = ({ text, className }) => {
+  const ref = React27.useRef(null);
+  const [isOverflowing, setIsOverflowing] = React27.useState(false);
+  React27.useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const checkOverflow = () => setIsOverflowing(el.scrollWidth > el.clientWidth);
+    checkOverflow();
+    const observer = new ResizeObserver(checkOverflow);
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [text]);
+  if (!text) {
+    return /* @__PURE__ */ jsx27("span", { className: cn("cursor-default", className), children: "" });
+  }
+  const textSpan = /* @__PURE__ */ jsx27("span", { ref, className: cn("block w-full truncate", className), children: text });
+  return /* @__PURE__ */ jsxs17(Tooltip, { children: [
+    /* @__PURE__ */ jsx27(TooltipTrigger, { className: "min-w-0 w-full", children: textSpan }),
+    isOverflowing && /* @__PURE__ */ jsx27(
+      TooltipContent,
+      {
+        side: "top",
+        sideOffset: 0,
+        className: "max-w-[21.875rem] max-h-[18.75rem] overflow-y-auto whitespace-normal break-words pointer-events-auto",
+        children: /* @__PURE__ */ jsx27("small", { className: "text-label text-text-muted", children: text })
+      }
+    )
+  ] });
+};
+
+// src/components/ui/view-toggle.tsx
+import * as React28 from "react";
+import { jsx as jsx28, jsxs as jsxs18 } from "react/jsx-runtime";
+var VIEW_MODE_KEY = "fp_view_mode";
+var useViewMode = () => {
+  const [viewMode, setViewMode] = React28.useState(() => {
+    const stored = localStorage.getItem(VIEW_MODE_KEY);
+    if (stored === "list" /* LIST */ || stored === "grid" /* GRID */) return stored;
+    return "grid" /* GRID */;
+  });
+  const setAndPersist = React28.useCallback((mode) => {
+    setViewMode(mode);
+    localStorage.setItem(VIEW_MODE_KEY, mode);
+  }, []);
+  return [viewMode, setAndPersist];
+};
+var ViewToggle = ({ viewMode = "grid" /* GRID */, onViewModeChange }) => {
+  return /* @__PURE__ */ jsxs18("div", { className: "view-toggle", children: [
+    /* @__PURE__ */ jsxs18(Tooltip, { children: [
+      /* @__PURE__ */ jsx28(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx28(
+        Button,
+        {
+          type: "button",
+          onClick: () => onViewModeChange("grid" /* GRID */),
+          className: `view-toggle__btn${viewMode === "grid" /* GRID */ ? " view-toggle__btn--active" : ""}`,
+          variant: "ghost",
+          size: "icon",
+          children: /* @__PURE__ */ jsx28("i", { className: "icon-neo-grid" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx28(TooltipContent, { children: "Grid view" })
+    ] }),
+    /* @__PURE__ */ jsxs18(Tooltip, { children: [
+      /* @__PURE__ */ jsx28(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx28(
+        Button,
+        {
+          type: "button",
+          onClick: () => onViewModeChange("list" /* LIST */),
+          className: `view-toggle__btn${viewMode === "list" /* LIST */ ? " view-toggle__btn--active" : ""}`,
+          variant: "ghost",
+          size: "icon",
+          children: /* @__PURE__ */ jsx28("i", { className: "icon-neo-list" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx28(TooltipContent, { children: "List view" })
+    ] })
+  ] });
+};
+ViewToggle.displayName = "ViewToggle";
+export {
+  AppList,
+  AppListBody,
+  AppListCell,
+  AppListHeader,
+  AppListItem,
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Badge,
+  Button,
+  ButtonIcon,
+  CARD_TEXT_LIMIT,
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  Checkbox,
+  CheckboxIndicator,
+  delete_action_default as DeleteAction,
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  DropdownMenu,
+  DropdownMenuCheckboxItem,
+  DropdownMenuContent,
+  DropdownMenuGroup,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuPortal,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger,
+  EViewMode,
+  ExpandableSearch,
+  FileInput,
+  form_field_default as FormField,
+  Icon,
+  Input,
+  loader_default as Loader,
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+  RadioButton,
+  ScrollArea,
+  ScrollBar,
+  scroll_to_field_error_default as ScrollToFieldError,
+  Switch,
+  Tab,
+  Table,
+  Textarea,
+  time_picker_default as TimePicker,
+  Toast,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+  TruncatedText,
+  ViewToggle,
+  actionColorTokens,
+  badgeVariants,
+  buttonVariants,
+  cn,
+  componentTokens_default as componentTokens,
+  designTokens_default as designTokens,
+  getIconColorProps,
+  iconVariants,
+  semanticTokens_default as semanticTokens,
+  tabVariants,
+  tableVariants,
+  useViewMode
+};
+//# sourceMappingURL=index.js.map