@a2v2ai/uikit 0.0.3 → 0.0.5

package/Alert/Alert.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+type AlertVariant = "default" | "destructive" | "success" | "warning" | "info";
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "info" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: AlertVariant;
+}
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & 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 };
+export type { AlertVariant };

package/Alert/Alert.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alertVariants = exports.AlertDescription = exports.AlertTitle = exports.Alert = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const class_variance_authority_1 = require("class-variance-authority");
+const utils_1 = require("../lib/utils");
+const alertVariants = (0, class_variance_authority_1.cva)("relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-current [&>svg~*]:pl-7", {
+    variants: {
+        variant: {
+            default: "bg-white text-main-950 border-grey-200",
+            destructive: "border-error-200 bg-error-50 text-error-700 [&>svg]:text-error-600",
+            success: "border-success-200 bg-success-50 text-success-700 [&>svg]:text-success-600",
+            warning: "border-warning-200 bg-warning-50 text-warning-700 [&>svg]:text-warning-600",
+            info: "border-info-200 bg-info-50 text-info-700 [&>svg]:text-info-600",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+    },
+});
+exports.alertVariants = alertVariants;
+const Alert = React.forwardRef(({ className, variant, ...props }, ref) => ((0, jsx_runtime_1.jsx)("div", { ref: ref, role: "alert", className: (0, utils_1.cn)(alertVariants({ variant }), className), ...props })));
+exports.Alert = Alert;
+Alert.displayName = "Alert";
+const AlertTitle = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("h5", { ref: ref, className: (0, utils_1.cn)("mb-1 font-medium leading-none tracking-tight", className), ...props })));
+exports.AlertTitle = AlertTitle;
+AlertTitle.displayName = "AlertTitle";
+const AlertDescription = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("div", { ref: ref, className: (0, utils_1.cn)("text-sm [&_p]:leading-relaxed", className), ...props })));
+exports.AlertDescription = AlertDescription;
+AlertDescription.displayName = "AlertDescription";

package/AlertDialog/AlertDialog.d.ts

@@ -0,0 +1,43 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+type AlertDialogContentType = "desktop" | "mobile";
+type AlertDialogHeaderType = "header" | "close-only" | "icon-button-close";
+type AlertDialogFooterType = "buttons-right" | "full-width" | "single-full-width";
+type AlertDialogCloseButtonVariant = "default" | "icon-button";
+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 alertDialogContentVariants: (props?: ({
+    type?: "desktop" | "mobile" | null | undefined;
+    scrollable?: boolean | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface AlertDialogContentProps extends React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content> {
+    type?: AlertDialogContentType;
+    scrollable?: boolean;
+    showCloseButton?: boolean;
+    closeButtonVariant?: AlertDialogCloseButtonVariant;
+    loading?: boolean;
+}
+declare const AlertDialogContent: React.ForwardRefExoticComponent<AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const alertDialogHeaderVariants: (props?: ({
+    type?: "header" | "close-only" | "icon-button-close" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface AlertDialogHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    type?: AlertDialogHeaderType;
+}
+declare const AlertDialogHeader: React.ForwardRefExoticComponent<AlertDialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+declare const alertDialogFooterVariants: (props?: ({
+    type?: "buttons-right" | "full-width" | "single-full-width" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface AlertDialogFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    type?: AlertDialogFooterType;
+}
+declare const AlertDialogFooter: React.ForwardRefExoticComponent<AlertDialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+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 AlertDialogBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogBody, AlertDialogAction, AlertDialogCancel, alertDialogContentVariants, alertDialogHeaderVariants, alertDialogFooterVariants, };
+export type { AlertDialogContentType, AlertDialogHeaderType, AlertDialogFooterType, AlertDialogCloseButtonVariant };

package/AlertDialog/AlertDialog.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alertDialogFooterVariants = exports.alertDialogHeaderVariants = exports.alertDialogContentVariants = exports.AlertDialogCancel = exports.AlertDialogAction = exports.AlertDialogBody = exports.AlertDialogDescription = exports.AlertDialogTitle = exports.AlertDialogFooter = exports.AlertDialogHeader = exports.AlertDialogContent = exports.AlertDialogTrigger = exports.AlertDialogOverlay = exports.AlertDialogPortal = exports.AlertDialog = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const AlertDialogPrimitive = __importStar(require("@radix-ui/react-alert-dialog"));
+const lucide_react_1 = require("lucide-react");
+const class_variance_authority_1 = require("class-variance-authority");
+const Button_1 = require("../Button/Button");
+const utils_1 = require("../lib/utils");
+const AlertDialog = AlertDialogPrimitive.Root;
+exports.AlertDialog = AlertDialog;
+const AlertDialogTrigger = AlertDialogPrimitive.Trigger;
+exports.AlertDialogTrigger = AlertDialogTrigger;
+const AlertDialogPortal = AlertDialogPrimitive.Portal;
+exports.AlertDialogPortal = AlertDialogPortal;
+const AlertDialogOverlay = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AlertDialogPrimitive.Overlay, { ref: ref, className: (0, utils_1.cn)("fixed inset-0 z-50 bg-black/50 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className), ...props })));
+exports.AlertDialogOverlay = AlertDialogOverlay;
+AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName;
+const alertDialogContentVariants = (0, class_variance_authority_1.cva)("fixed z-50 grid gap-4 bg-white border border-grey-200 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", {
+    variants: {
+        type: {
+            desktop: "left-[50%] top-[50%] translate-x-[-50%] translate-y-[-50%] w-full max-w-[640px] rounded-lg",
+            mobile: "left-[50%] top-[50%] translate-x-[-50%] translate-y-[-50%] w-full max-w-[320px] rounded-lg",
+        },
+        scrollable: {
+            true: "max-h-[80vh] overflow-y-auto",
+            false: "",
+        },
+    },
+    defaultVariants: {
+        type: "desktop",
+        scrollable: false,
+    },
+});
+exports.alertDialogContentVariants = alertDialogContentVariants;
+const AlertDialogContent = React.forwardRef(({ className, children, type, scrollable, showCloseButton = true, closeButtonVariant = "default", loading = false, ...props }, ref) => ((0, jsx_runtime_1.jsxs)(AlertDialogPortal, { children: [(0, jsx_runtime_1.jsx)(AlertDialogOverlay, {}), (0, jsx_runtime_1.jsxs)(AlertDialogPrimitive.Content, { ref: ref, className: (0, utils_1.cn)(alertDialogContentVariants({ type, scrollable, className })), ...props, children: [loading && ((0, jsx_runtime_1.jsx)("div", { className: "absolute inset-0 z-10 flex items-center justify-center bg-white/80 rounded-lg", children: (0, jsx_runtime_1.jsx)(lucide_react_1.Loader2, { className: "size-8 text-main-600 animate-spin" }) })), children, showCloseButton && closeButtonVariant === "default" && !loading && ((0, jsx_runtime_1.jsxs)(AlertDialogPrimitive.Cancel, { className: "absolute right-4 top-4 rounded-sm opacity-70 transition-opacity hover:opacity-100 focus:outline-none focus:shadow-[0_0_0_3px_#d4d4d4] disabled:pointer-events-none cursor-pointer", children: [(0, jsx_runtime_1.jsx)(lucide_react_1.X, { className: "size-4 text-grey-600" }), (0, jsx_runtime_1.jsx)("span", { className: "sr-only", children: "Close" })] })), showCloseButton && closeButtonVariant === "icon-button" && !loading && ((0, jsx_runtime_1.jsx)(AlertDialogPrimitive.Cancel, { asChild: true, children: (0, jsx_runtime_1.jsxs)(Button_1.Button, { variant: "ghost", size: "small", className: "absolute right-2 top-2 size-9 p-0", children: [(0, jsx_runtime_1.jsx)(lucide_react_1.X, { className: "size-4" }), (0, jsx_runtime_1.jsx)("span", { className: "sr-only", children: "Close" })] }) }))] })] })));
+exports.AlertDialogContent = AlertDialogContent;
+AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName;
+const alertDialogHeaderVariants = (0, class_variance_authority_1.cva)("flex p-4", {
+    variants: {
+        type: {
+            header: "flex-row items-center justify-between",
+            "close-only": "flex-col items-end",
+            "icon-button-close": "flex-col items-end justify-center pr-0",
+        },
+    },
+    defaultVariants: {
+        type: "header",
+    },
+});
+exports.alertDialogHeaderVariants = alertDialogHeaderVariants;
+const AlertDialogHeader = React.forwardRef(({ className, type, ...props }, ref) => ((0, jsx_runtime_1.jsx)("div", { ref: ref, className: (0, utils_1.cn)(alertDialogHeaderVariants({ type, className })), ...props })));
+exports.AlertDialogHeader = AlertDialogHeader;
+AlertDialogHeader.displayName = "AlertDialogHeader";
+const alertDialogFooterVariants = (0, class_variance_authority_1.cva)("flex gap-2 p-4", {
+    variants: {
+        type: {
+            "buttons-right": "flex-row items-center justify-end",
+            "full-width": "flex-row items-start",
+            "single-full-width": "flex-row items-start",
+        },
+    },
+    defaultVariants: {
+        type: "buttons-right",
+    },
+});
+exports.alertDialogFooterVariants = alertDialogFooterVariants;
+const AlertDialogFooter = React.forwardRef(({ className, type, children, ...props }, ref) => ((0, jsx_runtime_1.jsx)("div", { ref: ref, className: (0, utils_1.cn)(alertDialogFooterVariants({ type, className })), ...props, children: type === "full-width" || type === "single-full-width" ? ((0, jsx_runtime_1.jsx)("div", { className: "flex gap-2 w-full", children: React.Children.map(children, (child) => React.isValidElement(child)
+            ? React.cloneElement(child, {
+                className: (0, utils_1.cn)("flex-1", child.props.className),
+            })
+            : child) })) : (children) })));
+exports.AlertDialogFooter = AlertDialogFooter;
+AlertDialogFooter.displayName = "AlertDialogFooter";
+const AlertDialogTitle = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AlertDialogPrimitive.Title, { ref: ref, className: (0, utils_1.cn)("text-2xl font-bold leading-[1.2] tracking-tight text-main-950 font-display", className), ...props })));
+exports.AlertDialogTitle = AlertDialogTitle;
+AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName;
+const AlertDialogDescription = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AlertDialogPrimitive.Description, { ref: ref, className: (0, utils_1.cn)("text-sm text-grey-600", className), ...props })));
+exports.AlertDialogDescription = AlertDialogDescription;
+AlertDialogDescription.displayName = AlertDialogPrimitive.Description.displayName;
+const AlertDialogBody = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("div", { ref: ref, className: (0, utils_1.cn)("flex-1 px-4 py-2", className), ...props })));
+exports.AlertDialogBody = AlertDialogBody;
+AlertDialogBody.displayName = "AlertDialogBody";
+const AlertDialogAction = AlertDialogPrimitive.Action;
+exports.AlertDialogAction = AlertDialogAction;
+const AlertDialogCancel = AlertDialogPrimitive.Cancel;
+exports.AlertDialogCancel = AlertDialogCancel;

package/Avatar/Avatar.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+type AvatarSize = "small" | "regular" | "large" | "xlarge";
+declare const avatarVariants: (props?: ({
+    size?: "small" | "regular" | "large" | "xlarge" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root> {
+    size?: AvatarSize;
+}
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & 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 };
+export type { AvatarSize };

package/Avatar/Avatar.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.avatarVariants = exports.AvatarFallback = exports.AvatarImage = exports.Avatar = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const AvatarPrimitive = __importStar(require("@radix-ui/react-avatar"));
+const class_variance_authority_1 = require("class-variance-authority");
+const utils_1 = require("../lib/utils");
+const avatarVariants = (0, class_variance_authority_1.cva)("relative flex shrink-0 overflow-hidden rounded-full", {
+    variants: {
+        size: {
+            small: "size-8",
+            regular: "size-10",
+            large: "size-12",
+            xlarge: "size-16",
+        },
+    },
+    defaultVariants: {
+        size: "regular",
+    },
+});
+exports.avatarVariants = avatarVariants;
+const Avatar = React.forwardRef(({ className, size, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AvatarPrimitive.Root, { ref: ref, className: (0, utils_1.cn)(avatarVariants({ size }), className), ...props })));
+exports.Avatar = Avatar;
+Avatar.displayName = AvatarPrimitive.Root.displayName;
+const AvatarImage = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AvatarPrimitive.Image, { ref: ref, className: (0, utils_1.cn)("aspect-square h-full w-full", className), ...props })));
+exports.AvatarImage = AvatarImage;
+AvatarImage.displayName = AvatarPrimitive.Image.displayName;
+const AvatarFallback = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)(AvatarPrimitive.Fallback, { ref: ref, className: (0, utils_1.cn)("flex h-full w-full items-center justify-center rounded-full bg-grey-100 text-grey-600 font-medium", className), ...props })));
+exports.AvatarFallback = AvatarFallback;
+AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName;

package/Badge/Badge.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+type BadgeVariant = "default" | "secondary" | "outline" | "destructive" | "success" | "warning";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "secondary" | "outline" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: BadgeVariant;
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };
+export type { BadgeVariant };

package/Badge/Badge.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.badgeVariants = void 0;
+exports.Badge = Badge;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const class_variance_authority_1 = require("class-variance-authority");
+const utils_1 = require("../lib/utils");
+const badgeVariants = (0, class_variance_authority_1.cva)("inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-main-950 focus:ring-offset-2", {
+    variants: {
+        variant: {
+            default: "border-transparent bg-main-950 text-main-50",
+            secondary: "border-transparent bg-grey-100 text-main-950",
+            outline: "border-grey-300 text-main-950",
+            destructive: "border-transparent bg-error-600 text-white",
+            success: "border-transparent bg-success-600 text-white",
+            warning: "border-transparent bg-warning-500 text-white",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+    },
+});
+exports.badgeVariants = badgeVariants;
+function Badge({ className, variant, ...props }) {
+    return ((0, jsx_runtime_1.jsx)("div", { className: (0, utils_1.cn)(badgeVariants({ variant }), className), ...props }));
+}

package/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+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;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/Breadcrumb/Breadcrumb.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreadcrumbEllipsis = exports.BreadcrumbSeparator = exports.BreadcrumbPage = exports.BreadcrumbLink = exports.BreadcrumbItem = exports.BreadcrumbList = exports.Breadcrumb = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const react_slot_1 = require("@radix-ui/react-slot");
+const lucide_react_1 = require("lucide-react");
+const utils_1 = require("../lib/utils");
+const Breadcrumb = React.forwardRef(({ ...props }, ref) => (0, jsx_runtime_1.jsx)("nav", { ref: ref, "aria-label": "breadcrumb", ...props }));
+exports.Breadcrumb = Breadcrumb;
+Breadcrumb.displayName = "Breadcrumb";
+const BreadcrumbList = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("ol", { ref: ref, className: (0, utils_1.cn)("flex flex-wrap items-center gap-1.5 break-words text-sm text-grey-500 sm:gap-2.5", className), ...props })));
+exports.BreadcrumbList = BreadcrumbList;
+BreadcrumbList.displayName = "BreadcrumbList";
+const BreadcrumbItem = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("li", { ref: ref, className: (0, utils_1.cn)("inline-flex items-center gap-1.5", className), ...props })));
+exports.BreadcrumbItem = BreadcrumbItem;
+BreadcrumbItem.displayName = "BreadcrumbItem";
+const BreadcrumbLink = React.forwardRef(({ asChild, className, ...props }, ref) => {
+    const Comp = asChild ? react_slot_1.Slot : "a";
+    return ((0, jsx_runtime_1.jsx)(Comp, { ref: ref, className: (0, utils_1.cn)("transition-colors hover:text-main-950", className), ...props }));
+});
+exports.BreadcrumbLink = BreadcrumbLink;
+BreadcrumbLink.displayName = "BreadcrumbLink";
+const BreadcrumbPage = React.forwardRef(({ className, ...props }, ref) => ((0, jsx_runtime_1.jsx)("span", { ref: ref, role: "link", "aria-disabled": "true", "aria-current": "page", className: (0, utils_1.cn)("font-normal text-main-950", className), ...props })));
+exports.BreadcrumbPage = BreadcrumbPage;
+BreadcrumbPage.displayName = "BreadcrumbPage";
+const BreadcrumbSeparator = ({ children, className, ...props }) => ((0, jsx_runtime_1.jsx)("li", { role: "presentation", "aria-hidden": "true", className: (0, utils_1.cn)("[&>svg]:size-3.5", className), ...props, children: children ?? (0, jsx_runtime_1.jsx)(lucide_react_1.ChevronRight, {}) }));
+exports.BreadcrumbSeparator = BreadcrumbSeparator;
+BreadcrumbSeparator.displayName = "BreadcrumbSeparator";
+const BreadcrumbEllipsis = ({ className, ...props }) => ((0, jsx_runtime_1.jsxs)("span", { role: "presentation", "aria-hidden": "true", className: (0, utils_1.cn)("flex h-9 w-9 items-center justify-center", className), ...props, children: [(0, jsx_runtime_1.jsx)(lucide_react_1.MoreHorizontal, { className: "size-4" }), (0, jsx_runtime_1.jsx)("span", { className: "sr-only", children: "More" })] }));
+exports.BreadcrumbEllipsis = BreadcrumbEllipsis;
+BreadcrumbEllipsis.displayName = "BreadcrumbEllipsis";

package/Button/Button.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+type ButtonVariant = "primary" | "secondary" | "outline" | "ghost" | "ghost-muted" | "destructive";
+type ButtonSize = "mini" | "small" | "regular" | "large";
+type ButtonRoundness = "default" | "round";
+declare const buttonVariants: (props?: ({
+    variant?: "destructive" | "secondary" | "outline" | "primary" | "ghost" | "ghost-muted" | null | undefined;
+    size?: "small" | "regular" | "large" | "mini" | null | undefined;
+    roundness?: "default" | "round" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    roundness?: ButtonRoundness;
+    asChild?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };
+export type { ButtonVariant, ButtonSize, ButtonRoundness };

package/Button/Button.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buttonVariants = exports.Button = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const React = __importStar(require("react"));
+const react_slot_1 = require("@radix-ui/react-slot");
+const class_variance_authority_1 = require("class-variance-authority");
+const utils_1 = require("../lib/utils");
+const buttonVariants = (0, class_variance_authority_1.cva)("inline-flex items-center justify-center gap-2 whitespace-nowrap font-normal font-sans cursor-pointer transition-colors focus-visible:outline-none focus-visible:shadow-[0_0_0_3px_#d4d4d4] disabled:pointer-events-none disabled:opacity-50 disabled:cursor-not-allowed [&_svg]:pointer-events-none [&_svg]:shrink-0", {
+    variants: {
+        variant: {
+            primary: "bg-main-950 text-main-50 hover:bg-main-800",
+            secondary: "bg-main-100 text-main-950 hover:bg-main-200",
+            outline: "border border-main-300 bg-transparent text-main-950 hover:bg-main-100",
+            ghost: "bg-transparent text-main-600 hover:bg-main-100 hover:text-main-950",
+            "ghost-muted": "bg-transparent text-main-400 hover:bg-main-100 hover:text-main-600",
+            destructive: "bg-error-600 text-white hover:bg-error-700",
+        },
+        size: {
+            mini: "h-6 px-3 text-xs rounded-md [&_svg]:size-3",
+            small: "h-8 px-3 text-sm rounded-md [&_svg]:size-3.5",
+            regular: "h-9 px-4 text-sm rounded-lg [&_svg]:size-4",
+            large: "h-10 px-4 text-base rounded-lg [&_svg]:size-5",
+        },
+        roundness: {
+            default: "",
+            round: "!rounded-full",
+        },
+    },
+    defaultVariants: {
+        variant: "primary",
+        size: "regular",
+        roundness: "default",
+    },
+});
+exports.buttonVariants = buttonVariants;
+const Button = React.forwardRef(({ className, variant, size, roundness, asChild = false, leftIcon, rightIcon, children, ...props }, ref) => {
+    const Comp = asChild ? react_slot_1.Slot : "button";
+    return ((0, jsx_runtime_1.jsxs)(Comp, { className: (0, utils_1.cn)(buttonVariants({ variant, size, roundness, className })), ref: ref, ...props, children: [leftIcon && (0, jsx_runtime_1.jsx)("span", { className: "shrink-0", children: leftIcon }), children, rightIcon && (0, jsx_runtime_1.jsx)("span", { className: "shrink-0", children: rightIcon })] }));
+});
+exports.Button = Button;
+Button.displayName = "Button";

package/Calendar/Calendar.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { DayButton, DayPicker } from "react-day-picker";
+import { Button } from "../Button/Button";
+export type CalendarProps = React.ComponentProps<typeof DayPicker> & {
+    /**
+     * Variant for navigation buttons
+     * @default "ghost"
+     */
+    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+};
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+export { Calendar, CalendarDayButton };