impact-nova 0.1.0

package/dist/components/ui/ag-grid-react/process-backend-columndefs.js

@@ -0,0 +1,61 @@
+import { AG_GRID_VALUE_FORMATTERS as i } from "./value-formatters.js";
+const c = (t, e, r) => {
+  if (t == null) return !1;
+  switch (e) {
+    case ">":
+      return Number(t) > Number(r);
+    case "<":
+      return Number(t) < Number(r);
+    case ">=":
+      return Number(t) >= Number(r);
+    case "<=":
+      return Number(t) <= Number(r);
+    case "==":
+      return t == r;
+    case "!=":
+      return t != r;
+    case "contains":
+      return String(t).includes(String(r));
+    case "startsWith":
+      return String(t).startsWith(String(r));
+    case "endsWith":
+      return String(t).endsWith(String(r));
+    default:
+      return !1;
+  }
+}, a = (t) => (e) => {
+  const r = e.value;
+  for (const n of t)
+    if (c(r, n.condition, n.value)) {
+      const o = {
+        color: n.color
+      };
+      return n.fontWeight && (o.fontWeight = n.fontWeight), n.backgroundColor && (o.backgroundColor = n.backgroundColor), o;
+    }
+}, s = (t) => {
+  if ("children" in t && t.children)
+    return {
+      ...t,
+      children: t.children.map((r) => s(r))
+    };
+  const e = { ...t };
+  if (typeof e.valueFormatter == "object" && e.valueFormatter?.type) {
+    const r = e.valueFormatter, n = i[r.type];
+    n ? e.valueFormatter = n : console.warn(`[processColDef] Unknown valueFormatter type: "${r.type}"`);
+  }
+  if (t.colorRules && t.colorRules.length > 0) {
+    const r = a(t.colorRules), n = e.cellStyle;
+    typeof n == "function" ? e.cellStyle = (o) => ({
+      ...n(o),
+      ...r(o) || {}
+    }) : n ? e.cellStyle = (o) => ({
+      ...n,
+      ...r(o) || {}
+    }) : e.cellStyle = r, delete e.colorRules;
+  }
+  return (e.type === "number" || e.type === "numericColumn" || e.type === "currency" || e.type === "percentage") && (e.headerClass = e.headerClass ? `${e.headerClass} ag-right-aligned-header` : "ag-right-aligned-header", e.cellClass = e.cellClass ? `${e.cellClass} ag-right-aligned-cell` : "ag-right-aligned-cell"), e;
+}, g = (t) => !t || t.length === 0 ? t : t.filter((e) => e != null).map((e) => s(e));
+export {
+  g as processBackendColumnDefs,
+  s as processColDef
+};

package/dist/components/ui/ag-grid-react/theme.d.ts

@@ -0,0 +1,2 @@
+import { Theme } from 'ag-grid-community';
+export declare const customAgGridTheme: Theme;

package/dist/components/ui/ag-grid-react/theme.js

@@ -0,0 +1,46 @@
+import { themeQuartz as e, iconSetMaterial as r } from "ag-grid-community";
+/* empty css             */
+const a = e.withPart(r).withParams({
+  accentColor: "#4259EE",
+  advancedFilterBuilderButtonBarBorder: !0,
+  borderColor: "#D9DDE7",
+  browserColorScheme: "light",
+  cellEditingBorder: !0,
+  chartMenuPanelWidth: 260,
+  checkboxCheckedBackgroundColor: "#ECEEFD",
+  checkboxCheckedBorderColor: "#4259EE",
+  checkboxCheckedShapeColor: "#4259EE",
+  columnBorder: !0,
+  columnDropCellBorder: !0,
+  fontFamily: "inherit",
+  footerRowBorder: !0,
+  foregroundColor: "#0D152C",
+  headerBackgroundColor: "#F5F6FA",
+  headerColumnBorder: !0,
+  headerFontFamily: "inherit",
+  headerFontSize: 14,
+  headerHeight: 40,
+  headerFontWeight: 700,
+  headerRowBorder: !0,
+  headerVerticalPaddingScale: 1,
+  headerColumnResizeHandleWidth: 0,
+  inputBorder: !1,
+  inputDisabledBorder: !1,
+  inputFocusBorder: !1,
+  inputFocusShadow: "none",
+  focusShadow: "none",
+  rowBorder: !0,
+  tabBarBorder: !0,
+  wrapperBorder: !0,
+  wrapperBorderRadius: 0,
+  spacing: 9,
+  menuBackgroundColor: "#FFFFFF",
+  menuBorder: !1,
+  menuShadow: "#00000040 0px 0px 2px 0px",
+  menuTextColor: "#1F2B4D",
+  pinnedRowBackgroundColor: "#F4F1F9",
+  pinnedRowBorder: !1
+});
+export {
+  a as customAgGridTheme
+};

package/dist/components/ui/ag-grid-react/value-formatters.d.ts

@@ -0,0 +1,22 @@
+import { ValueFormatterParams } from 'ag-grid-community';
+/**
+ * AG Grid value formatters registry
+ * Use with AgGridWrapper's valueFormatters prop
+ *
+ * @example
+ * ```typescript
+ * <AgGridWrapper
+ *   valueFormatters={AG_GRID_VALUE_FORMATTERS}
+ *   context={{ currency: 'EUR', decimals: 0 }}
+ *   columnDefs={[
+ *     { field: 'price', valueFormatter: 'currency' },
+ *     { field: 'discount', valueFormatter: 'percentage' },
+ *   ]}
+ * />
+ * ```
+ */
+export declare const AG_GRID_VALUE_FORMATTERS: Record<string, (params: ValueFormatterParams) => string>;
+/**
+ * Type-safe formatter names
+ */
+export type AGGridFormatterName = keyof typeof AG_GRID_VALUE_FORMATTERS;

package/dist/components/ui/ag-grid-react/value-formatters.js

@@ -0,0 +1,95 @@
+const a = (e) => e?.nullDisplay ?? "-", F = (e, n) => {
+  let t, o;
+  return n === "bil" ? (t = e / 1e9, o = "B") : n === "mil" ? (t = e / 1e6, o = "M") : (t = e / 1e3, o = "K"), isNaN(t) || !isFinite(t) ? `0.0${o}` : t.toFixed(1) + o;
+}, y = (e, n) => !n || n === "full_no" ? null : F(e, n), N = (e) => {
+  const n = e.colDef, t = typeof n.valueFormatter == "object" ? n.valueFormatter : n;
+  if (e.value == null) return t.nullDisplay ?? "-";
+  const o = t.currency || "USD", l = t.locale || "en-US", r = t.formatType, c = Number(e.value);
+  if (isNaN(c)) return String(e.value);
+  const s = y(Math.abs(c), r);
+  if (s) {
+    const u = c < 0 ? "-" : "", i = new Intl.NumberFormat(l, {
+      style: "currency",
+      currency: o
+    }).formatToParts(0).find((D) => D.type === "currency")?.value || o;
+    return `${u}${i}${s}`;
+  }
+  return new Intl.NumberFormat(l, {
+    style: "currency",
+    currency: o
+  }).format(c);
+}, d = (e) => {
+  const n = e.colDef, t = typeof n.valueFormatter == "object" ? n.valueFormatter : n;
+  if (e.value == null) return t.nullDisplay ?? "-";
+  const o = t.symbol || "$", l = t.position || "prefix", r = t.decimals ?? 2, c = t.locale || "en-US", s = t.formatType, u = Number(e.value);
+  if (isNaN(u)) return String(e.value);
+  const m = y(Math.abs(u), s);
+  let i;
+  return m ? i = `${u < 0 ? "-" : ""}${m}` : i = new Intl.NumberFormat(c, {
+    minimumFractionDigits: r,
+    maximumFractionDigits: r
+  }).format(u), l === "prefix" ? `${o}${i}` : `${i}${o}`;
+}, b = (e) => {
+  if (e.value == null) return a(e.colDef);
+  const n = e.colDef, t = n.decimals ?? 0, o = n.locale || "en-US", l = n.formatType, r = Number(e.value);
+  if (isNaN(r)) return String(e.value);
+  const c = y(Math.abs(r), l);
+  return c ? `${r < 0 ? "-" : ""}${c}` : new Intl.NumberFormat(o, {
+    minimumFractionDigits: t,
+    maximumFractionDigits: t
+  }).format(r);
+}, f = (e) => {
+  if (e.value == null) return a(e.colDef);
+  const n = Number(e.value);
+  if (isNaN(n)) return String(e.value);
+  const t = Math.abs(n), o = n < 0 ? "-" : "";
+  return t >= 1e9 ? `${o}${(t / 1e9).toFixed(1)}B` : t >= 1e6 ? `${o}${(t / 1e6).toFixed(1)}M` : t >= 1e3 ? `${o}${(t / 1e3).toFixed(1)}K` : new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: 2
+  }).format(n);
+}, v = (e) => {
+  if (e.value == null) return a(e.colDef);
+  const n = Number(e.value);
+  if (isNaN(n)) return String(e.value);
+  const t = e.colDef, o = t.decimals ?? 2, l = t.divideBy ?? 100, r = n / l;
+  return new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: o,
+    maximumFractionDigits: o
+  }).format(r);
+}, g = (e) => {
+  if (!e.value) return a(e.colDef);
+  const n = e.colDef, t = n.dateStyle || "medium", o = n.locale || "en-US", l = new Date(e.value);
+  return isNaN(l.getTime()) ? String(e.value) : new Intl.DateTimeFormat(o, {
+    dateStyle: t
+  }).format(l);
+}, S = (e) => {
+  if (!e.value) return a(e.colDef);
+  const n = e.colDef, t = n.dateStyle || "medium", o = n.timeStyle || "short", l = n.locale || "en-US", r = new Date(e.value);
+  return isNaN(r.getTime()) ? String(e.value) : new Intl.DateTimeFormat(l, {
+    dateStyle: t,
+    timeStyle: o
+  }).format(r);
+}, $ = (e) => {
+  if (e.value == null) return a(e.colDef);
+  const n = e.colDef, t = n.trueValue || "Yes", o = n.falseValue || "No";
+  return e.value ? t : o;
+}, x = {
+  // Currency formatters
+  currency: N,
+  currencySymbol: d,
+  // Number formatters
+  number: b,
+  compact: f,
+  compactNumber: f,
+  largeNumber: f,
+  // Percentage formatter
+  percentage: v,
+  // Date formatters
+  date: g,
+  dateTime: S,
+  // Boolean formatter
+  boolean: $
+};
+export {
+  x as AG_GRID_VALUE_FORMATTERS
+};

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/ui/alert-dialog.js

@@ -0,0 +1,114 @@
+import { jsx as l, jsxs as n } from "react/jsx-runtime";
+import * as i from "react";
+import * as t from "@radix-ui/react-alert-dialog";
+import { cn as s } from "../../lib/utils.js";
+import { buttonVariants as r } from "./button-variants.js";
+const w = t.Root, b = t.Trigger, m = t.Portal, d = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ l(
+  t.Overlay,
+  {
+    className: s(
+      "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+      a
+    ),
+    ...e,
+    ref: o
+  }
+));
+d.displayName = t.Overlay.displayName;
+const c = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ n(m, { children: [
+  /* @__PURE__ */ l(d, {}),
+  /* @__PURE__ */ l(
+    t.Content,
+    {
+      ref: o,
+      "aria-describedby": void 0,
+      className: s(
+        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
+        a
+      ),
+      ...e
+    }
+  )
+] }));
+c.displayName = t.Content.displayName;
+const f = ({
+  className: a,
+  ...e
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    className: s(
+      "flex flex-col space-y-2 text-center sm:text-left",
+      a
+    ),
+    ...e
+  }
+);
+f.displayName = "AlertDialogHeader";
+const p = ({
+  className: a,
+  ...e
+}) => /* @__PURE__ */ l(
+  "div",
+  {
+    className: s(
+      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
+      a
+    ),
+    ...e
+  }
+);
+p.displayName = "AlertDialogFooter";
+const g = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ l(
+  t.Title,
+  {
+    ref: o,
+    className: s("text-lg font-semibold", a),
+    ...e
+  }
+));
+g.displayName = t.Title.displayName;
+const N = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ l(
+  t.Description,
+  {
+    ref: o,
+    className: s("text-sm text-muted-foreground", a),
+    ...e
+  }
+));
+N.displayName = t.Description.displayName;
+const y = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ l(
+  t.Action,
+  {
+    ref: o,
+    className: s(r(), a),
+    ...e
+  }
+));
+y.displayName = t.Action.displayName;
+const x = i.forwardRef(({ className: a, ...e }, o) => /* @__PURE__ */ l(
+  t.Cancel,
+  {
+    ref: o,
+    className: s(
+      r({ variant: "outline" }),
+      "mt-2 sm:mt-0",
+      a
+    ),
+    ...e
+  }
+));
+x.displayName = t.Cancel.displayName;
+export {
+  w as AlertDialog,
+  y as AlertDialogAction,
+  x as AlertDialogCancel,
+  c as AlertDialogContent,
+  N as AlertDialogDescription,
+  p as AlertDialogFooter,
+  f as AlertDialogHeader,
+  d as AlertDialogOverlay,
+  m as AlertDialogPortal,
+  g as AlertDialogTitle,
+  b as AlertDialogTrigger
+};

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const alertVariants: (props?: {
+    variant?: "default" | "info" | "warning" | "error" | "success";
+} & import('class-variance-authority/types').ClassProp) => string;
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "default" | "info" | "warning" | "error" | "success";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription, alertVariants };

package/dist/components/ui/alert.js

@@ -0,0 +1,54 @@
+import { jsx as a } from "react/jsx-runtime";
+import * as o from "react";
+import { cva as l } from "class-variance-authority";
+import { cn as s } from "../../lib/utils.js";
+const n = l(
+  "relative w-full rounded-lg border px-4 py-3 text-sm flex gap-3 items-start",
+  {
+    variants: {
+      variant: {
+        default: "bg-background text-foreground",
+        info: "bg-info-bg border-info-border [&>svg]:text-primary",
+        warning: "bg-warning-alert-bg border-warning-alert-border [&>svg]:text-warning",
+        error: "bg-error-alert-bg border-error-alert-border [&>svg]:text-destructive",
+        success: "bg-success-alert-bg border-success-alert-border [&>svg]:text-success"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+), d = o.forwardRef(({ className: r, variant: e, ...t }, i) => /* @__PURE__ */ a(
+  "div",
+  {
+    ref: i,
+    role: "alert",
+    className: s(n({ variant: e }), r),
+    ...t
+  }
+));
+d.displayName = "Alert";
+const g = o.forwardRef(({ className: r, ...e }, t) => /* @__PURE__ */ a(
+  "h5",
+  {
+    ref: t,
+    className: s("font-semibold leading-[21px] tracking-tight text-foreground", r),
+    ...e
+  }
+));
+g.displayName = "AlertTitle";
+const c = o.forwardRef(({ className: r, ...e }, t) => /* @__PURE__ */ a(
+  "div",
+  {
+    ref: t,
+    className: s("text-[12px] leading-[18px] text-secondary-foreground", r),
+    ...e
+  }
+));
+c.displayName = "AlertDescription";
+export {
+  d as Alert,
+  c as AlertDescription,
+  g as AlertTitle,
+  n as alertVariants
+};

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const avatarVariants: (props?: {
+    size?: "sm" | "md" | "lg";
+    shape?: "circle" | "square";
+} & import('class-variance-authority/types').ClassProp) => string;
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & VariantProps<(props?: {
+    size?: "sm" | "md" | "lg";
+    shape?: "circle" | "square";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback, avatarVariants };

package/dist/components/ui/avatar.js

@@ -0,0 +1,60 @@
+import { jsx as r } from "react/jsx-runtime";
+import * as l from "react";
+import * as a from "@radix-ui/react-avatar";
+import { cva as f } from "class-variance-authority";
+import { cn as m } from "../../lib/utils.js";
+const c = f(
+  "relative flex shrink-0 overflow-hidden",
+  {
+    variants: {
+      size: {
+        sm: "h-9 w-9 text-xs",
+        md: "h-12 w-12 text-sm",
+        lg: "h-16 w-16 text-lg"
+      },
+      shape: {
+        circle: "rounded-full",
+        square: "rounded-lg"
+      }
+    },
+    defaultVariants: {
+      size: "md",
+      shape: "square"
+    }
+  }
+), d = l.forwardRef(({ className: e, size: s, shape: t, ...o }, i) => /* @__PURE__ */ r(
+  a.Root,
+  {
+    ref: i,
+    className: m(c({ size: s, shape: t, className: e })),
+    ...o
+  }
+));
+d.displayName = a.Root.displayName;
+const n = l.forwardRef(({ className: e, ...s }, t) => /* @__PURE__ */ r(
+  a.Image,
+  {
+    ref: t,
+    className: m("aspect-square h-full w-full", e),
+    ...s
+  }
+));
+n.displayName = a.Image.displayName;
+const p = l.forwardRef(({ className: e, ...s }, t) => /* @__PURE__ */ r(
+  a.Fallback,
+  {
+    ref: t,
+    className: m(
+      "flex h-full w-full items-center justify-center bg-success text-white font-bold",
+      e
+    ),
+    ...s
+  }
+));
+p.displayName = a.Fallback.displayName;
+export {
+  d as Avatar,
+  p as AvatarFallback,
+  n as AvatarImage,
+  c as avatarVariants
+};

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: {
+    variant?: "solid" | "outline" | "subtle";
+    color?: "primary" | "destructive" | "warning" | "success" | "neutral";
+} & import('class-variance-authority/types').ClassProp) => string;
+export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color">, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, color, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/badge.js

@@ -0,0 +1,54 @@
+import { jsx as s } from "react/jsx-runtime";
+import "react";
+import { cva as n } from "class-variance-authority";
+import { cn as o } from "../../lib/utils.js";
+const i = n(
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-sm leading-[18px] font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        solid: "",
+        outline: "",
+        subtle: ""
+      },
+      color: {
+        primary: "",
+        success: "",
+        warning: "",
+        destructive: "",
+        neutral: ""
+      }
+    },
+    compoundVariants: [
+      // Solid
+      { variant: "solid", color: "primary", className: "border-transparent bg-primary text-white" },
+      { variant: "solid", color: "success", className: "border-transparent bg-success text-white" },
+      { variant: "solid", color: "warning", className: "border-transparent bg-warning text-[#000000de]" },
+      { variant: "solid", color: "destructive", className: "border-transparent bg-destructive text-white" },
+      { variant: "solid", color: "neutral", className: "border-transparent bg-[#5f6673] text-white" },
+      // Outline
+      { variant: "outline", color: "primary", className: "bg-transparent border-primary text-primary" },
+      { variant: "outline", color: "success", className: "bg-transparent border-success text-success" },
+      { variant: "outline", color: "warning", className: "bg-transparent border-warning text-warning" },
+      { variant: "outline", color: "destructive", className: "bg-transparent border-destructive text-destructive" },
+      { variant: "outline", color: "neutral", className: "bg-transparent border-[#5f6673] text-[#5f6673]" },
+      // Subtle
+      { variant: "subtle", color: "primary", className: "border-transparent bg-primary-subtle-bg text-primary-subtle-text" },
+      { variant: "subtle", color: "success", className: "border-transparent bg-success-alert-bg text-success" },
+      { variant: "subtle", color: "warning", className: "border-transparent bg-warning-alert-bg text-warning" },
+      { variant: "subtle", color: "destructive", className: "border-transparent bg-error-alert-bg text-destructive" },
+      { variant: "subtle", color: "neutral", className: "border-transparent bg-[#5f6673]/10 text-[#5f6673]" }
+    ],
+    defaultVariants: {
+      variant: "solid",
+      color: "primary"
+    }
+  }
+);
+function d({ className: r, variant: t, color: a, ...e }) {
+  return /* @__PURE__ */ s("div", { className: o(i({ variant: t, color: a }), r), ...e });
+}
+export {
+  d as Badge,
+  i as badgeVariants
+};

package/dist/components/ui/breadcrumb.d.ts

@@ -0,0 +1,24 @@
+import * as React from "react";
+declare const HomeIcon: ({ className }: {
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, BreadcrumbHeader, HomeIcon, BreadcrumbArrowSeparator, };
+declare const BreadcrumbArrowSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;