@moontra/moonui-pro 2.20.1 → 2.20.3

package/src/components/ui/command.tsx

@@ -1,225 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { Search } from "lucide-react"
-import { Command as CommandPrimitive } from "cmdk"
-import { cva, type VariantProps } from "class-variance-authority"
-
-import { cn } from "../../lib/utils"
-import { Dialog, DialogContent, DialogTitle } from "./dialog"
-
-/**
- * Command (Komut Paleti) Bileşeni
- * 
- * Gerçek command palette işlevselliği ile klavye navigasyonu, arama ve filtreleme.
- * cmdk kütüphanesi üzerine inşa edilmiş, tam özellikli command interface.
- */
-
-const MoonUIcommandVariantsPro = cva(
-  "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
-  {
-    variants: {
-      variant: {
-        default: "bg-popover text-popover-foreground",
-        glass: "bg-background/80 text-foreground backdrop-blur-sm",
-        bordered: "bg-popover text-popover-foreground border border-border",
-      },
-      size: {
-        sm: "min-h-[200px]",
-        default: "min-h-[300px]",
-        lg: "min-h-[400px]",
-      },
-    },
-    defaultVariants: {
-      variant: "default",
-      size: "default",
-    },
-  }
-)
-
-// Command bileşeni - cmdk primitive wrapper
-interface CommandProps 
-  extends React.ComponentProps<typeof CommandPrimitive>,
-    VariantProps<typeof MoonUIcommandVariantsPro> {}
-
-const MoonUICommandPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive>,
-  CommandProps
->(({ className, variant, size, ...props }, ref) => (
-  <CommandPrimitive
-    ref={ref}
-    className={cn(MoonUIcommandVariantsPro({ variant, size }), className)}
-    {...props}
-  />
-))
-MoonUICommandPro.displayName = CommandPrimitive.displayName
-
-// CommandDialog bileşeni
-interface CommandDialogProps extends React.ComponentProps<typeof Dialog> {
-  commandClassName?: string
-  children?: React.ReactNode
-}
-
-const MoonUICommandDialogPro = ({ 
-  children, 
-  commandClassName,
-  ...props 
-}: CommandDialogProps) => {
-  return (
-    <Dialog {...props}>
-      <DialogContent className="overflow-hidden p-0 shadow-lg" hideCloseButton>
-        <DialogTitle className="sr-only">Command Menu</DialogTitle>
-        <MoonUICommandPro className={cn(
-          "[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5",
-          commandClassName
-        )}>
-          {children}
-        </MoonUICommandPro>
-      </DialogContent>
-    </Dialog>
-  )
-}
-
-// CommandInput bileşeni
-interface CommandInputProps 
-  extends React.ComponentProps<typeof CommandPrimitive.Input> {}
-
-const MoonUICommandInputPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.Input>,
-  CommandInputProps
->(({ className, ...props }, ref) => (
-  <div className="flex items-center border-b px-3" cmdk-input-wrapper="">
-    <Search className="mr-2 h-4 w-4 shrink-0 opacity-50" />
-    <CommandPrimitive.Input
-      ref={ref}
-      className={cn(
-        "flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
-        className
-      )}
-      {...props}
-    />
-  </div>
-))
-MoonUICommandInputPro.displayName = CommandPrimitive.Input.displayName
-
-// CommandList bileşeni
-interface CommandListProps 
-  extends React.ComponentProps<typeof CommandPrimitive.List> {}
-
-const MoonUICommandListPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.List>,
-  CommandListProps
->(({ className, ...props }, ref) => (
-  <CommandPrimitive.List
-    ref={ref}
-    className={cn("max-h-[300px] overflow-y-auto overflow-x-hidden", className)}
-    {...props}
-  />
-))
-MoonUICommandListPro.displayName = CommandPrimitive.List.displayName
-
-// CommandEmpty bileşeni
-interface CommandEmptyProps 
-  extends React.ComponentProps<typeof CommandPrimitive.Empty> {}
-
-const MoonUICommandEmptyPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.Empty>,
-  CommandEmptyProps
->(({ className, ...props }, ref) => (
-  <CommandPrimitive.Empty
-    ref={ref}
-    className={cn("py-6 text-center text-sm text-muted-foreground", className)}
-    {...props}
-  />
-))
-MoonUICommandEmptyPro.displayName = CommandPrimitive.Empty.displayName
-
-// CommandGroup bileşeni
-interface CommandGroupProps 
-  extends React.ComponentProps<typeof CommandPrimitive.Group> {}
-
-const MoonUICommandGroupPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.Group>,
-  CommandGroupProps
->(({ className, ...props }, ref) => (
-  <CommandPrimitive.Group
-    ref={ref}
-    className={cn(
-      "overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
-      className
-    )}
-    {...props}
-  />
-))
-MoonUICommandGroupPro.displayName = CommandPrimitive.Group.displayName
-
-// CommandSeparator bileşeni
-interface CommandSeparatorProps 
-  extends React.ComponentProps<typeof CommandPrimitive.Separator> {}
-
-const MoonUICommandSeparatorPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.Separator>,
-  CommandSeparatorProps
->(({ className, ...props }, ref) => (
-  <CommandPrimitive.Separator
-    ref={ref}
-    className={cn("-mx-1 h-px bg-border", className)}
-    {...props}
-  />
-))
-MoonUICommandSeparatorPro.displayName = CommandPrimitive.Separator.displayName
-
-// CommandItem bileşeni
-interface CommandItemProps 
-  extends React.ComponentProps<typeof CommandPrimitive.Item> {}
-
-const MoonUICommandItemPro = React.forwardRef<
-  React.ElementRef<typeof CommandPrimitive.Item>,
-  CommandItemProps
->(({ className, ...props }, ref) => (
-  <CommandPrimitive.Item
-    ref={ref}
-    className={cn(
-      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none aria-selected:bg-accent aria-selected:text-accent-foreground data-[disabled=true]:pointer-events-none data-[disabled=true]:opacity-50",
-      className
-    )}
-    {...props}
-  />
-))
-MoonUICommandItemPro.displayName = CommandPrimitive.Item.displayName
-
-// CommandShortcut bileşeni - utility component
-const MoonUICommandShortcutPro = ({
-  className,
-  ...props
-}: React.HTMLAttributes<HTMLSpanElement>) => {
-  return (
-    <span
-      className={cn(
-        "ml-auto text-xs tracking-widest text-muted-foreground",
-        className
-      )}
-      {...props}
-    />
-  )
-}
-MoonUICommandShortcutPro.displayName = "CommandShortcutPro"
-
-
-// Internal aliases for Pro component usage
-export const commandVariantsInternal = MoonUIcommandVariantsPro
-export const CommandInternal = MoonUICommandPro
-export const CommandDialogInternal = MoonUICommandDialogPro
-export const CommandInputInternal = MoonUICommandInputPro
-export const CommandListInternal = MoonUICommandListPro
-export const CommandEmptyInternal = MoonUICommandEmptyPro
-export const CommandGroupInternal = MoonUICommandGroupPro
-export const CommandSeparatorInternal = MoonUICommandSeparatorPro
-export const CommandItemInternal = MoonUICommandItemPro
-export const CommandShortcutInternal = MoonUICommandShortcutPro
-
-// Pro exports  
-export { MoonUIcommandVariantsPro, MoonUICommandPro, MoonUICommandDialogPro, MoonUICommandInputPro, MoonUICommandListPro, MoonUICommandEmptyPro, MoonUICommandGroupPro, MoonUICommandSeparatorPro, MoonUICommandItemPro, MoonUICommandShortcutPro }
-
-// Clean exports (without MoonUI prefix for easier usage)
-export { MoonUIcommandVariantsPro as commandVariants, MoonUICommandPro as Command, MoonUICommandDialogPro as CommandDialog, MoonUICommandInputPro as CommandInput, MoonUICommandListPro as CommandList, MoonUICommandEmptyPro as CommandEmpty, MoonUICommandGroupPro as CommandGroup, MoonUICommandSeparatorPro as CommandSeparator, MoonUICommandItemPro as CommandItem, MoonUICommandShortcutPro as CommandShortcut }

package/src/components/ui/dialog.tsx

@@ -1,334 +0,0 @@
-"use client";
-
-import * as React from "react";
-import * as DialogPrimitive from "@radix-ui/react-dialog";
-import { cva, type VariantProps } from "class-variance-authority";
-import { Check, Loader2, X } from "lucide-react";
-
-import { cn } from "../../lib/utils";
-
-/**
- * Premium Dialog Component
- *
- * Modern, accessible and customizable modal dialog component.
- * Enhances user experience with variants, sizes and rich features.
- * Provides a premium appearance with dark and light mode compatibility and fluid animations.
- */
-
-const MoonUIDialogPro = DialogPrimitive.Root;
-const MoonUIDialogTriggerPro = DialogPrimitive.Trigger;
-const MoonUIDialogPortal = DialogPrimitive.Portal;
-const MoonUIDialogClosePro = DialogPrimitive.Close;
-
-const overlayVariants = cva(
-    "fixed inset-0 z-50 backdrop-blur-sm data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-    {
-        variants: {
-            variant: {
-                default: "bg-black/80",
-                subtle: "bg-black/60",
-                blur: "bg-black/40 backdrop-blur-md",
-                minimal: "bg-black/20 backdrop-blur-sm",
-            },
-            animation: {
-                default: "duration-200",
-                slow: "duration-300",
-                fast: "duration-100",
-            },
-        },
-        defaultVariants: {
-            variant: "default",
-            animation: "default",
-        },
-    }
-);
-
-interface DialogOverlayProps
-    extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>,
-        VariantProps<typeof overlayVariants> {}
-
-const MoonUIDialogOverlayPro = React.forwardRef<
-    React.ElementRef<typeof DialogPrimitive.Overlay>,
-    DialogOverlayProps
->(({ className, variant, animation, ...props }, ref) => (
-    <DialogPrimitive.Overlay
-        ref={ref}
-        className={cn(overlayVariants({ variant, animation }), className)}
-        {...props}
-    />
-));
-MoonUIDialogOverlayPro.displayName = DialogPrimitive.Overlay.displayName;
-
-const dialogContentVariants = cva(
-    "fixed left-[50%] top-[50%] z-50 grid w-full translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background shadow-lg",
-    {
-        variants: {
-            variant: {
-                default: "border-gray-200 dark:border-gray-700",
-                primary: "border-primary/20 dark:border-primary/30",
-                secondary: "border-gray-300 dark:border-gray-600",
-                ghost: "border-transparent shadow-xl",
-                destructive: "border-error/20 dark:border-error/30",
-            },
-            size: {
-                xs: "max-w-xs p-4",
-                sm: "max-w-sm p-5",
-                default: "max-w-lg p-6",
-                md: "max-w-md p-6",
-                lg: "max-w-2xl p-7",
-                xl: "max-w-4xl p-8",
-                full: "max-w-[95vw] max-h-[95vh] p-6",
-            },
-            radius: {
-                none: "rounded-none",
-                sm: "rounded-md",
-                default: "rounded-lg",
-                lg: "rounded-xl",
-                xl: "rounded-2xl",
-                full: "rounded-3xl",
-            },
-            animation: {
-                default:
-                    "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",
-                fade: "duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-                zoom: "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",
-                slide: "duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom",
-                none: "",
-            },
-            position: {
-                default: "top-[50%]",
-                top: "top-[5%]",
-                bottom: "bottom-[5%] top-auto translate-y-0",
-            },
-        },
-        defaultVariants: {
-            variant: "default",
-            size: "default",
-            radius: "default",
-            animation: "default",
-            position: "default",
-        },
-    }
-);
-
-interface MoonUIDialogContentProProps
-    extends Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, 'title'>,
-        VariantProps<typeof dialogContentVariants> {
-    /** X butonunu gizle */
-    hideCloseButton?: boolean;
-    /** Overlay varyantı */
-    overlayVariant?: VariantProps<typeof overlayVariants>["variant"];
-    /** Overlay animasyonu */
-    overlayAnimation?: VariantProps<typeof overlayVariants>["animation"];
-    /** İçerik başlığı (hızlı kullanım için) */
-    title?: React.ReactNode;
-    /** İçerik açıklaması (hızlı kullanım için) */
-    description?: React.ReactNode;
-    /** Başlık ikonu */
-    icon?: React.ReactNode;
-    /** Yükleniyor durumu */
-    loading?: boolean;
-    /** Success durumu */
-    success?: boolean;
-    /** Özel onClose handler */
-    onClose?: () => void;
-}
-
-const MoonUIDialogContentPro = React.forwardRef<
-    React.ElementRef<typeof DialogPrimitive.Content>,
-    MoonUIDialogContentProProps
->(
-    (
-        {
-            className,
-            children,
-            variant,
-            size,
-            radius,
-            animation,
-            position,
-            overlayVariant = "default",
-            overlayAnimation = "default",
-            hideCloseButton = false,
-            title,
-            description,
-            icon,
-            loading = false,
-            success = false,
-            onClose,
-            ...props
-        },
-        ref
-    ) => {
-        // Capturing the close function through the Radix Dialog API
-        const handleClose = () => {
-            if (onClose) {
-                onClose();
-            }
-        };
-
-        return (
-            <MoonUIDialogPortal>
-                <MoonUIDialogOverlayPro
-                    variant={overlayVariant}
-                    animation={overlayAnimation}
-                    onClick={hideCloseButton ? undefined : handleClose}
-                />
-                <DialogPrimitive.Content
-                    ref={ref}
-                    onEscapeKeyDown={hideCloseButton ? undefined : handleClose}
-                    onInteractOutside={
-                        hideCloseButton ? undefined : handleClose
-                    }
-                    className={cn(
-                        dialogContentVariants({
-                            variant,
-                            size,
-                            radius,
-                            animation,
-                            position,
-                        }),
-                        "outline-none",
-                        loading && "pointer-events-none",
-                        success && "border-success/40",
-                        className
-                    )}
-                    {...props}
-                >
-                    {/* Başlık ve açıklama varsa otomatik olarak DialogHeader oluştur */}
-                    {(title || description || icon) && (
-                        <MoonUIDialogHeaderPro className="flex gap-4">
-                            {/* İkon veya loading/success durumları */}
-                            {(icon || loading || success) && (
-                                <div className="flex shrink-0 items-center justify-center">
-                                    {loading && (
-                                        <Loader2 className="h-5 w-5 animate-spin text-primary" />
-                                    )}
-                                    {success && (
-                                        <Check className="h-5 w-5 text-success" />
-                                    )}
-                                    {!loading && !success && icon && (
-                                        <span className="text-primary">
-                                            {icon}
-                                        </span>
-                                    )}
-                                </div>
-                            )}
-                            <div className="flex-1">
-                                {title && <MoonUIDialogTitlePro>{title}</MoonUIDialogTitlePro>}
-                                {description && (
-                                    <MoonUIDialogDescriptionPro>
-                                        {description}
-                                    </MoonUIDialogDescriptionPro>
-                                )}
-                            </div>
-                        </MoonUIDialogHeaderPro>
-                    )}
-
-                    {/* Main content */}
-                    {children}
-
-                    {/* Close button */}
-                    {!hideCloseButton && (
-                        <DialogPrimitive.Close
-                            onClick={handleClose}
-                            className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-primary/30 focus:ring-offset-2 disabled:pointer-events-none dark:text-gray-300 dark:hover:text-white"
-                        >
-                            <X className="h-4 w-4" />
-                            <span className="sr-only">Close</span>
-                        </DialogPrimitive.Close>
-                    )}
-                </DialogPrimitive.Content>
-            </MoonUIDialogPortal>
-        );
-    }
-);
-MoonUIDialogContentPro.displayName = DialogPrimitive.Content.displayName;
-
-const MoonUIDialogHeaderPro = ({
-    className,
-    ...props
-}: React.HTMLAttributes<HTMLDivElement>) => (
-    <div
-        className={cn(
-            "flex flex-col space-y-2 text-center sm:text-left",
-            className
-        )}
-        {...props}
-    />
-);
-MoonUIDialogHeaderPro.displayName = "MoonUIDialogHeaderPro";
-
-const MoonUIDialogFooterPro = ({
-    className,
-    ...props
-}: React.HTMLAttributes<HTMLDivElement>) => (
-    <div
-        className={cn(
-            "flex flex-col-reverse gap-2 sm:flex-row sm:justify-end sm:space-x-2 mt-6",
-            className
-        )}
-        {...props}
-    />
-);
-MoonUIDialogFooterPro.displayName = "MoonUIDialogFooterPro";
-
-const MoonUIDialogTitlePro = React.forwardRef<
-    React.ElementRef<typeof DialogPrimitive.Title>,
-    React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
->(({ className, ...props }, ref) => (
-    <DialogPrimitive.Title
-        ref={ref}
-        className={cn(
-            "text-xl font-semibold leading-snug tracking-tight dark:text-white",
-            className
-        )}
-        {...props}
-    />
-));
-MoonUIDialogTitlePro.displayName = DialogPrimitive.Title.displayName;
-
-const MoonUIDialogDescriptionPro = React.forwardRef<
-    React.ElementRef<typeof DialogPrimitive.Description>,
-    React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
->(({ className, ...props }, ref) => (
-    <DialogPrimitive.Description
-        ref={ref}
-        className={cn(
-            "text-sm text-muted-foreground leading-normal dark:text-gray-400",
-            className
-        )}
-        {...props}
-    />
-));
-MoonUIDialogDescriptionPro.displayName = DialogPrimitive.Description.displayName;
-
-/**
- * Dialog-Form integration for use with form support
- * Used to integrate form submission processes into the modal
- */
-const MoonUIDialogFormPro = React.forwardRef<
-    HTMLFormElement,
-    React.HTMLAttributes<HTMLFormElement>
->(({ className, ...props }, ref) => (
-    <form
-        ref={ref}
-        className={cn("flex flex-col gap-4", className)}
-        {...props}
-    />
-));
-MoonUIDialogFormPro.displayName = "DialogForm";
-
-export { MoonUIDialogPro,
-    MoonUIDialogTriggerPro,
-    MoonUIDialogContentPro,
-    MoonUIDialogHeaderPro,
-    MoonUIDialogFooterPro,
-    MoonUIDialogTitlePro,
-    MoonUIDialogDescriptionPro,
-    MoonUIDialogClosePro,
-    MoonUIDialogFormPro,
- };
-
-// Backward compatibility exports
-export { MoonUIDialogPro as Dialog, MoonUIDialogContentPro as DialogContent, MoonUIDialogHeaderPro as DialogHeader, MoonUIDialogFooterPro as DialogFooter, MoonUIDialogTitlePro as DialogTitle, MoonUIDialogDescriptionPro as DialogDescription, MoonUIDialogTriggerPro as DialogTrigger, MoonUIDialogClosePro as DialogClose };