@libreapps/ui 5.4.1

package/dist/primitives/separator.d.ts

@@ -0,0 +1,8 @@
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as React from 'react';
+declare const Separator: {
+    ({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Separator };
+export default Separator;

package/dist/primitives/sheet.d.ts

@@ -0,0 +1,40 @@
+import * as SheetPrimitive from '@radix-ui/react-dialog';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
+declare const SheetOverlay: {
+    ({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+    container?: HTMLElement;
+    overlayClassName?: string;
+    hideCloseButton?: boolean;
+}
+declare const SheetContent: {
+    ({ side, className, children, container, overlayClassName, hideCloseButton, ...props }: SheetContentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: {
+    ({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const SheetDescription: {
+    ({ className, ...props }: React.ComponentProps<typeof SheetPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/primitives/sidebar.d.ts

@@ -0,0 +1,69 @@
+import * as React from "react";
+import { VariantProps } from "class-variance-authority";
+import { Button } from "./button";
+import { Input } from "./input";
+import { Separator } from "./separator";
+import { TooltipContent } from "./tooltip";
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }: React.ComponentProps<"div"> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: React.ComponentProps<"div"> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<"button">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<"main">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupLabel({ className, asChild, ...props }: React.ComponentProps<"div"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupAction({ className, asChild, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React.ComponentProps<"button"> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React.ComponentProps<"a"> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

package/dist/primitives/skeleton.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };
+export default Skeleton;

package/dist/primitives/slider.d.ts

@@ -0,0 +1,5 @@
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import * as React from 'react';
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Slider };
+export default Slider;

package/dist/primitives/sonner.d.ts

@@ -0,0 +1,5 @@
+import { Toaster as Sonner } from 'sonner';
+import { toast } from 'sonner';
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { toast, Toaster };

package/dist/primitives/spinner.d.ts

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<'svg'>): import("react/jsx-runtime").JSX.Element;
+export { Spinner };

package/dist/primitives/step-indicator.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+declare const StepIndicator: React.FC<{
+    steps: string[];
+    currentStep: number;
+    dotSizeRem: number;
+    className?: string;
+    muted?: boolean;
+}>;
+export default StepIndicator;

package/dist/primitives/stepper.d.ts

@@ -0,0 +1,48 @@
+import * as React from 'react';
+interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+    defaultValue?: number;
+    value?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare const Stepper: {
+    ({ defaultValue, value, onValueChange, orientation, className, ...props }: StepperProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface StepperItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    step: number;
+    completed?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+}
+declare const StepperItem: {
+    ({ step, completed, disabled, loading, className, children, ...props }: StepperItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface StepperTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const StepperTrigger: {
+    ({ asChild, className, children, ...props }: StepperTriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+interface StepperIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean;
+}
+declare const StepperIndicator: {
+    ({ asChild, className, children, ...props }: StepperIndicatorProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const StepperTitle: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLHeadingElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const StepperDescription: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLParagraphElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const StepperSeparator: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Stepper, StepperDescription, StepperIndicator, StepperItem, StepperSeparator, StepperTitle, StepperTrigger, };

package/dist/primitives/switch.d.ts

@@ -0,0 +1,8 @@
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import * as React from 'react';
+declare const Switch: {
+    ({ className, ...props }: React.ComponentProps<typeof SwitchPrimitives.Root>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Switch };
+export default Switch;

package/dist/primitives/table.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+declare const Table: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableBody: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableRow: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableRowElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableHead: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableCellElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableCell: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableCellElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const TableCaption: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLTableCaptionElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/primitives/tabs.d.ts

@@ -0,0 +1,11 @@
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare function Tabs({ className, orientation, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "line" | "default" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, ...props }: React.ComponentProps<typeof TabsPrimitive.List> & VariantProps<typeof tabsListVariants>): import("react/jsx-runtime").JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/dist/primitives/text-area.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface TextAreaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export default TextArea;

package/dist/primitives/text-link.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const TextLink: ({ label, url, className, ...props }: {
+    label: string;
+    url: string;
+} & React.ButtonHTMLAttributes<HTMLSpanElement>) => import("react/jsx-runtime").JSX.Element;

package/dist/primitives/textarea.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+export type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    minHeight?: number;
+    maxHeight?: number;
+    resize?: 'none' | 'both' | 'horizontal' | 'vertical';
+};
+declare const Textarea: React.ForwardRefExoticComponent<React.TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    minHeight?: number;
+    maxHeight?: number;
+    resize?: "none" | "both" | "horizontal" | "vertical";
+} & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/primitives/textfield.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { RefCallBack } from 'react-hook-form';
+declare const TextField: ({ classes, field, label, type, helperMessage, startAdornment, endAdornment, autoFocus, min, max, }: {
+    classes?: {
+        formItem?: string;
+        label?: string;
+        input?: string;
+        helperMessage?: string;
+    };
+    field: {
+        onChange?: (...event: any[]) => void;
+        onFocus?: (...event: any[]) => void;
+        onKeyDown?: (...event: any[]) => void;
+        onBlur?: () => void;
+        value: any;
+        disabled?: boolean;
+        name?: string;
+        ref?: React.RefObject<HTMLInputElement | null> | RefCallBack;
+        placeholder?: string;
+        readOnly?: boolean;
+    };
+    autoFocus?: boolean;
+    label: React.ReactNode;
+    helperMessage?: React.ReactNode;
+    type?: "text" | "password" | "number";
+    startAdornment?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    min?: number;
+    max?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export { TextField };
+export default TextField;

package/dist/primitives/toast.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Toaster as Sonner } from 'sonner';
+type ToasterProps = React.ComponentProps<typeof Sonner>;
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/dist/primitives/toggle-group.d.ts

@@ -0,0 +1,13 @@
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import { toggleVariants } from './toggle';
+declare const ToggleGroup: {
+    ({ className, variant, size, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+declare const ToggleGroupItem: {
+    ({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { ToggleGroup, ToggleGroupItem };

package/dist/primitives/toggle.d.ts

@@ -0,0 +1,12 @@
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Toggle: {
+    ({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Toggle, toggleVariants };

package/dist/primitives/tooltip.d.ts

@@ -0,0 +1,14 @@
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as React from 'react';
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipPortal: React.FC<TooltipPrimitive.TooltipPortalProps>;
+declare const TooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const TooltipContent: {
+    ({ className, sideOffset, showArrow, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content> & {
+        showArrow?: boolean;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string | undefined;
+};
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipPortal, TooltipArrow, };

package/dist/primitives/video-player.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface VideoProps extends React.ComponentPropsWithoutRef<"video"> {
+    sources: string[];
+}
+declare const VideoPlayer: React.ForwardRefExoticComponent<VideoProps & React.RefAttributes<HTMLVideoElement>>;
+export default VideoPlayer;

package/dist/primitives/youtube-pip-player.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+export interface YouTubePipPlayerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onPlay' | 'onPause'> {
+    /** YouTube video ID or array of IDs for rotation */
+    videoId: string | string[];
+    /** Auto-rotate videos every N seconds (default: 30) */
+    rotationInterval?: number;
+    /** Enable scroll-based PIP mode */
+    enablePip?: boolean;
+    /** Initial muted state (default: true) */
+    defaultMuted?: boolean;
+    /** Show live indicator */
+    showLiveIndicator?: boolean;
+    /** Enable TV-style visual effects */
+    enableTvEffects?: boolean;
+    /** PIP position (default: bottom-right) */
+    pipPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Callbacks */
+    onPlay?: () => void;
+    onPause?: () => void;
+    onPipEnter?: () => void;
+    onPipExit?: () => void;
+    onMuteChange?: (muted: boolean) => void;
+}
+declare const youtubePipPlayerVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "full" | "hero" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface YouTubePipPlayerVariantProps extends VariantProps<typeof youtubePipPlayerVariants> {
+}
+declare const YouTubePipPlayer: React.ForwardRefExoticComponent<YouTubePipPlayerProps & YouTubePipPlayerVariantProps & React.RefAttributes<HTMLDivElement>>;
+export { YouTubePipPlayer, youtubePipPlayerVariants };
+export default YouTubePipPlayer;