@uipath/apollo-wind 0.7.2-pr188.4865fad

package/dist/components/forms/validation-converter.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { ValidationConfig, FieldType } from './form-schema';
+/**
+ * Validation Converter
+ *
+ * Converts JSON-serializable ValidationConfig to Zod schemas at runtime.
+ * This is the bridge between declarative validation config and runtime validation.
+ */
+/**
+ * Convert a ValidationConfig to a Zod schema based on field type
+ *
+ * @param config - The validation configuration (JSON-serializable)
+ * @param fieldType - The field type to determine base schema
+ * @returns A Zod schema for runtime validation
+ *
+ * @example
+ * const schema = validationConfigToZod(
+ *   { required: true, minLength: 2, email: true },
+ *   "email"
+ * );
+ * // Returns: z.string().min(2).email()
+ */
+export declare function validationConfigToZod(config: ValidationConfig | undefined, fieldType: FieldType): z.ZodTypeAny;
+/**
+ * Build a complete Zod object schema from field validations
+ *
+ * @param fields - Array of field metadata with validation configs
+ * @returns A Zod object schema for the entire form
+ */
+export declare function buildZodSchemaFromFields(fields: Array<{
+    name: string;
+    type: FieldType;
+    validation?: ValidationConfig;
+}>): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Merge multiple ValidationConfigs (for rule-based validation changes)
+ *
+ * @param base - Base validation config
+ * @param override - Override validation config from rule effects
+ * @returns Merged validation config
+ */
+export declare function mergeValidationConfigs(base: ValidationConfig | undefined, override: ValidationConfig | undefined): ValidationConfig | undefined;

package/dist/components/forms/validation-converter.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+function validationConfigToZod(config, fieldType) {
+    let schema = getBaseSchemaForType(fieldType);
+    if (!config) return schema.optional();
+    schema = applyStringConstraints(schema, config, fieldType);
+    schema = applyNumberConstraints(schema, config, fieldType);
+    schema = applyArrayConstraints(schema, config, fieldType);
+    if (config.required) {
+        if (isStringType(fieldType) && !config.minLength) schema = schema.min(1, config.messages?.required || 'This field is required');
+        return schema;
+    }
+    return schema.optional();
+}
+function getBaseSchemaForType(fieldType) {
+    switch(fieldType){
+        case 'text':
+        case 'textarea':
+            return z.string();
+        case 'email':
+            return z.string().email();
+        case 'number':
+        case 'slider':
+            return z.coerce.number();
+        case 'checkbox':
+        case 'switch':
+            return z.boolean();
+        case 'select':
+        case 'radio':
+            return z.string();
+        case 'multiselect':
+            return z.array(z.string());
+        case 'date':
+            return z.coerce.date();
+        case 'datetime':
+            return z.coerce.date();
+        case 'file':
+            return z.any();
+        case 'custom':
+            return z.any();
+        default:
+            return z.string();
+    }
+}
+function isStringType(fieldType) {
+    return [
+        'text',
+        'textarea',
+        'email',
+        'select',
+        'radio'
+    ].includes(fieldType);
+}
+function isNumberType(fieldType) {
+    return [
+        'number',
+        'slider'
+    ].includes(fieldType);
+}
+function isArrayType(fieldType) {
+    return [
+        'multiselect'
+    ].includes(fieldType);
+}
+function applyStringConstraints(schema, config, fieldType) {
+    if (!isStringType(fieldType)) return schema;
+    let stringSchema = schema;
+    if (null != config.minLength) stringSchema = stringSchema.min(config.minLength, config.messages?.minLength || `Must be at least ${config.minLength} characters`);
+    if (null != config.maxLength) stringSchema = stringSchema.max(config.maxLength, config.messages?.maxLength || `Must be at most ${config.maxLength} characters`);
+    if (config.pattern) try {
+        const regex = new RegExp(config.pattern);
+        stringSchema = stringSchema.regex(regex, config.messages?.pattern || 'Invalid format');
+    } catch  {
+        console.warn(`Invalid regex pattern: ${config.pattern}`);
+    }
+    if (config.email && 'email' !== fieldType) stringSchema = stringSchema.email(config.messages?.email || 'Invalid email address');
+    if (config.url) stringSchema = stringSchema.url(config.messages?.url || 'Invalid URL');
+    return stringSchema;
+}
+function applyNumberConstraints(schema, config, fieldType) {
+    if (!isNumberType(fieldType)) return schema;
+    let numberSchema = schema;
+    if (config.integer) numberSchema = numberSchema.int(config.messages?.integer || 'Must be a whole number');
+    if (null != config.min) numberSchema = numberSchema.min(config.min, config.messages?.min || `Must be at least ${config.min}`);
+    if (null != config.max) numberSchema = numberSchema.max(config.max, config.messages?.max || `Must be at most ${config.max}`);
+    if (config.positive) numberSchema = numberSchema.positive(config.messages?.positive || 'Must be a positive number');
+    if (config.negative) numberSchema = numberSchema.negative(config.messages?.negative || 'Must be a negative number');
+    return numberSchema;
+}
+function applyArrayConstraints(schema, config, fieldType) {
+    if (!isArrayType(fieldType)) return schema;
+    let arraySchema = schema;
+    if (null != config.minItems) arraySchema = arraySchema.min(config.minItems, config.messages?.minItems || `Select at least ${config.minItems} item(s)`);
+    if (null != config.maxItems) arraySchema = arraySchema.max(config.maxItems, config.messages?.maxItems || `Select at most ${config.maxItems} item(s)`);
+    return arraySchema;
+}
+function buildZodSchemaFromFields(fields) {
+    const shape = {};
+    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type);
+    return z.object(shape);
+}
+function mergeValidationConfigs(base, override) {
+    if (!base && !override) return;
+    if (!base) return override;
+    if (!override) return base;
+    return {
+        ...base,
+        ...override,
+        messages: {
+            ...base.messages,
+            ...override.messages
+        }
+    };
+}
+export { buildZodSchemaFromFields, mergeValidationConfigs, validationConfigToZod };

package/dist/components/ui/accordion.cjs

@@ -0,0 +1,82 @@
+'use client';
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AccordionItem: ()=>AccordionItem,
+    Accordion: ()=>Accordion,
+    AccordionContent: ()=>AccordionContent,
+    AccordionTrigger: ()=>AccordionTrigger
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_accordion_namespaceObject = require("@radix-ui/react-accordion");
+const external_lucide_react_namespaceObject = require("lucide-react");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const Accordion = react_accordion_namespaceObject.Root;
+const AccordionItem = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_accordion_namespaceObject.Item, {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)('border-b', className),
+        ...props
+    }));
+AccordionItem.displayName = 'AccordionItem';
+const AccordionTrigger = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, children, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_accordion_namespaceObject.Header, {
+        className: "flex",
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(react_accordion_namespaceObject.Trigger, {
+            ref: ref,
+            className: (0, index_cjs_namespaceObject.cn)('flex flex-1 cursor-pointer items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180', className),
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.ChevronDown, {
+                    className: "h-4 w-4 shrink-0 transition-transform duration-200"
+                })
+            ]
+        })
+    }));
+AccordionTrigger.displayName = react_accordion_namespaceObject.Trigger.displayName;
+const AccordionContent = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, children, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_accordion_namespaceObject.Content, {
+        ref: ref,
+        className: "overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down data-[state=open]:overflow-visible",
+        ...props,
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+            className: (0, index_cjs_namespaceObject.cn)('pb-4 pt-0', className),
+            children: children
+        })
+    }));
+AccordionContent.displayName = react_accordion_namespaceObject.Content.displayName;
+exports.Accordion = __webpack_exports__.Accordion;
+exports.AccordionContent = __webpack_exports__.AccordionContent;
+exports.AccordionItem = __webpack_exports__.AccordionItem;
+exports.AccordionTrigger = __webpack_exports__.AccordionTrigger;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Accordion",
+    "AccordionContent",
+    "AccordionItem",
+    "AccordionTrigger"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,7 @@
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import * as React from 'react';
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/ui/accordion.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Content, Header, Item, Root, Trigger } from "@radix-ui/react-accordion";
+import { ChevronDown } from "lucide-react";
+import { forwardRef } from "react";
+import { cn } from "../../lib/index.js";
+const Accordion = Root;
+const AccordionItem = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Item, {
+        ref: ref,
+        className: cn('border-b', className),
+        ...props
+    }));
+AccordionItem.displayName = 'AccordionItem';
+const AccordionTrigger = /*#__PURE__*/ forwardRef(({ className, children, ...props }, ref)=>/*#__PURE__*/ jsx(Header, {
+        className: "flex",
+        children: /*#__PURE__*/ jsxs(Trigger, {
+            ref: ref,
+            className: cn('flex flex-1 cursor-pointer items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180', className),
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ jsx(ChevronDown, {
+                    className: "h-4 w-4 shrink-0 transition-transform duration-200"
+                })
+            ]
+        })
+    }));
+AccordionTrigger.displayName = Trigger.displayName;
+const AccordionContent = /*#__PURE__*/ forwardRef(({ className, children, ...props }, ref)=>/*#__PURE__*/ jsx(Content, {
+        ref: ref,
+        className: "overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down data-[state=open]:overflow-visible",
+        ...props,
+        children: /*#__PURE__*/ jsx("div", {
+            className: cn('pb-4 pt-0', className),
+            children: children
+        })
+    }));
+AccordionContent.displayName = Content.displayName;
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger };

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

@@ -0,0 +1,126 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AlertDialogCancel: ()=>AlertDialogCancel,
+    AlertDialogContent: ()=>AlertDialogContent,
+    AlertDialogHeader: ()=>AlertDialogHeader,
+    AlertDialogOverlay: ()=>AlertDialogOverlay,
+    AlertDialogFooter: ()=>AlertDialogFooter,
+    AlertDialogTrigger: ()=>AlertDialogTrigger,
+    AlertDialogDescription: ()=>AlertDialogDescription,
+    AlertDialogTitle: ()=>AlertDialogTitle,
+    AlertDialog: ()=>AlertDialog,
+    AlertDialogPortal: ()=>AlertDialogPortal,
+    AlertDialogAction: ()=>AlertDialogAction
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_button_cjs_namespaceObject = require("./button.cjs");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const react_alert_dialog_namespaceObject = require("@radix-ui/react-alert-dialog");
+const AlertDialog = react_alert_dialog_namespaceObject.Root;
+const AlertDialogTrigger = react_alert_dialog_namespaceObject.Trigger;
+const AlertDialogPortal = react_alert_dialog_namespaceObject.Portal;
+const AlertDialogOverlay = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Overlay, {
+        className: (0, index_cjs_namespaceObject.cn)('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', className),
+        ...props,
+        ref: ref
+    }));
+AlertDialogOverlay.displayName = react_alert_dialog_namespaceObject.Overlay.displayName;
+const AlertDialogContent = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(AlertDialogPortal, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(AlertDialogOverlay, {}),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Content, {
+                ref: ref,
+                className: (0, index_cjs_namespaceObject.cn)('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', className),
+                ...props
+            })
+        ]
+    }));
+AlertDialogContent.displayName = react_alert_dialog_namespaceObject.Content.displayName;
+const AlertDialogHeader = ({ className, ...props })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        className: (0, index_cjs_namespaceObject.cn)('flex flex-col space-y-2 text-center sm:text-left', className),
+        ...props
+    });
+AlertDialogHeader.displayName = 'AlertDialogHeader';
+const AlertDialogFooter = ({ className, ...props })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        className: (0, index_cjs_namespaceObject.cn)('flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2', className),
+        ...props
+    });
+AlertDialogFooter.displayName = 'AlertDialogFooter';
+const AlertDialogTitle = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Title, {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)('text-lg font-semibold', className),
+        ...props
+    }));
+AlertDialogTitle.displayName = react_alert_dialog_namespaceObject.Title.displayName;
+const AlertDialogDescription = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Description, {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)('text-sm text-muted-foreground', className),
+        ...props
+    }));
+AlertDialogDescription.displayName = react_alert_dialog_namespaceObject.Description.displayName;
+const AlertDialogAction = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Action, {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)((0, external_button_cjs_namespaceObject.buttonVariants)(), className),
+        ...props
+    }));
+AlertDialogAction.displayName = react_alert_dialog_namespaceObject.Action.displayName;
+const AlertDialogCancel = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_alert_dialog_namespaceObject.Cancel, {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)((0, external_button_cjs_namespaceObject.buttonVariants)({
+            variant: 'outline'
+        }), 'mt-2 sm:mt-0', className),
+        ...props
+    }));
+AlertDialogCancel.displayName = react_alert_dialog_namespaceObject.Cancel.displayName;
+exports.AlertDialog = __webpack_exports__.AlertDialog;
+exports.AlertDialogAction = __webpack_exports__.AlertDialogAction;
+exports.AlertDialogCancel = __webpack_exports__.AlertDialogCancel;
+exports.AlertDialogContent = __webpack_exports__.AlertDialogContent;
+exports.AlertDialogDescription = __webpack_exports__.AlertDialogDescription;
+exports.AlertDialogFooter = __webpack_exports__.AlertDialogFooter;
+exports.AlertDialogHeader = __webpack_exports__.AlertDialogHeader;
+exports.AlertDialogOverlay = __webpack_exports__.AlertDialogOverlay;
+exports.AlertDialogPortal = __webpack_exports__.AlertDialogPortal;
+exports.AlertDialogTitle = __webpack_exports__.AlertDialogTitle;
+exports.AlertDialogTrigger = __webpack_exports__.AlertDialogTrigger;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "AlertDialog",
+    "AlertDialogAction",
+    "AlertDialogCancel",
+    "AlertDialogContent",
+    "AlertDialogDescription",
+    "AlertDialogFooter",
+    "AlertDialogHeader",
+    "AlertDialogOverlay",
+    "AlertDialogPortal",
+    "AlertDialogTitle",
+    "AlertDialogTrigger"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };

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

@@ -0,0 +1,62 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { buttonVariants } from "./button.js";
+import { cn } from "../../lib/index.js";
+import { Action, Cancel, Content, Description, Overlay, Portal, Root, Title, Trigger } from "@radix-ui/react-alert-dialog";
+const AlertDialog = Root;
+const AlertDialogTrigger = Trigger;
+const AlertDialogPortal = Portal;
+const AlertDialogOverlay = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Overlay, {
+        className: cn('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', className),
+        ...props,
+        ref: ref
+    }));
+AlertDialogOverlay.displayName = Overlay.displayName;
+const AlertDialogContent = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsxs(AlertDialogPortal, {
+        children: [
+            /*#__PURE__*/ jsx(AlertDialogOverlay, {}),
+            /*#__PURE__*/ jsx(Content, {
+                ref: ref,
+                className: cn('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', className),
+                ...props
+            })
+        ]
+    }));
+AlertDialogContent.displayName = Content.displayName;
+const AlertDialogHeader = ({ className, ...props })=>/*#__PURE__*/ jsx("div", {
+        className: cn('flex flex-col space-y-2 text-center sm:text-left', className),
+        ...props
+    });
+AlertDialogHeader.displayName = 'AlertDialogHeader';
+const AlertDialogFooter = ({ className, ...props })=>/*#__PURE__*/ jsx("div", {
+        className: cn('flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2', className),
+        ...props
+    });
+AlertDialogFooter.displayName = 'AlertDialogFooter';
+const AlertDialogTitle = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Title, {
+        ref: ref,
+        className: cn('text-lg font-semibold', className),
+        ...props
+    }));
+AlertDialogTitle.displayName = Title.displayName;
+const AlertDialogDescription = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Description, {
+        ref: ref,
+        className: cn('text-sm text-muted-foreground', className),
+        ...props
+    }));
+AlertDialogDescription.displayName = Description.displayName;
+const AlertDialogAction = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Action, {
+        ref: ref,
+        className: cn(buttonVariants(), className),
+        ...props
+    }));
+AlertDialogAction.displayName = Action.displayName;
+const AlertDialogCancel = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Cancel, {
+        ref: ref,
+        className: cn(buttonVariants({
+            variant: 'outline'
+        }), 'mt-2 sm:mt-0', className),
+        ...props
+    }));
+AlertDialogCancel.displayName = Cancel.displayName;
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger };

package/dist/components/ui/alert.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Alert: ()=>Alert,
+    AlertDescription: ()=>AlertDescription,
+    AlertTitle: ()=>AlertTitle
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_class_variance_authority_namespaceObject = require("class-variance-authority");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const alertVariants = (0, external_class_variance_authority_namespaceObject.cva)('relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground', {
+    variants: {
+        variant: {
+            default: 'bg-background text-foreground',
+            destructive: 'border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive'
+        }
+    },
+    defaultVariants: {
+        variant: 'default'
+    }
+});
+const Alert = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, variant, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: ref,
+        role: "alert",
+        className: (0, index_cjs_namespaceObject.cn)(alertVariants({
+            variant
+        }), className),
+        ...props
+    }));
+Alert.displayName = 'Alert';
+const AlertTitle = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("h5", {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)('mb-1 font-medium leading-none tracking-tight', className),
+        ...props
+    }));
+AlertTitle.displayName = 'AlertTitle';
+const AlertDescription = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+        ref: ref,
+        className: (0, index_cjs_namespaceObject.cn)('text-sm [&_p]:leading-relaxed', className),
+        ...props
+    }));
+AlertDescription.displayName = "AlertDescription";
+exports.Alert = __webpack_exports__.Alert;
+exports.AlertDescription = __webpack_exports__.AlertDescription;
+exports.AlertTitle = __webpack_exports__.AlertTitle;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Alert",
+    "AlertDescription",
+    "AlertTitle"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,8 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => 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 };

package/dist/components/ui/alert.js

@@ -0,0 +1,37 @@
+import { jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { forwardRef } from "react";
+import { cn } from "../../lib/index.js";
+const alertVariants = cva('relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground', {
+    variants: {
+        variant: {
+            default: 'bg-background text-foreground',
+            destructive: 'border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive'
+        }
+    },
+    defaultVariants: {
+        variant: 'default'
+    }
+});
+const Alert = /*#__PURE__*/ forwardRef(({ className, variant, ...props }, ref)=>/*#__PURE__*/ jsx("div", {
+        ref: ref,
+        role: "alert",
+        className: cn(alertVariants({
+            variant
+        }), className),
+        ...props
+    }));
+Alert.displayName = 'Alert';
+const AlertTitle = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("h5", {
+        ref: ref,
+        className: cn('mb-1 font-medium leading-none tracking-tight', className),
+        ...props
+    }));
+AlertTitle.displayName = 'AlertTitle';
+const AlertDescription = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("div", {
+        ref: ref,
+        className: cn('text-sm [&_p]:leading-relaxed', className),
+        ...props
+    }));
+AlertDescription.displayName = "AlertDescription";
+export { Alert, AlertDescription, AlertTitle };