@hanzo/ui 4.5.0 → 4.5.2

package/dist/primitives/sheet.jsx

@@ -0,0 +1,56 @@
+// @ts-nocheck
+'use client';
+import * as React from 'react';
+import * as SheetPrimitive from '@radix-ui/react-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from '../util';
+const Sheet = SheetPrimitive.Root;
+const SheetTrigger = SheetPrimitive.Trigger;
+const SheetClose = SheetPrimitive.Close;
+const SheetPortal = SheetPrimitive.Portal;
+const SheetOverlay = React.forwardRef(({ className, ...props }, ref) => (<SheetPrimitive.Overlay className={cn('fixed inset-0 z-below-modal bg-overlay 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', className)} {...props} ref={ref}/>));
+SheetOverlay.displayName = SheetPrimitive.Overlay.displayName;
+const sheetVariants = cva('fixed z-modal gap-4 bg-background p-3 sm:p-6 shadow-lg transition ease-in-out data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-300', {
+    variants: {
+        side: {
+            top: 'inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top',
+            bottom: 'inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom',
+            left: 'inset-y-0 left-0 h-full w-5/6 sm:w-2/3 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm',
+            right: 'inset-y-0 right-0 h-full w-5/6 sm:w-2/3 border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm',
+        },
+    },
+    defaultVariants: {
+        side: 'right',
+    },
+});
+const closeUIclx = 'rounded-sm opacity-70 ring-offset-background ' +
+    'transition-opacity hover:opacity-100 disabled:pointer-events-none data-[state=open]:bg-primary';
+const SheetContent = React.forwardRef(({ side = 'right', className, children, closeElement, centerElement, duplicateCloseOnBottom = false, closeButtonClass, ...props }, ref) => {
+    const xOfCloseUIClass = (side === 'right') ? 'left-2' : 'right-2';
+    return (<SheetPortal>
+        <SheetOverlay />
+        <SheetPrimitive.Content ref={ref} className={cn(sheetVariants({ side }), className)} {...props}>
+          {children}
+
+          {closeElement && (<SheetPrimitive.Close className={cn(closeUIclx, 'absolute z-above-content top-3', xOfCloseUIClass, closeButtonClass)}>
+              {closeElement}
+            </SheetPrimitive.Close>)}
+          {closeElement && duplicateCloseOnBottom && (<SheetPrimitive.Close className={cn(closeUIclx, 'absolute z-above-content bottom-3', xOfCloseUIClass, closeButtonClass)}>
+            {closeElement}
+            </SheetPrimitive.Close>)}
+          {centerElement && (<div className={'absolute z-content top-3 left-0 right-0 flex flex-row justify-center align-start'}>
+              {centerElement}
+            </div>)}
+        </SheetPrimitive.Content>
+      </SheetPortal>);
+});
+SheetContent.displayName = SheetPrimitive.Content.displayName;
+const SheetHeader = ({ className, ...props }) => (<div className={cn('flex flex-col space-y-2 text-center sm:text-left', className)} {...props}/>);
+SheetHeader.displayName = 'SheetHeader';
+const SheetFooter = ({ className, ...props }) => (<div className={cn('flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2', className)} {...props}/>);
+SheetFooter.displayName = 'SheetFooter';
+const SheetTitle = React.forwardRef(({ className, ...props }, ref) => (<SheetPrimitive.Title ref={ref} className={cn('text-lg font-semibold text-foreground', className)} {...props}/>));
+SheetTitle.displayName = SheetPrimitive.Title.displayName;
+const SheetDescription = React.forwardRef(({ className, ...props }, ref) => (<SheetPrimitive.Description ref={ref} className={cn('text-sm text-muted-1', className)} {...props}/>));
+SheetDescription.displayName = SheetPrimitive.Description.displayName;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/dist/primitives/skeleton.d.ts

@@ -0,0 +1,4 @@
+declare const Skeleton: React.FC<{
+    reverse?: boolean;
+} & React.HTMLAttributes<HTMLDivElement>>;
+export default Skeleton;

package/dist/primitives/skeleton.jsx

@@ -0,0 +1,3 @@
+import { cn } from '../util';
+const Skeleton = ({ reverse = false, className, ...props }) => (<div className={cn('rounded-md bg-level-2', reverse ? 'animate-pulsereverse' : 'animate-pulse', className)} {...props}/>);
+export default Skeleton;

package/dist/primitives/slider.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & {
+    trackBgClx?: string;
+    rangeBgClx?: string;
+    thumbClx?: string;
+    thumbSlidingClx?: string;
+} & React.RefAttributes<HTMLSpanElement>>;
+export default Slider;

package/dist/primitives/slider.jsx

@@ -0,0 +1,30 @@
+'use client';
+import * as React from 'react';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import { cn } from '../util';
+import { useState } from 'react';
+const Slider = React.forwardRef(({ className, trackBgClx = 'bg-level-2', rangeBgClx = 'bg-primary', thumbClx = '', thumbSlidingClx = '', onValueChange, onValueCommit, ...rest }, ref) => {
+    const [sliding, setSliding] = useState(false);
+    const _onChange = (value) => {
+        if (!sliding) {
+            setSliding(true);
+        }
+        if (onValueChange) {
+            onValueChange(value);
+        }
+    };
+    const _onCommit = (value) => {
+        setSliding(false);
+        if (onValueCommit) {
+            onValueCommit(value);
+        }
+    };
+    return (<SliderPrimitive.Root ref={ref} className={cn('relative flex w-full touch-none select-none items-center', className)} onValueChange={_onChange} onValueCommit={_onCommit} {...rest}>
+      <SliderPrimitive.Track data-vaul-no-drag className={'relative h-2 w-full grow overflow-hidden rounded-full ' + trackBgClx}>
+        <SliderPrimitive.Range data-vaul-no-drag className={'absolute h-full ' + rangeBgClx}/>
+      </SliderPrimitive.Track>
+      <SliderPrimitive.Thumb data-vaul-no-drag className={cn('block h-5 w-5 rounded-full border-2 border-primary bg-background ', 'ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-1 ', 'focus-visible:ring-muted-2 focus-visible:ring-offset-1 disabled:pointer-events-none disabled:opacity-50', thumbClx, (sliding ? thumbSlidingClx : ''))}/>
+    </SliderPrimitive.Root>);
+});
+Slider.displayName = SliderPrimitive.Root.displayName;
+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.Element;
+export { toast, Toaster };

package/dist/primitives/sonner.jsx

@@ -0,0 +1,16 @@
+'use client';
+import { useTheme } from 'next-themes';
+import { Toaster as Sonner } from 'sonner';
+import { toast } from 'sonner';
+const Toaster = ({ ...props }) => {
+    const { theme = 'system' } = useTheme();
+    return (<Sonner theme={theme} className='toaster group' toastOptions={{
+            classNames: {
+                toast: 'group toast group-[.toaster]:bg-level-2 group-[.toaster]:text-foreground group-[.toaster]:border-muted-3 group-[.toaster]:shadow-lg',
+                description: 'group-[.toast]:text-foreground',
+                actionButton: 'group-[.toast]:bg-primary group-[.toast]:text-primary-fg',
+                cancelButton: 'group-[.toast]:bg-transparent group-[.toast]:text-foreground',
+            },
+        }} {...props}/>);
+};
+export { toast, Toaster };

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/step-indicator.jsx

@@ -0,0 +1,23 @@
+import React from 'react';
+import { cn } from '../util';
+const StepIndicator = ({ steps, currentStep, dotSizeRem, className = '', muted = false }) => {
+    const pX = `calc(${1 / (steps.length * 2) * 100}% - ${dotSizeRem / 2}rem)`;
+    // This code current throws 'Warning: Each child in a list should have a unique "key" prop.'
+    // As is evident, we supply keys that should suffice.  < shrug >
+    return (<div className={cn('flex flex-col', className)}>
+      <div key='one' 
+    /* id='FOO' */
+    className='flex flex-row items-center justify-start w-full' style={{ paddingLeft: pX, paddingRight: pX }}>
+        {steps.map((ignore, index) => (<>
+          {index !== 0 && (<div key={`sep-${index}`} className={cn('h-[1px] grow', currentStep >= index ? (muted ? 'bg-muted' : 'bg-foreground') : (muted ? 'bg-muted-3' : 'bg-level-3'))}/>)}
+          <div key={`circle-${index}`} style={{ width: `${dotSizeRem}rem`, height: `${dotSizeRem}rem` }} className={cn('shrink-0 rounded-full border-[1.5px]', currentStep >= index ? (muted ? 'bg-muted border-muted' : 'bg-foreground border-foreground') : '')}/>
+        </>))}
+      </div>
+      <div key='two' className={'grid ' + `grid-cols-${steps.length}` /* These are white listed already */}>
+        {steps.map((label, index) => (<div key={index} className={cn('text-center whitespace-nowrap', (muted ? 'text-muted' : 'text-foreground'))}>
+            {label}
+          </div>))}
+      </div>
+    </div>);
+};
+export default StepIndicator;

package/dist/primitives/switch.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    thumbClx?: string;
+} & React.RefAttributes<HTMLButtonElement>>;
+export default Switch;

package/dist/primitives/switch.jsx

@@ -0,0 +1,14 @@
+'use client';
+import React from 'react';
+import * as SwitchPrimitives from '@radix-ui/react-switch';
+import { cn } from '../util';
+const Switch = React.forwardRef(({ className, thumbClx = '', ...props }, ref) => (<SwitchPrimitives.Root className={cn('peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full ' +
+        'border-2 border-transparent shadow-sm transition-colors focus-visible:outline-none ' +
+        'focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 ' +
+        'focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 ' +
+        'data-[state=checked]:bg-primary data-[state=unchecked]:bg-level-3', className)} {...props} ref={ref}>
+    <SwitchPrimitives.Thumb className={cn('pointer-events-none block h-4 w-4 rounded-full bg-background shadow-lg ' +
+        'ring-0 transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0', thumbClx)}/>
+  </SwitchPrimitives.Root>));
+Switch.displayName = SwitchPrimitives.Root.displayName;
+export default Switch;

package/dist/primitives/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/primitives/table.jsx

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { cn } from '../util';
+const Table = React.forwardRef(({ className, ...props }, ref) => (<div className='relative w-full overflow-auto'>
+    <table ref={ref} className={cn('w-full caption-bottom text-sm', className)} {...props}/>
+  </div>));
+Table.displayName = 'Table';
+const TableHeader = React.forwardRef(({ className, ...props }, ref) => (<thead ref={ref} className={cn('[&_tr]:border-b', className)} {...props}/>));
+TableHeader.displayName = 'TableHeader';
+const TableBody = React.forwardRef(({ className, ...props }, ref) => (<tbody ref={ref} className={cn('[&_tr:last-child]:border-0', className)} {...props}/>));
+TableBody.displayName = 'TableBody';
+const TableFooter = React.forwardRef(({ className, ...props }, ref) => (<tfoot ref={ref} className={cn('border-t bg-level-1 font-medium [&>tr]:last:border-b-0', className)} {...props}/>));
+TableFooter.displayName = 'TableFooter';
+const TableRow = React.forwardRef(({ className, ...props }, ref) => (<tr ref={ref} className={cn('border-b transition-colors hover:bg-level-1 data-[state=selected]:bg-level-1', className)} {...props}/>));
+TableRow.displayName = 'TableRow';
+const TableHead = React.forwardRef(({ className, ...props }, ref) => (<th ref={ref} className={cn('h-12 px-4 text-left align-middle font-medium text-muted [&:has([role=checkbox])]:pr-0', className)} {...props}/>));
+TableHead.displayName = 'TableHead';
+const TableCell = React.forwardRef(({ className, ...props }, ref) => (<td ref={ref} className={cn('p-4 align-middle [&:has([role=checkbox])]:pr-0', className)} {...props}/>));
+TableCell.displayName = 'TableCell';
+const TableCaption = React.forwardRef(({ className, ...props }, ref) => (<caption ref={ref} className={cn('mt-4 text-sm text-muted', className)} {...props}/>));
+TableCaption.displayName = 'TableCaption';
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/primitives/tabs.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/primitives/tabs.jsx

@@ -0,0 +1,18 @@
+'use client';
+import React from 'react';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { cn } from '../util';
+const Tabs = TabsPrimitive.Root;
+const TabsList = React.forwardRef(({ className, ...props }, ref) => (<TabsPrimitive.List ref={ref} className={cn('inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground', className)} {...props}/>));
+TabsList.displayName = TabsPrimitive.List.displayName;
+const TabsTrigger = React.forwardRef(({ className, ...props }, ref) => (<TabsPrimitive.Trigger ref={ref} className={cn('inline-flex items-center justify-center whitespace-nowrap rounded-sm ' +
+        'px-3 py-1.5 text-sm font-medium ring-offset-background transition-all ' +
+        'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ' +
+        'focus-visible:ring-offset-2 disabled:pointer-events-none ' +
+        'disabled:opacity-50 data-[state=active]:bg-background ' +
+        'data-[state=active]:text-foreground data-[state=active]:shadow-sm', className)} {...props}/>));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+const TabsContent = React.forwardRef(({ className, ...props }, ref) => (<TabsPrimitive.Content ref={ref} className={cn('mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 ' +
+        'focus-visible:ring-ring focus-visible:ring-offset-2', className)} {...props}/>));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

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-area.jsx

@@ -0,0 +1,9 @@
+import React from 'react';
+import { cn } from '../util';
+const TextArea = React.forwardRef(({ className, ...props }, ref) => {
+    return (<textarea className={cn('flex min-h-[80px] w-full rounded-md border border-muted-3 px-3 py-2 text-sm ' +
+            'placeholder:text-muted-2  focus-visible:outline-none focus-visible:ring-2 ' +
+            'focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50', className)} ref={ref} {...props}/>);
+});
+TextArea.displayName = 'TextArea';
+export default TextArea;

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

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import type { VariantProps } from 'class-variance-authority';
+declare const ToggleGroup: React.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | "hfull" | null | undefined;
+    rounded?: "none" | "md" | "sm" | "lg" | "full" | "xl" | "lsm" | "rsm" | "lmd" | "rmd" | "llg" | "rlg" | "lxl" | "rxl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string>) & React.RefAttributes<HTMLDivElement>>;
+declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | "hfull" | null | undefined;
+    rounded?: "none" | "md" | "sm" | "lg" | "full" | "xl" | "lsm" | "rsm" | "lmd" | "rmd" | "llg" | "rlg" | "lxl" | "rxl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroup, ToggleGroupItem };

package/dist/primitives/toggle-group.jsx

@@ -0,0 +1,28 @@
+'use client';
+import * as React from 'react';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import { cn } from '../util';
+import { toggleVariants } from './toggle';
+const ToggleGroupContext = React.createContext({
+    size: 'default',
+    variant: 'default',
+    rounded: 'md'
+});
+const ToggleGroup = React.forwardRef(({ className, variant, size, rounded, children, ...props }, ref) => (<ToggleGroupPrimitive.Root ref={ref} className={cn('flex items-center justify-center gap-1', className)} {...props}>
+    <ToggleGroupContext.Provider value={{ variant, size, rounded }}>
+      {children}
+    </ToggleGroupContext.Provider>
+  </ToggleGroupPrimitive.Root>));
+ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName;
+const ToggleGroupItem = React.forwardRef(({ className, children, variant, size, rounded, ...props }, ref) => {
+    const context = React.useContext(ToggleGroupContext);
+    return (<ToggleGroupPrimitive.Item ref={ref} className={cn(toggleVariants({
+            variant: context.variant || variant,
+            size: context.size || size,
+            rounded: context.rounded || rounded,
+        }), className)} {...props}>
+      {children}
+    </ToggleGroupPrimitive.Item>);
+});
+ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName;
+export { ToggleGroup, ToggleGroupItem };

package/dist/primitives/toggle.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { type VariantProps } from 'class-variance-authority';
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | "hfull" | null | undefined;
+    rounded?: "none" | "md" | "sm" | "lg" | "full" | "xl" | "lsm" | "rsm" | "lmd" | "rmd" | "llg" | "rlg" | "lxl" | "rxl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | "hfull" | null | undefined;
+    rounded?: "none" | "md" | "sm" | "lg" | "full" | "xl" | "lsm" | "rsm" | "lmd" | "rmd" | "llg" | "rlg" | "lxl" | "rxl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLButtonElement>>;
+export { Toggle, toggleVariants };

package/dist/primitives/toggle.jsx

@@ -0,0 +1,52 @@
+'use client';
+import * as React from 'react';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import { cva } from 'class-variance-authority';
+import { cn } from '../util';
+const toggleVariants = cva('inline-flex items-center justify-center text-sm font-medium ' +
+    'ring-offset-background ' +
+    'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ' +
+    'focus-visible:ring-offset-2 disabled:pointer-events-none ' +
+    'active:bg-level-3 active:text-accent ', {
+    variants: {
+        variant: {
+            default: 'text-muted-1 hover:text-accent ' +
+                'data-[state=off]:bg-level-1 hover:data-[state=off]:text-foreground ' +
+                'data-[state=on]:text-foreground data-[state=on]:bg-level-3  ' +
+                'data-[state=on]:hover:bg-level-3 ',
+            outline: 'border border-muted-3 text-muted-1 ' +
+                'data-[state=off]:bg-level-1 hover:data-[state=off]:text-foreground ' +
+                'data-[state=on]:bg-level-3 data-[state=on]:border-muted data-[state=on]:text-foreground',
+        },
+        size: {
+            default: 'h-10 px-3',
+            hfull: 'h-full px-3',
+            sm: 'h-9 px-2',
+            lg: 'h-11 px-5',
+        },
+        rounded: {
+            full: 'rounded-full',
+            sm: 'rounded-sm',
+            lsm: 'rounded-l-sm',
+            rsm: 'rounded-r-sm',
+            md: 'rounded-md',
+            lmd: 'rounded-l-md',
+            rmd: 'rounded-r-md',
+            lg: 'rounded-lg',
+            llg: 'rounded-l-lg',
+            rlg: 'rounded-r-lg',
+            xl: 'rounded-xl',
+            lxl: 'rounded-l-xl',
+            rxl: 'rounded-r-xl',
+            none: 'rounded-none'
+        }
+    },
+    defaultVariants: {
+        variant: 'default',
+        size: 'default',
+        rounded: 'md'
+    },
+});
+const Toggle = React.forwardRef(({ className, variant, size, rounded, ...props }, ref) => (<TogglePrimitive.Root ref={ref} className={cn(toggleVariants({ variant, size, rounded }), className)} {...props}/>));
+Toggle.displayName = TogglePrimitive.Root.displayName;
+export { Toggle, toggleVariants };

package/dist/primitives/tooltip.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+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 TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TooltipWrapper: React.FC<{
+    text: string;
+    tooltipClx?: string;
+} & React.PropsWithChildren>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipWrapper };

package/dist/primitives/tooltip.jsx

@@ -0,0 +1,18 @@
+'use client';
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { cn } from '../util';
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (<TooltipPrimitive.Content ref={ref} sideOffset={sideOffset} className={cn('z-50 overflow-hidden rounded-md border bg-level-1 px-3 py-1.5 text-sm text-muted-foreground shadow-md animate-in fade-in-50 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2', className)} {...props}/>));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+const TooltipWrapper = ({ children, text, tooltipClx = '' }) => (<Tooltip>
+    <TooltipTrigger asChild>
+      {children}
+    </TooltipTrigger>
+    <TooltipContent className={tooltipClx}>
+      {text}
+    </TooltipContent>
+  </Tooltip>);
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipWrapper };

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/video-player.jsx

@@ -0,0 +1,8 @@
+'use client';
+import React from 'react';
+const VideoPlayer = React.forwardRef(({ sources, ...rest }, ref) => {
+    return (<video ref={ref} {...rest}>
+    {sources.map((source, index) => (<source key={index} src={source}/>))} 
+    </video>);
+});
+export default VideoPlayer;

package/dist/registry/api.d.ts

@@ -0,0 +1,37 @@
+import { RegistryItem, Registry } from ".";
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export declare function getRegistryUrl(registry: string): string;
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export declare function getRegistryItem(itemUrl: string, basePath: string): Promise<RegistryItem | null>;
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export declare function resolveImport(importPath: string, basePath: string): string;
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export declare function fetchRegistry(paths: string[], options?: {
+    useCache?: boolean;
+}): Promise<Registry[]>;
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export declare function getRegistryItemUrl(itemName: string, registryUrl: string): string;

package/dist/registry/api.js

@@ -0,0 +1,130 @@
+import { registryItemSchema, RegistryItem, Registry } from ".";
+import { z } from "zod";
+const registryCache = new Map();
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export function getRegistryUrl(registry) {
+    // Check if registry is a full URL
+    if (registry.startsWith("http")) {
+        return registry;
+    }
+    // Default to Hanzo registry if REGISTRY_BASE_URL is defined, otherwise use shadcn
+    const baseUrl = process.env.REGISTRY_BASE_URL || "https://ui.shadcn.com/registry";
+    // Check if registry is a path to a JSON file
+    if (registry.endsWith(".json")) {
+        return `${baseUrl}/${registry}`;
+    }
+    // Assume registry is a registry style
+    return `${baseUrl}/${registry}/registry.json`;
+}
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export async function getRegistryItem(itemUrl, basePath) {
+    try {
+        const response = await fetch(itemUrl);
+        if (!response.ok) {
+            console.error(`Failed to fetch registry item from ${itemUrl}: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        const item = await response.json();
+        const validatedItem = registryItemSchema.safeParse(item);
+        if (!validatedItem.success) {
+            console.error(`Invalid registry item format: ${JSON.stringify(validatedItem.error)}`);
+            return null;
+        }
+        // Process and resolve file paths
+        if (validatedItem.data.files) {
+            for (const file of validatedItem.data.files) {
+                if (!file.content) {
+                    continue;
+                }
+                // If the file has a target, we resolve it from the target
+                if (file.target) {
+                    file.target = resolveImport(file.target, basePath);
+                }
+            }
+        }
+        return validatedItem.data;
+    }
+    catch (error) {
+        console.error(`Error fetching registry item: ${error}`);
+        return null;
+    }
+}
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export function resolveImport(importPath, basePath) {
+    const importParts = importPath?.split("/");
+    // Check if it's a relative import
+    if (importPath.startsWith(".")) {
+        return [basePath.replace(/^@/, ""), ...importParts].filter(Boolean).join("/");
+    }
+    // Check if it's a scope package
+    if (importParts?.[0]?.startsWith("@")) {
+        return importPath;
+    }
+    return importPath;
+}
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export async function fetchRegistry(paths, options = {}) {
+    options = {
+        useCache: true,
+        ...options,
+    };
+    try {
+        const results = await Promise.all(paths.map(async (path) => {
+            const url = getRegistryUrl(path);
+            // Check cache first if caching is enabled
+            if (options.useCache && registryCache.has(url)) {
+                return registryCache.get(url);
+            }
+            // Store the promise in the cache before awaiting if caching is enabled
+            const fetchPromise = (async () => {
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch registry from ${url}. ${response.status} ${response.statusText}`);
+                }
+                return response.json();
+            })();
+            if (options.useCache) {
+                registryCache.set(url, fetchPromise);
+            }
+            return fetchPromise;
+        }));
+        return results;
+    }
+    catch (error) {
+        console.error(`Error fetching registry: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export function getRegistryItemUrl(itemName, registryUrl) {
+    const registryBaseUrl = registryUrl.replace(/\/registry\.json$/, "");
+    return `${registryBaseUrl}/r/${itemName}.json`;
+}
+// Support CommonJS
+if (typeof module !== 'undefined') {
+    module.exports = { getRegistryUrl, getRegistryItem, resolveImport, fetchRegistry, getRegistryItemUrl };
+}

package/dist/registry/index.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const fileSchema: any;
+export declare const registryItemSchema: any;
+export declare const registrySchema: any;
+export declare const registryWithContentSchema: any;
+export type RegistryItem = z.infer<typeof registryItemSchema>;
+export type Registry = z.infer<typeof registrySchema>;
+export type RegistryWithContent = z.infer<typeof registryWithContentSchema>;
+export type RegistryFile = z.infer<typeof fileSchema>;