@nlabs/gothamui 1.8.0

package/lib/components/Avatar/Avatar.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { createContext, useContext, useMemo, useState } from 'react';
+const AvatarContext = /*#__PURE__*/ createContext(null);
+const sizeClasses = {
+    default: 'size-8',
+    lg: 'size-10',
+    sm: 'size-6'
+};
+const badgeClasses = {
+    default: 'size-2.5 [&>svg]:size-2',
+    lg: 'size-3 [&>svg]:size-2',
+    sm: 'size-2 [&>svg]:hidden'
+};
+const textClasses = {
+    default: 'text-sm',
+    lg: 'text-sm',
+    sm: 'text-xs'
+};
+const avatarClasses = 'relative inline-grid shrink-0 align-middle outline-none *:col-start-1 *:row-start-1';
+const fallbackClasses = 'flex size-full items-center justify-center bg-zinc-100 font-medium text-zinc-600 ring-1 ring-zinc-950/5 dark:bg-zinc-800 dark:text-zinc-300 dark:ring-white/10';
+const shapeClasses = {
+    round: 'rounded-full *:rounded-full',
+    square: 'rounded-lg *:rounded-lg'
+};
+const useAvatarContext = ()=>{
+    const context = useContext(AvatarContext);
+    if (!context) {
+        throw new Error('Avatar components must be used within Avatar.');
+    }
+    return context;
+};
+const useAvatarValue = (size, square)=>{
+    const [imageLoaded, setImageLoaded] = useState(false);
+    return useMemo(()=>({
+            imageLoaded,
+            registerImageLoaded: setImageLoaded,
+            size,
+            square
+        }), [
+        imageLoaded,
+        size,
+        square
+    ]);
+};
+const renderAvatarContent = ({ alt, children, initials, onError, onLoad, src })=>children ?? /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            src ? /*#__PURE__*/ _jsx(AvatarImage, {
+                alt: alt,
+                onError: onError,
+                onLoad: onLoad,
+                src: src
+            }) : null,
+            initials ? /*#__PURE__*/ _jsx(AvatarFallback, {
+                children: initials
+            }) : null
+        ]
+    });
+export const Avatar = ({ alt = '', children, className, initials, onError, onLoad, size = 'default', square = false, src, ...props })=>{
+    const value = useAvatarValue(size, square);
+    return /*#__PURE__*/ _jsx(AvatarContext.Provider, {
+        value: value,
+        children: /*#__PURE__*/ _jsx("div", {
+            className: cn(avatarClasses, square ? shapeClasses.square : shapeClasses.round, sizeClasses[size], className),
+            "data-size": size,
+            "data-slot": "avatar",
+            "data-square": square ? 'true' : undefined,
+            ...props,
+            children: renderAvatarContent({
+                alt,
+                children,
+                initials,
+                onError,
+                onLoad,
+                src
+            })
+        })
+    });
+};
+export const AvatarImage = ({ alt = '', className, onError, onLoad, ...props })=>{
+    const { registerImageLoaded } = useAvatarContext();
+    return /*#__PURE__*/ _jsx("img", {
+        alt: alt,
+        className: cn('size-full object-cover', className),
+        "data-slot": "avatar-image",
+        onError: (event)=>{
+            registerImageLoaded(false);
+            onError?.(event);
+        },
+        onLoad: (event)=>{
+            registerImageLoaded(true);
+            onLoad?.(event);
+        },
+        ...props
+    });
+};
+export const AvatarFallback = ({ children, className, ...props })=>{
+    const { imageLoaded, size } = useAvatarContext();
+    if (imageLoaded) {
+        return null;
+    }
+    return /*#__PURE__*/ _jsx("div", {
+        className: cn(fallbackClasses, textClasses[size], className),
+        "data-slot": "avatar-fallback",
+        ...props,
+        children: children
+    });
+};
+export const AvatarBadge = ({ className, ...props })=>{
+    const { size } = useAvatarContext();
+    return /*#__PURE__*/ _jsx("span", {
+        className: cn('absolute right-0 bottom-0 z-10 inline-flex translate-x-1/4 translate-y-1/4 items-center justify-center rounded-full bg-primary text-primary-foreground ring-2 ring-white select-none dark:ring-zinc-900', badgeClasses[size], className),
+        "data-slot": "avatar-badge",
+        ...props
+    });
+};
+export const AvatarButton = ({ alt = '', children, className, initials, onError, onLoad, size = 'default', square = false, src, type = 'button', ...props })=>{
+    const value = useAvatarValue(size, square);
+    return /*#__PURE__*/ _jsx(AvatarContext.Provider, {
+        value: value,
+        children: /*#__PURE__*/ _jsx("button", {
+            className: cn(avatarClasses, 'cursor-pointer disabled:pointer-events-none disabled:opacity-50 focus-visible:ring-[3px] focus-visible:ring-ring/50', square ? shapeClasses.square : shapeClasses.round, sizeClasses[size], className),
+            "data-size": size,
+            "data-slot": "avatar-button",
+            "data-square": square ? 'true' : undefined,
+            type: type,
+            ...props,
+            children: renderAvatarContent({
+                alt,
+                children,
+                initials,
+                onError,
+                onLoad,
+                src
+            })
+        })
+    });
+};
+export const AvatarGroup = ({ className, ...props })=>/*#__PURE__*/ _jsx("div", {
+        className: cn('group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-white *:data-[slot=avatar-button]:ring-2 *:data-[slot=avatar-button]:ring-white dark:*:data-[slot=avatar]:ring-zinc-900 dark:*:data-[slot=avatar-button]:ring-zinc-900', className),
+        "data-slot": "avatar-group",
+        ...props
+    });
+export const AvatarGroupCount = ({ children, className, ...props })=>{
+    const countLabel = children ?? '+0';
+    return /*#__PURE__*/ _jsx("div", {
+        className: cn('relative flex size-8 shrink-0 items-center justify-center rounded-full bg-zinc-100 text-sm font-medium text-zinc-600 ring-2 ring-white dark:bg-zinc-800 dark:text-zinc-300 dark:ring-zinc-900 [&>svg]:size-4', className),
+        "data-slot": "avatar-group-count",
+        ...props,
+        children: countLabel
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Avatar/Avatar.tsx"],"sourcesContent":["import {cn} from '@nlabs/utils';\nimport {createContext, useContext, useMemo, useState} from 'react';\n\nimport type {ButtonHTMLAttributes, HTMLAttributes, ImgHTMLAttributes, ReactNode, SyntheticEvent} from 'react';\n\nexport type AvatarSize = 'default' | 'sm' | 'lg';\n\ntype AvatarContextType = {\n  readonly imageLoaded: boolean;\n  readonly registerImageLoaded: (loaded: boolean) => void;\n  readonly size: AvatarSize;\n  readonly square: boolean;\n};\n\nconst AvatarContext = createContext<AvatarContextType | null>(null);\n\nconst sizeClasses: Record<AvatarSize, string> = {\n  default: 'size-8',\n  lg: 'size-10',\n  sm: 'size-6'\n};\n\nconst badgeClasses: Record<AvatarSize, string> = {\n  default: 'size-2.5 [&>svg]:size-2',\n  lg: 'size-3 [&>svg]:size-2',\n  sm: 'size-2 [&>svg]:hidden'\n};\n\nconst textClasses: Record<AvatarSize, string> = {\n  default: 'text-sm',\n  lg: 'text-sm',\n  sm: 'text-xs'\n};\n\nconst avatarClasses = 'relative inline-grid shrink-0 align-middle outline-none *:col-start-1 *:row-start-1';\nconst fallbackClasses = 'flex size-full items-center justify-center bg-zinc-100 font-medium text-zinc-600 ring-1 ring-zinc-950/5 dark:bg-zinc-800 dark:text-zinc-300 dark:ring-white/10';\n\nconst shapeClasses = {\n  round: 'rounded-full *:rounded-full',\n  square: 'rounded-lg *:rounded-lg'\n};\n\nconst useAvatarContext = () => {\n  const context = useContext(AvatarContext);\n\n  if (!context) {\n    throw new Error('Avatar components must be used within Avatar.');\n  }\n\n  return context;\n};\n\nconst useAvatarValue = (size: AvatarSize, square: boolean) => {\n  const [imageLoaded, setImageLoaded] = useState(false);\n\n  return useMemo(() => ({\n    imageLoaded,\n    registerImageLoaded: setImageLoaded,\n    size,\n    square\n  }), [imageLoaded, size, square]);\n};\n\nconst renderAvatarContent = ({\n  alt,\n  children,\n  initials,\n  onError,\n  onLoad,\n  src\n}: {\n  readonly alt: string;\n  readonly children?: ReactNode;\n  readonly initials?: ReactNode;\n  readonly onError?: (event: SyntheticEvent<HTMLImageElement>) => void;\n  readonly onLoad?: (event: SyntheticEvent<HTMLImageElement>) => void;\n  readonly src?: string;\n}) => children ?? (\n  <>\n    {src ? (\n      <AvatarImage\n        alt={alt}\n        onError={onError}\n        onLoad={onLoad}\n        src={src}\n      />\n    ) : null}\n    {initials ? <AvatarFallback>{initials}</AvatarFallback> : null}\n  </>\n);\n\ntype AvatarImageEventHandler = (event: SyntheticEvent<HTMLImageElement>) => void;\n\nexport interface AvatarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onError' | 'onLoad'> {\n  readonly alt?: string;\n  readonly initials?: ReactNode;\n  readonly onError?: AvatarImageEventHandler;\n  readonly onLoad?: AvatarImageEventHandler;\n  readonly size?: AvatarSize;\n  readonly square?: boolean;\n  readonly src?: string;\n}\n\nexport const Avatar = ({\n  alt = '',\n  children,\n  className,\n  initials,\n  onError,\n  onLoad,\n  size = 'default',\n  square = false,\n  src,\n  ...props\n}: AvatarProps) => {\n  const value = useAvatarValue(size, square);\n\n  return (\n    <AvatarContext.Provider value={value}>\n      <div\n        className={cn(\n          avatarClasses,\n          square ? shapeClasses.square : shapeClasses.round,\n          sizeClasses[size],\n          className\n        )}\n        data-size={size}\n        data-slot=\"avatar\"\n        data-square={square ? 'true' : undefined}\n        {...props}\n      >\n        {renderAvatarContent({\n          alt,\n          children,\n          initials,\n          onError,\n          onLoad,\n          src\n        })}\n      </div>\n    </AvatarContext.Provider>\n  );\n};\n\nexport const AvatarImage = ({\n  alt = '',\n  className,\n  onError,\n  onLoad,\n  ...props\n}: ImgHTMLAttributes<HTMLImageElement>) => {\n  const {registerImageLoaded} = useAvatarContext();\n\n  return (\n    <img\n      alt={alt}\n      className={cn('size-full object-cover', className)}\n      data-slot=\"avatar-image\"\n      onError={(event) => {\n        registerImageLoaded(false);\n        onError?.(event);\n      }}\n      onLoad={(event) => {\n        registerImageLoaded(true);\n        onLoad?.(event);\n      }}\n      {...props}\n    />\n  );\n};\n\nexport const AvatarFallback = ({\n  children,\n  className,\n  ...props\n}: HTMLAttributes<HTMLDivElement>) => {\n  const {imageLoaded, size} = useAvatarContext();\n\n  if (imageLoaded) {\n    return null;\n  }\n\n  return (\n    <div\n      className={cn(\n        fallbackClasses,\n        textClasses[size],\n        className\n      )}\n      data-slot=\"avatar-fallback\"\n      {...props}\n    >\n      {children}\n    </div>\n  );\n};\n\nexport const AvatarBadge = ({className, ...props}: HTMLAttributes<HTMLSpanElement>) => {\n  const {size} = useAvatarContext();\n\n  return (\n    <span\n      className={cn(\n        'absolute right-0 bottom-0 z-10 inline-flex translate-x-1/4 translate-y-1/4 items-center justify-center rounded-full bg-primary text-primary-foreground ring-2 ring-white select-none dark:ring-zinc-900',\n        badgeClasses[size],\n        className\n      )}\n      data-slot=\"avatar-badge\"\n      {...props}\n    />\n  );\n};\n\nexport interface AvatarButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onError' | 'onLoad'> {\n  readonly alt?: string;\n  readonly initials?: ReactNode;\n  readonly onError?: AvatarImageEventHandler;\n  readonly onLoad?: AvatarImageEventHandler;\n  readonly size?: AvatarSize;\n  readonly square?: boolean;\n  readonly src?: string;\n}\n\nexport const AvatarButton = ({\n  alt = '',\n  children,\n  className,\n  initials,\n  onError,\n  onLoad,\n  size = 'default',\n  square = false,\n  src,\n  type = 'button',\n  ...props\n}: AvatarButtonProps) => {\n  const value = useAvatarValue(size, square);\n\n  return (\n    <AvatarContext.Provider value={value}>\n      <button\n        className={cn(\n          avatarClasses,\n          'cursor-pointer disabled:pointer-events-none disabled:opacity-50 focus-visible:ring-[3px] focus-visible:ring-ring/50',\n          square ? shapeClasses.square : shapeClasses.round,\n          sizeClasses[size],\n          className\n        )}\n        data-size={size}\n        data-slot=\"avatar-button\"\n        data-square={square ? 'true' : undefined}\n        type={type}\n        {...props}\n      >\n        {renderAvatarContent({\n          alt,\n          children,\n          initials,\n          onError,\n          onLoad,\n          src\n        })}\n      </button>\n    </AvatarContext.Provider>\n  );\n};\n\nexport const AvatarGroup = ({className, ...props}: HTMLAttributes<HTMLDivElement>) => (\n  <div\n    className={cn(\n      'group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-white *:data-[slot=avatar-button]:ring-2 *:data-[slot=avatar-button]:ring-white dark:*:data-[slot=avatar]:ring-zinc-900 dark:*:data-[slot=avatar-button]:ring-zinc-900',\n      className\n    )}\n    data-slot=\"avatar-group\"\n    {...props}\n  />\n);\n\nexport const AvatarGroupCount = ({\n  children,\n  className,\n  ...props\n}: HTMLAttributes<HTMLDivElement>) => {\n  const countLabel: ReactNode = children ?? '+0';\n\n  return (\n    <div\n      className={cn('relative flex size-8 shrink-0 items-center justify-center rounded-full bg-zinc-100 text-sm font-medium text-zinc-600 ring-2 ring-white dark:bg-zinc-800 dark:text-zinc-300 dark:ring-zinc-900 [&>svg]:size-4', className)}\n      data-slot=\"avatar-group-count\"\n      {...props}\n    >\n      {countLabel}\n    </div>\n  );\n};\n"],"names":["cn","createContext","useContext","useMemo","useState","AvatarContext","sizeClasses","default","lg","sm","badgeClasses","textClasses","avatarClasses","fallbackClasses","shapeClasses","round","square","useAvatarContext","context","Error","useAvatarValue","size","imageLoaded","setImageLoaded","registerImageLoaded","renderAvatarContent","alt","children","initials","onError","onLoad","src","AvatarImage","AvatarFallback","Avatar","className","props","value","Provider","div","data-size","data-slot","data-square","undefined","img","event","AvatarBadge","span","AvatarButton","type","button","AvatarGroup","AvatarGroupCount","countLabel"],"mappings":"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"}

package/lib/components/Avatar/Avatar.stories.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Avatar, AvatarBadge, AvatarButton, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage } from './Avatar.js';
+const meta = {
+    argTypes: {
+        alt: {
+            control: 'text'
+        },
+        initials: {
+            control: 'text'
+        },
+        size: {
+            control: 'select',
+            options: [
+                'sm',
+                'default',
+                'lg'
+            ]
+        },
+        square: {
+            control: 'boolean'
+        },
+        src: {
+            control: 'text'
+        }
+    },
+    component: Avatar,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Avatar'
+};
+export default meta;
+export const Default = {
+    args: {
+        alt: 'Bruce Wayne',
+        initials: 'BW',
+        size: 'default',
+        square: false
+    },
+    play: interactWithCanvas
+};
+export const WithImage = {
+    args: {
+        alt: 'Selina Kyle',
+        initials: 'SK',
+        size: 'lg',
+        square: false,
+        src: 'https://i.pravatar.cc/160?img=47'
+    },
+    play: interactWithCanvas
+};
+export const WithBadge = {
+    args: {
+        alt: 'Selina Kyle',
+        initials: 'SK',
+        size: 'lg'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsxs(Avatar, {
+            ...args,
+            children: [
+                args.src ? /*#__PURE__*/ _jsx(AvatarImage, {
+                    alt: args.alt,
+                    src: args.src
+                }) : /*#__PURE__*/ _jsx(AvatarFallback, {
+                    children: args.initials
+                }),
+                /*#__PURE__*/ _jsx(AvatarBadge, {})
+            ]
+        })
+};
+export const Group = {
+    play: interactWithCanvas,
+    render: ()=>/*#__PURE__*/ _jsxs(AvatarGroup, {
+            children: [
+                /*#__PURE__*/ _jsx(Avatar, {
+                    initials: "BW"
+                }),
+                /*#__PURE__*/ _jsx(Avatar, {
+                    initials: "SK"
+                }),
+                /*#__PURE__*/ _jsx(Avatar, {
+                    initials: "DG"
+                }),
+                /*#__PURE__*/ _jsx(AvatarGroupCount, {
+                    children: "+3"
+                })
+            ]
+        })
+};
+export const Button = {
+    args: {
+        alt: 'Open profile',
+        initials: 'OP',
+        size: 'default'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsx(AvatarButton, {
+            ...args
+        })
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Badge/Badge.d.ts

@@ -0,0 +1,9 @@
+import type { ElementType, HTMLAttributes, ReactNode } from 'react';
+export type BadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost' | 'link';
+export interface BadgeProps extends HTMLAttributes<HTMLElement> {
+    readonly as?: ElementType;
+    readonly asChild?: boolean;
+    readonly children?: ReactNode;
+    readonly variant?: BadgeVariant;
+}
+export declare const Badge: ({ as, asChild, children, className, variant, ...props }: BadgeProps) => import("react").JSX.Element | null;

package/lib/components/Badge/Badge.js

@@ -0,0 +1,22 @@
+import { cn } from '@nlabs/utils';
+import { renderWithAsChild } from '../ComponentUtils/renderWithAsChild.js';
+const variantClasses = {
+    default: 'bg-primary text-primary-foreground [a&]:hover:bg-primary/90',
+    destructive: 'bg-destructive text-destructive-foreground [a&]:hover:bg-destructive/90',
+    ghost: '[a&]:hover:bg-accent [a&]:hover:text-accent-foreground',
+    link: 'text-primary underline-offset-4 [a&]:hover:underline',
+    outline: 'border-border text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground',
+    secondary: 'bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90'
+};
+export const Badge = ({ as, asChild = false, children, className, variant = 'default', ...props })=>renderWithAsChild({
+        as: as ?? 'span',
+        asChild,
+        children,
+        className: cn('inline-flex w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-full border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-[color,box-shadow] focus-visible:ring-[3px] focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3', variantClasses[variant], className),
+        ...props
+    }, {
+        'data-slot': 'badge',
+        'data-variant': variant
+    });
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Badge/Badge.stories.js

@@ -0,0 +1,53 @@
+import React from 'react';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+import { Badge } from './Badge.js';
+const meta = {
+    argTypes: {
+        as: {
+            control: 'select',
+            options: [
+                'span',
+                'a',
+                'button'
+            ]
+        },
+        children: {
+            control: 'text'
+        },
+        variant: {
+            control: 'select',
+            options: [
+                'default',
+                'secondary',
+                'destructive',
+                'outline',
+                'ghost',
+                'link'
+            ]
+        }
+    },
+    component: Badge,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Badge'
+};
+export default meta;
+export const Default = {
+    args: {
+        children: 'Stable',
+        variant: 'default'
+    },
+    play: interactWithCanvas
+};
+export const Link = {
+    args: {
+        as: 'a',
+        children: 'Read docs',
+        href: '#',
+        variant: 'link'
+    },
+    play: interactWithCanvas
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Breadcrumbs/Breadcrumbs.d.ts

@@ -0,0 +1,19 @@
+import type { AnchorHTMLAttributes, ComponentType, ReactElement, SVGProps } from 'react';
+export type BreadcrumbsVariant = 'contained' | 'chevrons' | 'full';
+export interface BreadcrumbItem {
+    readonly current?: boolean;
+    readonly href?: string;
+    readonly label: string;
+}
+export interface BreadcrumbsProps {
+    readonly className?: string;
+    readonly homeAriaLabel?: string;
+    readonly homeHref?: string;
+    readonly homeIcon?: ComponentType<SVGProps<SVGSVGElement>>;
+    readonly homeLabel?: string;
+    readonly itemClassName?: string;
+    readonly items: readonly BreadcrumbItem[];
+    readonly linkComponent?: (props: AnchorHTMLAttributes<HTMLAnchorElement>) => ReactElement;
+    readonly variant?: BreadcrumbsVariant;
+}
+export declare const Breadcrumbs: ({ className, homeAriaLabel, homeHref, homeIcon: HomeIcon, homeLabel, itemClassName, items, linkComponent: LinkComponent, variant }: BreadcrumbsProps) => import("react").JSX.Element | null;

package/lib/components/Breadcrumbs/Breadcrumbs.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '@nlabs/utils';
+import { ChevronRight, House } from 'lucide-react';
+const DefaultLink = (props)=>/*#__PURE__*/ _jsx("a", {
+        ...props
+    });
+export const Breadcrumbs = ({ className, homeAriaLabel = 'Home', homeHref = '#', homeIcon: HomeIcon = House, homeLabel = 'Home', itemClassName, items, linkComponent: LinkComponent = DefaultLink, variant = 'contained' })=>{
+    if (items.length === 0) {
+        return null;
+    }
+    const listClassName = variant === 'contained' ? 'flex space-x-4 rounded-md bg-white px-6 shadow-sm dark:bg-gray-800/50 dark:shadow-none dark:outline dark:-outline-offset-1 dark:outline-white/10' : variant === 'full' ? 'mx-auto flex w-full max-w-(--breakpoint-xl) space-x-4 px-4 sm:px-6 lg:px-8' : 'flex items-center space-x-4';
+    const navClassName = variant === 'full' ? 'flex border-b border-gray-200 bg-white dark:border-white/10 dark:bg-gray-800/50' : 'flex';
+    const homeLinkClassName = variant === 'chevrons' ? 'text-gray-400 hover:text-gray-500 dark:text-gray-500 dark:hover:text-gray-300' : 'text-gray-400 hover:text-gray-500 dark:text-gray-400 dark:hover:text-gray-300';
+    const separatorClassName = variant === 'chevrons' ? 'size-5 shrink-0 text-gray-400 dark:text-gray-500' : 'h-full w-6 shrink-0 text-gray-200 dark:text-white/10';
+    return /*#__PURE__*/ _jsx("nav", {
+        "aria-label": "Breadcrumb",
+        className: cn(navClassName, className),
+        children: /*#__PURE__*/ _jsxs("ol", {
+            role: "list",
+            className: listClassName,
+            children: [
+                /*#__PURE__*/ _jsx("li", {
+                    className: "flex",
+                    children: /*#__PURE__*/ _jsx("div", {
+                        className: "flex items-center",
+                        children: /*#__PURE__*/ _jsxs(LinkComponent, {
+                            "aria-label": homeAriaLabel,
+                            className: homeLinkClassName,
+                            href: homeHref,
+                            children: [
+                                /*#__PURE__*/ _jsx(HomeIcon, {
+                                    "aria-hidden": "true",
+                                    className: "size-5 shrink-0"
+                                }),
+                                /*#__PURE__*/ _jsx("span", {
+                                    className: "sr-only",
+                                    children: homeLabel
+                                })
+                            ]
+                        })
+                    })
+                }),
+                items.map((item, index)=>{
+                    const isCurrent = item.current ?? index === items.length - 1;
+                    return /*#__PURE__*/ _jsx("li", {
+                        className: cn('flex', itemClassName),
+                        children: /*#__PURE__*/ _jsxs("div", {
+                            className: "flex items-center",
+                            children: [
+                                /*#__PURE__*/ _jsx(ChevronRight, {
+                                    "aria-hidden": "true",
+                                    className: separatorClassName,
+                                    strokeWidth: 1.5
+                                }),
+                                item.href ? /*#__PURE__*/ _jsx(LinkComponent, {
+                                    "aria-current": isCurrent ? 'page' : undefined,
+                                    className: "ml-4 text-sm font-medium text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200",
+                                    href: item.href,
+                                    children: item.label
+                                }) : /*#__PURE__*/ _jsx("span", {
+                                    "aria-current": isCurrent ? 'page' : undefined,
+                                    className: "ml-4 text-sm font-medium text-gray-500 dark:text-gray-400",
+                                    children: item.label
+                                })
+                            ]
+                        })
+                    }, `${item.label}-${index}`);
+                })
+            ]
+        })
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/components/Breadcrumbs/Breadcrumbs.tsx"],"sourcesContent":["import {cn} from '@nlabs/utils';\nimport {ChevronRight, House} from 'lucide-react';\n\nimport type {AnchorHTMLAttributes, ComponentType, ReactElement, SVGProps} from 'react';\n\nexport type BreadcrumbsVariant = 'contained' | 'chevrons' | 'full';\n\nexport interface BreadcrumbItem {\n  readonly current?: boolean;\n  readonly href?: string;\n  readonly label: string;\n}\n\nexport interface BreadcrumbsProps {\n  readonly className?: string;\n  readonly homeAriaLabel?: string;\n  readonly homeHref?: string;\n  readonly homeIcon?: ComponentType<SVGProps<SVGSVGElement>>;\n  readonly homeLabel?: string;\n  readonly itemClassName?: string;\n  readonly items: readonly BreadcrumbItem[];\n  readonly linkComponent?: (props: AnchorHTMLAttributes<HTMLAnchorElement>) => ReactElement;\n  readonly variant?: BreadcrumbsVariant;\n}\n\nconst DefaultLink = (props: AnchorHTMLAttributes<HTMLAnchorElement>) => <a {...props} />;\n\nexport const Breadcrumbs = ({\n  className,\n  homeAriaLabel = 'Home',\n  homeHref = '#',\n  homeIcon: HomeIcon = House,\n  homeLabel = 'Home',\n  itemClassName,\n  items,\n  linkComponent: LinkComponent = DefaultLink,\n  variant = 'contained'\n}: BreadcrumbsProps) => {\n  if(items.length === 0) {\n    return null;\n  }\n\n  const listClassName = variant === 'contained'\n    ? 'flex space-x-4 rounded-md bg-white px-6 shadow-sm dark:bg-gray-800/50 dark:shadow-none dark:outline dark:-outline-offset-1 dark:outline-white/10'\n    : variant === 'full'\n      ? 'mx-auto flex w-full max-w-(--breakpoint-xl) space-x-4 px-4 sm:px-6 lg:px-8'\n      : 'flex items-center space-x-4';\n\n  const navClassName = variant === 'full'\n    ? 'flex border-b border-gray-200 bg-white dark:border-white/10 dark:bg-gray-800/50'\n    : 'flex';\n\n  const homeLinkClassName = variant === 'chevrons'\n    ? 'text-gray-400 hover:text-gray-500 dark:text-gray-500 dark:hover:text-gray-300'\n    : 'text-gray-400 hover:text-gray-500 dark:text-gray-400 dark:hover:text-gray-300';\n\n  const separatorClassName = variant === 'chevrons'\n    ? 'size-5 shrink-0 text-gray-400 dark:text-gray-500'\n    : 'h-full w-6 shrink-0 text-gray-200 dark:text-white/10';\n\n  return (\n    <nav\n      aria-label=\"Breadcrumb\"\n      className={cn(navClassName, className)}\n    >\n      <ol\n        role=\"list\"\n        className={listClassName}\n      >\n        <li className=\"flex\">\n          <div className=\"flex items-center\">\n            <LinkComponent\n              aria-label={homeAriaLabel}\n              className={homeLinkClassName}\n              href={homeHref}\n            >\n              <HomeIcon\n                aria-hidden=\"true\"\n                className=\"size-5 shrink-0\"\n              />\n              <span className=\"sr-only\">{homeLabel}</span>\n            </LinkComponent>\n          </div>\n        </li>\n\n        {items.map((item, index) => {\n          const isCurrent = item.current ?? index === items.length - 1;\n\n          return (\n            <li\n              key={`${item.label}-${index}`}\n              className={cn('flex', itemClassName)}\n            >\n              <div className=\"flex items-center\">\n                <ChevronRight\n                  aria-hidden=\"true\"\n                  className={separatorClassName}\n                  strokeWidth={1.5}\n                />\n\n                {item.href ? (\n                  <LinkComponent\n                    aria-current={isCurrent ? 'page' : undefined}\n                    className=\"ml-4 text-sm font-medium text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200\"\n                    href={item.href}\n                  >\n                    {item.label}\n                  </LinkComponent>\n                ) : (\n                  <span\n                    aria-current={isCurrent ? 'page' : undefined}\n                    className=\"ml-4 text-sm font-medium text-gray-500 dark:text-gray-400\"\n                  >\n                    {item.label}\n                  </span>\n                )}\n              </div>\n            </li>\n          );\n        })}\n      </ol>\n    </nav>\n  );\n};\n"],"names":["cn","ChevronRight","House","DefaultLink","props","a","Breadcrumbs","className","homeAriaLabel","homeHref","homeIcon","HomeIcon","homeLabel","itemClassName","items","linkComponent","LinkComponent","variant","length","listClassName","navClassName","homeLinkClassName","separatorClassName","nav","aria-label","ol","role","li","div","href","aria-hidden","span","map","item","index","isCurrent","current","strokeWidth","aria-current","undefined","label"],"mappings":";AAAA,SAAQA,EAAE,QAAO,eAAe;AAChC,SAAQC,YAAY,EAAEC,KAAK,QAAO,eAAe;AAwBjD,MAAMC,cAAc,CAACC,sBAAmD,KAACC;QAAG,GAAGD,KAAK;;AAEpF,OAAO,MAAME,cAAc,CAAC,EAC1BC,SAAS,EACTC,gBAAgB,MAAM,EACtBC,WAAW,GAAG,EACdC,UAAUC,WAAWT,KAAK,EAC1BU,YAAY,MAAM,EAClBC,aAAa,EACbC,KAAK,EACLC,eAAeC,gBAAgBb,WAAW,EAC1Cc,UAAU,WAAW,EACJ;IACjB,IAAGH,MAAMI,MAAM,KAAK,GAAG;QACrB,OAAO;IACT;IAEA,MAAMC,gBAAgBF,YAAY,cAC9B,qJACAA,YAAY,SACV,+EACA;IAEN,MAAMG,eAAeH,YAAY,SAC7B,oFACA;IAEJ,MAAMI,oBAAoBJ,YAAY,aAClC,kFACA;IAEJ,MAAMK,qBAAqBL,YAAY,aACnC,qDACA;IAEJ,qBACE,KAACM;QACCC,cAAW;QACXjB,WAAWP,GAAGoB,cAAcb;kBAE5B,cAAA,MAACkB;YACCC,MAAK;YACLnB,WAAWY;;8BAEX,KAACQ;oBAAGpB,WAAU;8BACZ,cAAA,KAACqB;wBAAIrB,WAAU;kCACb,cAAA,MAACS;4BACCQ,cAAYhB;4BACZD,WAAWc;4BACXQ,MAAMpB;;8CAEN,KAACE;oCACCmB,eAAY;oCACZvB,WAAU;;8CAEZ,KAACwB;oCAAKxB,WAAU;8CAAWK;;;;;;gBAKhCE,MAAMkB,GAAG,CAAC,CAACC,MAAMC;oBAChB,MAAMC,YAAYF,KAAKG,OAAO,IAAIF,UAAUpB,MAAMI,MAAM,GAAG;oBAE3D,qBACE,KAACS;wBAECpB,WAAWP,GAAG,QAAQa;kCAEtB,cAAA,MAACe;4BAAIrB,WAAU;;8CACb,KAACN;oCACC6B,eAAY;oCACZvB,WAAWe;oCACXe,aAAa;;gCAGdJ,KAAKJ,IAAI,iBACR,KAACb;oCACCsB,gBAAcH,YAAY,SAASI;oCACnChC,WAAU;oCACVsB,MAAMI,KAAKJ,IAAI;8CAEdI,KAAKO,KAAK;mDAGb,KAACT;oCACCO,gBAAcH,YAAY,SAASI;oCACnChC,WAAU;8CAET0B,KAAKO,KAAK;;;;uBAvBZ,GAAGP,KAAKO,KAAK,CAAC,CAAC,EAAEN,OAAO;gBA6BnC;;;;AAIR,EAAE"}

package/lib/components/Breadcrumbs/Breadcrumbs.stories.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Breadcrumbs as BreadcrumbsComponent } from './Breadcrumbs.js';
+import { interactWithCanvas } from '../../utils/storyInteractions.js';
+const meta = {
+    argTypes: {
+        variant: {
+            control: 'select',
+            options: [
+                'contained',
+                'full',
+                'chevrons'
+            ]
+        }
+    },
+    component: BreadcrumbsComponent,
+    parameters: {
+        layout: 'centered'
+    },
+    title: 'Components/Breadcrumbs'
+};
+export default meta;
+export const Contained = {
+    args: {
+        homeHref: '#',
+        items: [
+            {
+                href: '#',
+                label: 'Projects'
+            },
+            {
+                current: true,
+                href: '#',
+                label: 'Project Nero'
+            }
+        ],
+        variant: 'contained'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsx("div", {
+            className: "w-full max-w-4xl p-6",
+            children: /*#__PURE__*/ _jsx(BreadcrumbsComponent, {
+                ...args
+            })
+        })
+};
+export const Full = {
+    args: {
+        homeHref: '#',
+        items: [
+            {
+                href: '#',
+                label: 'Projects'
+            },
+            {
+                current: true,
+                href: '#',
+                label: 'Project Nero'
+            }
+        ],
+        variant: 'full'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsx("div", {
+            className: "w-full max-w-6xl p-6",
+            children: /*#__PURE__*/ _jsx(BreadcrumbsComponent, {
+                ...args
+            })
+        })
+};
+export const Chevrons = {
+    args: {
+        homeHref: '#',
+        items: [
+            {
+                href: '#',
+                label: 'Projects'
+            },
+            {
+                current: true,
+                href: '#',
+                label: 'Project Nero'
+            }
+        ],
+        variant: 'chevrons'
+    },
+    play: interactWithCanvas,
+    render: (args)=>/*#__PURE__*/ _jsx("div", {
+            className: "w-full max-w-4xl p-6",
+            children: /*#__PURE__*/ _jsx(BreadcrumbsComponent, {
+                ...args
+            })
+        })
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/components/Button/Button.d.ts

@@ -0,0 +1,25 @@
+import type { ButtonHTMLAttributes, ElementType, ReactNode, Ref } from 'react';
+import type { GothamColor } from '../../utils/colorUtils.js';
+import type { GothamSize } from '../../utils/sizeUtils.js';
+export type ButtonType = 'button' | 'reset' | 'submit';
+export type ButtonVariant = 'text' | 'solid' | 'outline' | 'contained' | 'outlined';
+export interface ButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'color' | 'onClick' | 'type'> {
+    readonly as?: ElementType;
+    readonly asChild?: boolean;
+    readonly backgroundColor?: GothamColor;
+    readonly children?: ReactNode;
+    readonly color?: GothamColor;
+    readonly hasNotification?: boolean;
+    readonly hasShadow?: boolean;
+    readonly icon?: ReactNode;
+    readonly isLoading?: boolean;
+    readonly label?: string;
+    readonly labelColor?: GothamColor;
+    readonly onClick?: (event?: unknown) => void;
+    readonly ref?: Ref<HTMLButtonElement>;
+    readonly rounded?: number;
+    readonly size?: GothamSize;
+    readonly type?: ButtonType;
+    readonly variant?: ButtonVariant;
+}
+export declare const Button: ({ as, asChild, backgroundColor, children, className, color, disabled, hasNotification, hasShadow, icon, isLoading, label, labelColor, onClick, ref, rounded, size, style, type, variant, ...props }: ButtonProps) => import("react").JSX.Element | null;