@actioneer/ads 0.1.0

package/components/toast.js

@@ -0,0 +1,211 @@
+"use client";
+import { jsxs as T, jsx as a } from "react/jsx-runtime";
+import * as o from "react";
+import { createPortal as A } from "react-dom";
+import { MotionConfig as O, AnimatePresence as W, motion as F } from "motion/react";
+import { WarningCircle as B, Warning as D, Info as N, CheckCircle as U, Close as V } from "../lib/icons.js";
+import { cn as g } from "../lib/cn.js";
+import { toastSpring as q, EASE_OUT as G } from "../lib/motion.js";
+import { Button as J } from "./button.js";
+import { Spinner as K } from "./spinner.js";
+const z = o.createContext(null);
+function at() {
+  const x = o.useContext(z);
+  if (!x)
+    throw new Error("useToast must be used within a <ToastProvider>.");
+  const { push: c, close: m, clear: f } = x;
+  return { toast: o.useMemo(() => {
+    const s = ((r, i) => {
+      if (r !== null && typeof r == "object" && !o.isValidElement(r)) {
+        const { title: d, ...p } = r;
+        return c(d, { ...p, ...i });
+      }
+      return c(r, i);
+    }), l = (r) => (i, d) => c(i, { ...d, variant: r });
+    return s.success = l("success"), s.info = l("info"), s.warning = l("warning"), s.danger = l("danger"), s.close = m, s.clear = f, s.promise = (r, i) => {
+      const d = c(i.loading, { isLoading: !0, timeout: 0 });
+      return r.then((p) => {
+        m(d), c(
+          typeof i.success == "function" ? i.success(p) : i.success,
+          { variant: "success" }
+        );
+      }).catch((p) => {
+        m(d), c(
+          typeof i.error == "function" ? i.error(p) : i.error,
+          { variant: "danger" }
+        );
+      }), r;
+    }, s;
+  }, [c, m, f]) };
+}
+const Q = {
+  default: { icon: N, accent: "text-foreground" },
+  success: { icon: U, accent: "text-success-700" },
+  info: { icon: N, accent: "text-info-700" },
+  warning: { icon: D, accent: "text-warning-700" },
+  danger: { icon: B, accent: "text-danger-700" }
+}, X = {
+  "bottom-end": "bottom-4 right-4",
+  bottom: "bottom-4 left-1/2 -translate-x-1/2",
+  "bottom-start": "bottom-4 left-4",
+  "top-end": "top-4 right-4",
+  top: "top-4 left-1/2 -translate-x-1/2",
+  "top-start": "top-4 left-4"
+}, S = 12, Y = 0.05;
+function ct({
+  children: x,
+  placement: c = "bottom-end",
+  maxVisible: m = 3
+}) {
+  var k;
+  const [f, b] = o.useState([]), s = o.useRef(/* @__PURE__ */ new Map()), l = o.useRef(/* @__PURE__ */ new Map()), r = o.useCallback((t) => {
+    b((u) => u.filter((h) => h.id !== t));
+    const n = s.current.get(t);
+    n && (clearTimeout(n), s.current.delete(t));
+    const e = l.current.get(t);
+    l.current.delete(t), e == null || e();
+  }, []), i = o.useCallback(() => {
+    b((t) => (t.forEach((n) => {
+      var u;
+      const e = s.current.get(n.id);
+      e && clearTimeout(e), s.current.delete(n.id), (u = l.current.get(n.id)) == null || u(), l.current.delete(n.id);
+    }), []));
+  }, []), d = o.useCallback(
+    (t, n = {}) => {
+      const e = Math.random().toString(36).slice(2), u = { variant: "default", ...n, id: e, title: t };
+      b((v) => [...v, u]), l.current.set(e, n.onClose);
+      const h = n.timeout ?? n.duration ?? (n.isLoading ? 0 : 5e3);
+      return h > 0 && s.current.set(e, setTimeout(() => r(e), h)), e;
+    },
+    [r]
+  );
+  o.useEffect(() => {
+    const t = s.current;
+    return () => {
+      t.forEach((n) => clearTimeout(n)), t.clear();
+    };
+  }, []);
+  const p = o.useMemo(() => ({ push: d, close: r, clear: i }), [d, r, i]), [L, R] = o.useState(!1);
+  o.useEffect(() => R(!0), []);
+  const [y, P] = o.useState(null), E = o.useRef(null), j = (k = f[f.length - 1]) == null ? void 0 : k.id;
+  o.useLayoutEffect(() => {
+    const t = E.current;
+    if (!t) {
+      P(null);
+      return;
+    }
+    const n = () => P(t.offsetHeight);
+    n();
+    const e = new ResizeObserver(n);
+    return e.observe(t), () => e.disconnect();
+  }, [j]);
+  const w = c.startsWith("top"), H = w ? 1 : -1, _ = Math.min(m, Math.max(f.length, 1)), I = y != null ? y + S * (_ - 1) : void 0;
+  return /* @__PURE__ */ T(z.Provider, { value: p, children: [
+    x,
+    L && A(
+      /* @__PURE__ */ a(
+        "div",
+        {
+          className: g(
+            "pointer-events-none fixed z-50 w-full max-w-sm",
+            X[c]
+          ),
+          style: { height: I },
+          role: "region",
+          "aria-label": "Notifications",
+          children: /* @__PURE__ */ a(O, { reducedMotion: "user", children: /* @__PURE__ */ a(W, { children: f.map((t, n) => {
+            const e = f.length - 1 - n, u = e === 0, h = e >= m, v = Q[t.variant ?? "default"], $ = v.icon;
+            return /* @__PURE__ */ T(
+              F.div,
+              {
+                ref: u ? E : void 0,
+                layout: !1,
+                role: "status",
+                "aria-live": "polite",
+                initial: {
+                  opacity: 0,
+                  transform: `translate3d(0, ${w ? -16 : 16}px, 0) scale(0.98)`
+                },
+                animate: {
+                  opacity: h ? 0 : 1,
+                  transform: `translate3d(0, ${H * e * S}px, 0) scale(${1 - e * Y})`
+                },
+                exit: {
+                  opacity: 0,
+                  transform: `translate3d(0, ${w ? -16 : 16}px, 0) scale(0.98)`,
+                  transition: { duration: 0.14, ease: G }
+                },
+                transition: q,
+                className: g(
+                  "group/toast absolute inset-x-0 flex items-start gap-1.5",
+                  w ? "top-0" : "bottom-0",
+                  "rounded-2xl bg-elevated px-4 py-3 shadow-elevation",
+                  u ? "pointer-events-auto" : "pointer-events-none overflow-hidden"
+                ),
+                style: {
+                  zIndex: 100 - e,
+                  // Behind layers freeze at the front card's height so
+                  // only their top edge shows as a clean sliver.
+                  height: !u && y != null ? y : void 0
+                },
+                children: [
+                  /* @__PURE__ */ a(
+                    "span",
+                    {
+                      className: g(
+                        "flex shrink-0 select-none items-center justify-center p-1 [&_svg]:size-4",
+                        v.accent
+                      ),
+                      children: t.isLoading ? /* @__PURE__ */ a(K, { size: "sm", "aria-label": "Loading" }) : t.indicator ?? /* @__PURE__ */ a($, { "aria-hidden": !0 })
+                    }
+                  ),
+                  /* @__PURE__ */ T("div", { className: "flex min-w-0 grow flex-col items-start self-center", children: [
+                    /* @__PURE__ */ a("p", { className: g("text-xs font-medium leading-5", v.accent), children: t.title }),
+                    t.description && /* @__PURE__ */ a("p", { className: "text-xs text-muted-foreground", children: t.description })
+                  ] }),
+                  t.actionProps && /* @__PURE__ */ a(
+                    J,
+                    {
+                      size: "sm",
+                      variant: t.actionProps.variant ?? "soft",
+                      className: g("ml-2 shrink-0 self-center rounded-full", t.actionProps.className),
+                      onClick: () => {
+                        var C, M;
+                        return (M = (C = t.actionProps) == null ? void 0 : C.onClick) == null ? void 0 : M.call(C);
+                      },
+                      children: t.actionProps.children
+                    }
+                  ),
+                  /* @__PURE__ */ a(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => r(t.id),
+                      "aria-label": "Dismiss",
+                      className: g(
+                        "absolute -right-1 -top-1 inline-flex size-5 items-center justify-center",
+                        "rounded-full border border-border bg-elevated text-muted-foreground shadow-elevation",
+                        "opacity-0 transition-opacity duration-(--duration-fast) ease-out",
+                        "group-hover/toast:opacity-100 focus-visible:opacity-100",
+                        "hover:bg-muted hover:text-foreground",
+                        "outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                        "[&_svg]:size-3 [&_svg]:shrink-0"
+                      ),
+                      children: /* @__PURE__ */ a(V, { "aria-hidden": !0 })
+                    }
+                  )
+                ]
+              },
+              t.id
+            );
+          }) }) })
+        }
+      ),
+      document.body
+    )
+  ] });
+}
+export {
+  ct as ToastProvider,
+  at as useToast
+};

package/components/tooltip.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+type TooltipSide = "top" | "bottom" | "left" | "right";
+export interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactElement;
+    side?: TooltipSide;
+    delay?: number;
+    className?: string;
+}
+export declare function Tooltip({ content, children, side, delay, className, }: TooltipProps): React.JSX.Element;
+export {};

package/components/tooltip.js

@@ -0,0 +1,143 @@
+"use client";
+import { jsxs as L, Fragment as D, jsx as b } from "react/jsx-runtime";
+import * as r from "react";
+import { createPortal as F } from "react-dom";
+import { MotionConfig as H, AnimatePresence as I, motion as N } from "motion/react";
+import { cn as k } from "../lib/cn.js";
+import { tooltipVariants as O } from "../lib/motion.js";
+const j = {
+  top: "bottom-0 left-1/2 -translate-x-1/2 translate-y-1/2",
+  bottom: "top-0 left-1/2 -translate-x-1/2 -translate-y-1/2",
+  left: "right-0 top-1/2 translate-x-1/2 -translate-y-1/2",
+  right: "left-0 top-1/2 -translate-x-1/2 -translate-y-1/2"
+}, _ = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+let S = 0;
+const V = 300;
+function U({
+  content: W,
+  children: z,
+  side: d = "top",
+  delay: B = 300,
+  className: P
+}) {
+  const [a, g] = r.useState(!1), [T, x] = r.useState(!1), [i, A] = r.useState(null), v = r.useRef(null), M = r.useRef(null), f = r.useRef(null), y = r.useId(), w = () => {
+    f.current && (clearTimeout(f.current), f.current = null);
+  }, E = () => {
+    if (w(), Date.now() - S < V) {
+      x(!0), g(!0);
+      return;
+    }
+    x(!1), f.current = setTimeout(() => g(!0), B);
+  }, R = () => {
+    w(), a && (S = Date.now()), g(!1);
+  };
+  r.useEffect(() => () => w(), []), r.useLayoutEffect(() => {
+    if (!a) return;
+    const n = v.current, e = M.current;
+    if (!n || !e) return;
+    const t = () => {
+      const o = n.getBoundingClientRect(), p = e.offsetWidth, m = e.offsetHeight, h = 6, s = 8;
+      let c = 0, u = 0;
+      switch (d) {
+        case "top":
+          c = o.top - m - h, u = o.left + o.width / 2 - p / 2;
+          break;
+        case "bottom":
+          c = o.bottom + h, u = o.left + o.width / 2 - p / 2;
+          break;
+        case "left":
+          c = o.top + o.height / 2 - m / 2, u = o.left - p - h;
+          break;
+        case "right":
+          c = o.top + o.height / 2 - m / 2, u = o.right + h;
+          break;
+      }
+      A({
+        top: Math.min(
+          Math.max(c, s),
+          Math.max(s, window.innerHeight - m - s)
+        ),
+        left: Math.min(
+          Math.max(u, s),
+          Math.max(s, window.innerWidth - p - s)
+        )
+      });
+    };
+    return t(), window.addEventListener("resize", t), window.addEventListener("scroll", t, !0), () => {
+      window.removeEventListener("resize", t), window.removeEventListener("scroll", t, !0);
+    };
+  }, [a, d]);
+  const l = z, C = r.cloneElement(l, {
+    ref: v,
+    "aria-describedby": a ? y : void 0,
+    onMouseEnter: (n) => {
+      var e, t;
+      (t = (e = l.props).onMouseEnter) == null || t.call(e, n), E();
+    },
+    onMouseLeave: (n) => {
+      var e, t;
+      (t = (e = l.props).onMouseLeave) == null || t.call(e, n), R();
+    },
+    onFocus: (n) => {
+      var e, t;
+      (t = (e = l.props).onFocus) == null || t.call(e, n), E();
+    },
+    onBlur: (n) => {
+      var e, t;
+      (t = (e = l.props).onBlur) == null || t.call(e, n), R();
+    }
+  });
+  return /* @__PURE__ */ L(D, { children: [
+    C,
+    F(
+      /* @__PURE__ */ b(H, { reducedMotion: "user", children: /* @__PURE__ */ b(I, { children: a && /* @__PURE__ */ L(
+        N.div,
+        {
+          ref: M,
+          role: "tooltip",
+          id: y,
+          variants: O,
+          initial: "hidden",
+          animate: "visible",
+          exit: "hidden",
+          transition: T ? { duration: 0 } : void 0,
+          style: {
+            position: "fixed",
+            top: (i == null ? void 0 : i.top) ?? 0,
+            left: (i == null ? void 0 : i.left) ?? 0,
+            visibility: i ? "visible" : "hidden",
+            transformOrigin: _[d]
+          },
+          className: k(
+            "relative z-50 max-w-xs rounded-md bg-foreground px-2 py-1",
+            "text-xs text-background",
+            "pointer-events-none select-none",
+            P
+          ),
+          children: [
+            /* @__PURE__ */ b(
+              "span",
+              {
+                "aria-hidden": !0,
+                className: k(
+                  "absolute size-2 rotate-45 rounded-[1px] bg-foreground",
+                  j[d]
+                )
+              }
+            ),
+            W
+          ]
+        }
+      ) }) }),
+      document.body
+    )
+  ] });
+}
+export {
+  U as Tooltip
+};

package/components/tree.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+/**
+ * Tree — a nestable disclosure list where children link back to their parent by
+ * an L-shaped connector "branch": a vertical rail drops from the parent and a
+ * curved elbow reaches each child, with the last child's rail stopping at its
+ * elbow. A `TreeItem` with children is a collapsible branch (chevron + optional
+ * count); without children it's a leaf (optionally a link).
+ *
+ * Compose:
+ *   <Tree>
+ *     <TreeItem label="Skills" icon={<BookOpen/>} defaultExpanded>
+ *       <TreeItem label="forecasting" />
+ *       <TreeItem label="cohort-analysis" />
+ *     </TreeItem>
+ *   </Tree>
+ *
+ * The connector is a functional stroke (like Divider), not a surface border —
+ * the one sanctioned place strokes belong (principle 1).
+ */
+export declare const Tree: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export interface TreeItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** Row label. */
+    label: React.ReactNode;
+    /** Leading icon. Leaves default to a file glyph; branches usually pass one. */
+    icon?: React.ReactNode;
+    /** Trailing count shown on a branch. Defaults to the child count. */
+    count?: number;
+    /** Trailing content on the row (e.g. a badge), before the chevron. */
+    endContent?: React.ReactNode;
+    /** Uncontrolled initial expanded state (branches only). */
+    defaultExpanded?: boolean;
+    /** Controlled expanded state. */
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Render a leaf as a link. */
+    href?: string;
+    /** Selected/active leaf. */
+    isActive?: boolean;
+    /** Fires when a leaf row is activated. */
+    onSelect?: () => void;
+}
+export declare const TreeItem: React.ForwardRefExoticComponent<TreeItemProps & React.RefAttributes<HTMLDivElement>>;

package/components/tree.js

@@ -0,0 +1,86 @@
+"use client";
+import { jsx as e, jsxs as b, Fragment as v } from "react/jsx-runtime";
+import * as r from "react";
+import { cn as s } from "../lib/cn.js";
+import { ChevronRight as j, FileText as F } from "../lib/icons.js";
+const _ = r.forwardRef(({ className: l, ...i }, d) => /* @__PURE__ */ e(
+  "div",
+  {
+    ref: d,
+    role: "tree",
+    className: s("text-xs", l),
+    ...i
+  }
+));
+_.displayName = "Tree";
+const z = r.forwardRef(
+  ({
+    className: l,
+    label: i,
+    icon: d,
+    count: h,
+    endContent: N,
+    defaultExpanded: w = !1,
+    expanded: p,
+    onExpandedChange: c,
+    href: x,
+    isActive: f,
+    onSelect: y,
+    children: o,
+    ...C
+  }, I) => {
+    const t = r.Children.count(o) > 0, g = p !== void 0, [k, T] = r.useState(w), n = g ? p : k, R = (a) => {
+      g || T(a), c == null || c(a);
+    }, m = s(
+      "flex h-8 w-full items-center gap-2 rounded-md px-2 text-left",
+      "outline-none transition-colors focus-visible:ring-3 focus-visible:ring-ring",
+      "[&_svg]:size-4 [&_svg]:shrink-0",
+      f ? "bg-fill font-medium text-foreground" : "text-muted-foreground hover:bg-fill/60 hover:text-foreground"
+    ), u = /* @__PURE__ */ b(v, { children: [
+      d ?? (t ? null : /* @__PURE__ */ e(F, { className: "text-tertiary" })),
+      /* @__PURE__ */ e("span", { className: "min-w-0 flex-1 truncate", children: i }),
+      N,
+      t && /* @__PURE__ */ b(v, { children: [
+        (h ?? r.Children.count(o)) > 0 && /* @__PURE__ */ e("span", { className: "shrink-0 tabular-nums text-xs text-tertiary", children: h ?? r.Children.count(o) }),
+        /* @__PURE__ */ e(
+          j,
+          {
+            className: s(
+              "text-muted-foreground transition-transform duration-(--duration-fast) motion-reduce:transition-none",
+              n && "rotate-90"
+            ),
+            strokeWidth: 2
+          }
+        )
+      ] })
+    ] });
+    return /* @__PURE__ */ b("div", { ref: I, role: "treeitem", "aria-expanded": t ? n : void 0, "aria-selected": f, className: l, ...C, children: [
+      t ? /* @__PURE__ */ e("button", { type: "button", className: m, onClick: () => R(!n), children: u }) : x ? /* @__PURE__ */ e("a", { href: x, className: m, "aria-current": f ? "page" : void 0, children: u }) : /* @__PURE__ */ e("button", { type: "button", className: m, onClick: y, children: u }),
+      t && n && // ml-4 aligns the rail under the parent icon; each child carries the
+      // elbow (before) + rail continuation (after), hidden on the last.
+      /* @__PURE__ */ e("div", { role: "group", className: "ml-4", children: r.Children.map(o, (a) => /* @__PURE__ */ e(
+        "div",
+        {
+          className: s(
+            "relative ps-5",
+            // Continuous vertical rail — a straight line (no radius) so it
+            // never breaks between children. The LAST child needs no rail
+            // at all: the elbow's own left border draws its final vertical
+            // segment, so a rail there would poke through the curve.
+            "before:absolute before:left-0 before:top-0 before:bottom-0 before:border-l before:border-border before:content-['']",
+            "last:before:hidden",
+            // Rounded elbow branching off the rail to this child. Its own
+            // left border overlaps the rail, so the curve reads cleanly.
+            "after:absolute after:left-0 after:top-0 after:h-4 after:w-4 after:rounded-bl-[9px] after:border-b after:border-l after:border-border after:content-['']"
+          ),
+          children: a
+        }
+      )) })
+    ] });
+  }
+);
+z.displayName = "TreeItem";
+export {
+  _ as Tree,
+  z as TreeItem
+};

package/components/typography.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+export interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    level?: 1 | 2 | 3 | 4;
+}
+export declare const Heading: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const textSizes: {
+    readonly xs: "text-xs";
+    readonly sm: "text-xs";
+    readonly md: "text-base";
+    readonly lg: "text-lg";
+};
+declare const textWeights: {
+    readonly regular: "font-normal";
+    readonly bold: "font-bold";
+};
+declare const textColors: {
+    readonly primary: "text-primary";
+    readonly secondary: "text-secondary";
+    readonly tertiary: "text-tertiary";
+};
+export interface TextProps extends React.HTMLAttributes<HTMLElement> {
+    size?: keyof typeof textSizes;
+    /** One of the three accessible text levels. Defaults to `primary`. */
+    color?: keyof typeof textColors;
+    /** Shorthand for `color="tertiary"`. */
+    muted?: boolean;
+    weight?: keyof typeof textWeights;
+    /** Render as `p` (default) or `span`. */
+    as?: "p" | "span";
+}
+export declare const Text: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLElement>>;
+export declare const Code: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+export {};

package/components/typography.js

@@ -0,0 +1,65 @@
+"use client";
+import { jsx as c } from "react/jsx-runtime";
+import * as m from "react";
+import { cn as x } from "../lib/cn.js";
+const p = {
+  1: { tag: "h1", className: "text-2xl font-bold tracking-tight" },
+  2: { tag: "h2", className: "text-xl font-bold tracking-tight" },
+  3: { tag: "h3", className: "text-lg font-bold" },
+  4: { tag: "h4", className: "text-base font-bold" }
+}, y = m.forwardRef(
+  ({ className: e, level: a = 1, children: t, ...o }, s) => {
+    const { tag: r, className: l } = p[a];
+    return /* @__PURE__ */ c(r, { ref: s, className: x(l, e), ...o, children: t });
+  }
+);
+y.displayName = "Heading";
+const N = {
+  xs: "text-xs",
+  sm: "text-xs",
+  md: "text-base",
+  lg: "text-lg"
+}, b = {
+  regular: "font-normal",
+  bold: "font-bold"
+}, n = {
+  primary: "text-primary",
+  secondary: "text-secondary",
+  tertiary: "text-tertiary"
+}, u = m.forwardRef(
+  ({ className: e, size: a = "md", color: t, muted: o = !1, weight: s, as: r = "p", children: l, ...d }, i) => {
+    const g = r, f = t ? n[t] : o ? n.tertiary : n.primary;
+    return /* @__PURE__ */ c(
+      g,
+      {
+        ref: i,
+        className: x(
+          N[a],
+          s && b[s],
+          f,
+          e
+        ),
+        ...d,
+        children: l
+      }
+    );
+  }
+);
+u.displayName = "Text";
+const h = m.forwardRef(({ className: e, ...a }, t) => /* @__PURE__ */ c(
+  "code",
+  {
+    ref: t,
+    className: x(
+      "rounded bg-muted px-1.5 py-0.5 tabular-nums text-xs",
+      e
+    ),
+    ...a
+  }
+));
+h.displayName = "Code";
+export {
+  h as Code,
+  y as Heading,
+  u as Text
+};

package/components/ui/avatar.d.ts

@@ -0,0 +1,11 @@
+import { Avatar as AvatarPrimitive } from 'radix-ui';
+import * as React from "react";
+declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root> & {
+    size?: "default" | "sm" | "lg";
+}): React.JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): React.JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): React.JSX.Element;
+declare function AvatarBadge({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function AvatarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback, AvatarBadge, AvatarGroup, AvatarGroupCount, };

package/components/ui/avatar.js

@@ -0,0 +1,56 @@
+"use client";
+import { jsx as e } from "react/jsx-runtime";
+import { Avatar as r } from "radix-ui";
+import { cn as s } from "../../lib/cn.js";
+function n({
+  className: a,
+  size: t = "default",
+  ...l
+}) {
+  return /* @__PURE__ */ e(
+    r.Root,
+    {
+      "data-slot": "avatar",
+      "data-size": t,
+      className: s(
+        "group/avatar relative flex size-8 shrink-0 overflow-hidden rounded-full select-none data-[size=lg]:size-10 data-[size=sm]:size-6",
+        a
+      ),
+      ...l
+    }
+  );
+}
+function d({
+  className: a,
+  ...t
+}) {
+  return /* @__PURE__ */ e(
+    r.Image,
+    {
+      "data-slot": "avatar-image",
+      className: s("aspect-square size-full", a),
+      ...t
+    }
+  );
+}
+function f({
+  className: a,
+  ...t
+}) {
+  return /* @__PURE__ */ e(
+    r.Fallback,
+    {
+      "data-slot": "avatar-fallback",
+      className: s(
+        "flex size-full items-center justify-center rounded-full bg-muted text-xs text-muted-foreground group-data-[size=sm]/avatar:text-xs",
+        a
+      ),
+      ...t
+    }
+  );
+}
+export {
+  n as Avatar,
+  f as AvatarFallback,
+  d as AvatarImage
+};

package/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
+    size?: "default" | "sm" | "lg" | "xs" | "icon" | "icon-sm" | "icon-xs" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Button, buttonVariants };