react-shadcn-kit 0.2.4 → 0.2.5

package/dist/components/composites/action-button.d.ts

@@ -0,0 +1,16 @@
+import { CustomButtonProps } from '../primitives/custom-button';
+import * as React from "react";
+interface ActionButtonProps extends CustomButtonProps {
+    action: () => Promise<{
+        error: boolean;
+        message?: string;
+    }>;
+    requireAreYouSure?: boolean;
+    areYouSureTitle?: React.ReactNode;
+    areYouSureDescription?: React.ReactNode;
+    showSuccessToast?: boolean;
+    showErrorToast?: boolean;
+}
+declare const ActionButton: React.ForwardRefExoticComponent<ActionButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { ActionButton };
+export type { ActionButtonProps };

package/dist/components/composites/sidebar-wrapper.d.ts

@@ -0,0 +1,27 @@
+import { Sidebar } from '../primitives/sidebar';
+import * as React from "react";
+export interface SidebarWrapperProps extends React.ComponentPropsWithoutRef<typeof Sidebar> {
+    /**
+     * Optional custom trigger component. If not provided, a default trigger button is rendered.
+     */
+    trigger?: React.ReactNode;
+    /**
+     * Children rendered inside the SidebarContent area.
+     */
+    children: React.ReactNode;
+}
+/**
+ * SidebarWrapper
+ *
+ * A composable wrapper around the shadcn/ui `Sidebar` components tailored for the
+ * `mcomposites` package. It provides a ready‑to‑use layout consisting of a
+ * `SidebarProvider`, a `Sidebar` with optional custom trigger, and a content
+ * area. The wrapper can be dropped into any page to instantly gain a fully
+ * functional, accessible sidebar.
+ *
+ * Example usage:
+ * ```tsx
+ * <SidebarWrapper trigger={<MyTrigger />}>...</SidebarWrapper>
+ * ```
+ */
+export declare function SidebarWrapper({ trigger, children, className, ...sidebarProps }: SidebarWrapperProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/composites/theme-toggle.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+export interface ThemeToggleProps {
+    align?: "center" | "start" | "end";
+    side?: "top" | "right" | "bottom" | "left";
+    sideOffset?: number;
+    className?: string;
+    trigger?: React.ReactNode;
+}
+export declare function ThemeToggle({ align, side, sideOffset, className, trigger, }: ThemeToggleProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/composites/user-menu.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export interface UserMenuProps {
+    user: {
+        name: string;
+        email: string;
+        avatar?: string;
+    };
+    items?: Array<{
+        label: string;
+        href?: string;
+        onClick?: () => void;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }>;
+    className?: string;
+}
+export declare function UserMenu({ user, items, className }: UserMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/data-table-column-header.d.ts

@@ -0,0 +1,7 @@
+import { Column } from '@tanstack/react-table';
+interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-faceted-filter.d.ts

@@ -0,0 +1,15 @@
+import { Column } from '@tanstack/react-table';
+import * as React from "react";
+interface DataTableFacetedFilterProps<TData, TValue> {
+    column?: Column<TData, TValue>;
+    title?: string;
+    options: {
+        label: string;
+        value: string;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }[];
+}
+export declare function DataTableFacetedFilter<TData, TValue>({ column, title, options, }: DataTableFacetedFilterProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-pagination.d.ts

@@ -0,0 +1,6 @@
+import { Table } from '@tanstack/react-table';
+interface DataTablePaginationProps<TData> {
+    table: Table<TData>;
+}
+export declare function DataTablePagination<TData>({ table }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-toolbar.d.ts

@@ -0,0 +1,20 @@
+import { Table } from '@tanstack/react-table';
+interface DataTableToolbarProps<TData> {
+    table: Table<TData>;
+    searchKey?: string;
+    placeholder?: string;
+    enableGlobalFilter?: boolean;
+    facetedFilters?: {
+        columnId: string;
+        title: string;
+        options: {
+            label: string;
+            value: string;
+            icon?: React.ComponentType<{
+                className?: string;
+            }>;
+        }[];
+    }[];
+}
+export declare function DataTableToolbar<TData>({ table, searchKey, placeholder, enableGlobalFilter, facetedFilters, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-view-options.d.ts

@@ -0,0 +1,6 @@
+import { Table } from '@tanstack/react-table';
+interface DataTableViewOptionsProps<TData> {
+    table: Table<TData>;
+}
+export declare function DataTableViewOptions<TData>({ table }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table.d.ts

@@ -0,0 +1,30 @@
+import { Row, ColumnDef } from '@tanstack/react-table';
+import * as React from "react";
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    searchKey?: string;
+    onRowClick?: (row: Row<TData>) => void;
+    renderSubComponent?: (props: {
+        row: Row<TData>;
+    }) => React.ReactNode;
+    enableRowExpansion?: boolean;
+    enableColumnSizing?: boolean;
+    enableColumnPinning?: boolean;
+    enableGlobalFilter?: boolean;
+    enableColumnOrdering?: boolean;
+    enableRowPinning?: boolean;
+    facetedFilters?: {
+        columnId: string;
+        title: string;
+        options: {
+            label: string;
+            value: string;
+            icon?: React.ComponentType<{
+                className?: string;
+            }>;
+        }[];
+    }[];
+}
+export declare function DataTable<TData, TValue>({ columns, data, searchKey, onRowClick, renderSubComponent, enableRowExpansion, enableColumnSizing, enableColumnPinning, enableGlobalFilter, enableColumnOrdering, enableRowPinning, facetedFilters, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/kanban/KanbanBoard.d.ts

@@ -0,0 +1,2 @@
+import { KanbanBoardProps, KanbanItem } from './kanban-types';
+export declare function KanbanBoard<T extends KanbanItem>({ items, columns, onItemUpdate, onItemClick, renderCard, }: KanbanBoardProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/kanban/KanbanCard.d.ts

@@ -0,0 +1,9 @@
+import { KanbanItem } from './kanban-types';
+interface Props<T extends KanbanItem> {
+    card: T;
+    onCardClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+}
+declare function KanbanCardInner<T extends KanbanItem>({ card, onCardClick, renderCard }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export declare const KanbanCard: typeof KanbanCardInner;
+export {};

package/dist/components/kanban/KanbanColumn.d.ts

@@ -0,0 +1,10 @@
+import { KanbanColumnDef, KanbanItem } from './kanban-types';
+interface Props<T extends KanbanItem> {
+    column: KanbanColumnDef;
+    items: T[];
+    onCardClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+}
+declare function KanbanColumnInner<T extends KanbanItem>({ column, items, onCardClick, renderCard, }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export declare const KanbanColumn: typeof KanbanColumnInner;
+export {};

package/dist/components/kanban/KanbanDialog.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface KanbanItemDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    children: React.ReactNode;
+    sidebar?: React.ReactNode;
+    className?: string;
+}
+export declare function KanbanItemDialog({ open, onOpenChange, title, description, children, sidebar, className, }: KanbanItemDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/kanban/kanban-types.d.ts

@@ -0,0 +1,17 @@
+export type KanbanId = string | number;
+export interface KanbanColumnDef {
+    id: string;
+    title: string;
+}
+export interface KanbanItem {
+    id: KanbanId;
+    status: string;
+    [key: string]: unknown;
+}
+export interface KanbanBoardProps<T extends KanbanItem> {
+    items: T[];
+    columns?: KanbanColumnDef[];
+    onItemUpdate: (itemId: KanbanId, newStatus: string) => void;
+    onItemClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+}

package/dist/components/kanban/kanban.d.ts

@@ -0,0 +1,45 @@
+import * as React from "react";
+export type KanbanId = string | number;
+export interface KanbanColumnDef {
+    id: string;
+    title: string;
+}
+export interface KanbanItem {
+    id: KanbanId;
+    status: string;
+    title?: string;
+    name?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+interface KanbanRootProps<T extends KanbanItem> {
+    items: T[];
+    columns?: KanbanColumnDef[];
+    onItemUpdate: (itemId: KanbanId, newStatus: string) => void;
+    onItemClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+    className?: string;
+}
+declare function KanbanRoot<T extends KanbanItem>({ items, columns, onItemUpdate, onItemClick, renderCard, className, }: KanbanRootProps<T>): import("react/jsx-runtime").JSX.Element;
+interface KanbanColumnProps<T extends KanbanItem> {
+    column: KanbanColumnDef;
+    items: T[];
+    onCardClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+    className?: string;
+}
+declare function KanbanColumn<T extends KanbanItem>({ column, items, onCardClick, renderCard, className, }: KanbanColumnProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function KanbanColumnHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function KanbanColumnBadge({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function KanbanColumnContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+interface KanbanCardProps<T extends KanbanItem> {
+    card: T;
+    onCardClick?: (item: T) => void;
+    renderCard?: (item: T) => React.ReactNode;
+    className?: string;
+}
+declare const KanbanCardInner: <T extends KanbanItem>({ card, onCardClick, renderCard, className, }: KanbanCardProps<T>) => import("react/jsx-runtime").JSX.Element;
+declare const KanbanCard: typeof KanbanCardInner;
+declare function KanbanCardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function KanbanCardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { KanbanRoot as Kanban, KanbanColumn, KanbanColumnHeader, KanbanColumnBadge, KanbanColumnContent, KanbanCard, KanbanCardTitle, KanbanCardDescription, };

package/dist/components/marketing/hero.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+interface HeroSectionProps extends React.HTMLAttributes<HTMLElement> {
+    title: string;
+    subtitle?: string;
+    ctaText?: string;
+    ctaHref?: string;
+    secondaryCtaText?: string;
+    secondaryCtaHref?: string;
+    badge?: string;
+}
+declare const HeroSection: React.ForwardRefExoticComponent<HeroSectionProps & React.RefAttributes<HTMLElement>>;
+export { HeroSection };

package/dist/components/marketing/social-proof.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface SocialProofProps extends React.HTMLAttributes<HTMLElement> {
+    logos: {
+        name: string;
+        src: string;
+    }[];
+    title?: string;
+}
+declare const SocialProof: React.ForwardRefExoticComponent<SocialProofProps & React.RefAttributes<HTMLElement>>;
+export { SocialProof };

package/dist/components/marketing/value-props.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+interface Feature {
+    name: string;
+    description: string;
+    icon?: React.ElementType;
+}
+interface ValuePropsProps extends React.HTMLAttributes<HTMLElement> {
+    features: Feature[];
+    title: string;
+    subtitle?: string;
+    badge?: string;
+}
+declare const ValueProps: React.ForwardRefExoticComponent<ValuePropsProps & React.RefAttributes<HTMLElement>>;
+export { ValueProps };

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

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare function Accordion({ ...props }: React.ComponentProps<typeof AccordionPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionItem({ className, ...props }: React.ComponentProps<typeof AccordionPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<typeof AccordionPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/primitives/action-button.d.ts

@@ -0,0 +1,10 @@
+import { ComponentProps, ReactNode } from 'react';
+import { Button } from './button';
+export declare function ActionButton({ action, requireAreYouSure, areYouSureDescription, ...props }: ComponentProps<typeof Button> & {
+    action: () => Promise<{
+        error: boolean;
+        message?: string;
+    }>;
+    requireAreYouSure?: boolean;
+    areYouSureDescription?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/primitives/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

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

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Alert({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Alert, AlertTitle, AlertDescription };

package/dist/components/primitives/aspect-ratio.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare function AspectRatio({ ...props }: React.ComponentProps<typeof AspectRatioPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { AspectRatio };

package/dist/components/primitives/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare function Avatar({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/primitives/badge-variants.d.ts

@@ -0,0 +1,3 @@
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/primitives/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { badgeVariants } from './badge-variants';
+import * as React from "react";
+interface BadgeProps extends React.ComponentProps<"span">, VariantProps<typeof badgeVariants> {
+    asChild?: boolean;
+}
+declare const Badge: React.ForwardRefExoticComponent<Omit<BadgeProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Badge };
+export type { BadgeProps };

package/dist/components/primitives/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare function Breadcrumb({ ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbLink({ asChild, className, ...props }: React.ComponentProps<"a"> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/primitives/button-group-variants.d.ts

@@ -0,0 +1,3 @@
+export declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/primitives/button-group.d.ts

@@ -0,0 +1,13 @@
+import { VariantProps } from 'class-variance-authority';
+import { buttonGroupVariants } from './button-group-variants';
+import * as React from "react";
+interface ButtonGroupProps extends React.ComponentProps<"div">, VariantProps<typeof buttonGroupVariants> {
+}
+declare const ButtonGroup: React.ForwardRefExoticComponent<Omit<ButtonGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ButtonGroupTextProps extends React.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+declare const ButtonGroupText: React.ForwardRefExoticComponent<Omit<ButtonGroupTextProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ButtonGroupSeparator: React.ForwardRefExoticComponent<Omit<import('@radix-ui/react-separator').SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText };
+export type { ButtonGroupProps, ButtonGroupTextProps };

package/dist/components/primitives/button-variants.d.ts

@@ -0,0 +1,4 @@
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;

package/dist/components/primitives/button.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import { buttonVariants } from './button-variants';
+import * as React from "react";
+interface ButtonProps extends React.ComponentProps<"button">, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Button };
+export type { ButtonProps };

package/dist/components/primitives/calendar.d.ts

@@ -0,0 +1,8 @@
+import { DayButton, DayPicker } from 'react-day-picker';
+import { Button } from '../primitives/button';
+import * as React from "react";
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
+    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+}): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
+export { Calendar, CalendarDayButton };

package/dist/components/primitives/card.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent };

package/dist/components/primitives/carousel.d.ts

@@ -0,0 +1,19 @@
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+import { Button } from '../primitives/button';
+import * as React from "react";
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React.ComponentProps<"div"> & CarouselProps): import("react/jsx-runtime").JSX.Element;
+declare function CarouselContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselItem({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): import("react/jsx-runtime").JSX.Element;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, };

package/dist/components/primitives/chart.d.ts

@@ -0,0 +1,54 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+interface RechartsPayload {
+    type?: "none";
+    dataKey?: string | number;
+    name?: string | number;
+    value?: number | string;
+    color?: string;
+    payload?: Record<string, unknown>;
+    fill?: string;
+    graphicalItemId: string;
+    [key: string]: unknown;
+}
+declare function ChartContainer({ id, className, children, config, ...props }: React.ComponentProps<"div"> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}): import("react/jsx-runtime").JSX.Element;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: RechartsPrimitive.TooltipProps<number | string, number | string> & React.ComponentProps<"div"> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+    payload?: RechartsPayload[];
+    label?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React.ComponentProps<"div"> & Pick<RechartsPrimitive.LegendProps, "verticalAlign"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+    payload?: RechartsPrimitive.LegendPayload[];
+}): import("react/jsx-runtime").JSX.Element | null;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, };

package/dist/components/primitives/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/components/primitives/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): import("react/jsx-runtime").JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/primitives/command.d.ts

@@ -0,0 +1,18 @@
+import { Command as CommandPrimitive } from 'cmdk';
+import { Dialog } from '../primitives/dialog';
+import * as React from "react";
+declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+declare function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function CommandItem({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/primitives/context-menu.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+import * as ContextMenuPrimitive from "@radix-ui/react-context-menu";
+declare function ContextMenu({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuTrigger({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuPortal({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSub({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSubContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuContent({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: React.ComponentProps<typeof ContextMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };