@tirth_jasoliya/ui 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,398 @@
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+import { ColumnDef, Table } from '@tanstack/react-table';
+import { LucideIcon } from 'lucide-react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { motion } from 'framer-motion';
+
+type Paths<T, Prefix extends string = ''> = T extends object ? {
+    [K in keyof T]: K extends string ? T[K] extends object ? Paths<T[K], `${Prefix}${K}.`> | `${Prefix}${K}` : `${Prefix}${K}` : never;
+}[keyof T] : never;
+type FilterConfig<T> = {
+    key: Paths<T>;
+    placeholder: string;
+    type?: "text" | "select" | "date" | "number";
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    width?: string;
+    icon?: LucideIcon;
+};
+type PaginationConfig = {
+    enabled: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showInfo?: boolean;
+    showPageNumbers?: boolean;
+};
+type TableSettings = {
+    hideHeader?: boolean;
+    enableSorting?: boolean;
+    toolbar?: boolean;
+    enableFiltering?: boolean;
+    enableGlobalFilter?: boolean;
+    enableColumnVisibility?: boolean;
+    enableRowSelection?: boolean;
+    enableColumnResizing?: boolean;
+    enableColumnPinning?: boolean;
+    fixedCheckboxColumn?: boolean;
+    stickyHeader?: boolean;
+    showSerialNumbers?: boolean;
+    striped?: boolean;
+    hoverable?: boolean;
+    compact?: boolean;
+    bordered?: boolean;
+    fullHeight?: boolean;
+};
+type GroupColumnDef<TData> = ColumnDef<TData> & {
+    columns?: GroupColumnDef<TData>[];
+    enablePinning?: boolean;
+    headerAlign?: 'left' | 'center' | 'right';
+};
+type DataTableProps<TData> = {
+    data: TData[];
+    columns: GroupColumnDef<TData>[];
+    filters?: FilterConfig<TData>[];
+    pagination?: PaginationConfig;
+    settings?: TableSettings;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    className?: string;
+    maxHeight?: string;
+    loading?: boolean;
+    error?: string;
+    emptyMessage?: string;
+    onRowSelectionChange?: (selectedRows: TData[]) => void;
+    onExport?: (data: TData[]) => void;
+    onRefresh?: () => void;
+    onTableReady?: (table: Table<TData>) => void;
+    children?: (table: Table<TData>) => React.ReactNode;
+};
+
+declare function DataTable<T>({ data, columns: initialColumns, filters, pagination, settings, header, footer, className, maxHeight, loading, error, emptyMessage, onRowSelectionChange, onExport, onRefresh, onTableReady, children, }: DataTableProps<T>): React$1.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React$1.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React$1.JSX.Element;
+
+interface DataTableActionBarProps<TData> extends React$1.ComponentProps<typeof motion.div> {
+    table: Table<TData> | null;
+    visible?: boolean;
+    container?: Element | DocumentFragment | null;
+    children: React$1.ReactNode;
+}
+declare function DataTableActionBar<TData>({ table, visible: visibleProp, container: containerProp, children, className, ...props }: DataTableActionBarProps<TData>): React$1.ReactPortal | null;
+interface DataTableActionBarActionProps extends React$1.ComponentProps<typeof Button> {
+    tooltip?: string;
+    isPending?: boolean;
+}
+declare function DataTableActionBarAction({ size, tooltip, isPending, disabled, className, children, ...props }: DataTableActionBarActionProps): React$1.JSX.Element;
+interface DataTableActionBarSelectionProps<TData> {
+    table: Table<TData> | null;
+}
+declare function DataTableActionBarSelection<TData>({ table }: DataTableActionBarSelectionProps<TData>): React$1.JSX.Element | null;
+
+type DataTemplateField<T> = {
+    key: keyof T;
+    label: string;
+    type?: "text" | "number" | "date" | "boolean";
+    sortable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+};
+type DataTemplateFilter<T> = {
+    key: keyof T;
+    label: string;
+    type: "text" | "select" | "date" | "number" | "boolean";
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    placeholder?: string;
+    icon?: LucideIcon;
+};
+type DataTemplatePagination = {
+    enabled: boolean;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    showInfo?: boolean;
+    showPageNumbers?: boolean;
+};
+type DataTemplateSettings = {
+    enableSorting?: boolean;
+    enableFiltering?: boolean;
+    enableGlobalSearch?: boolean;
+    enableSelection?: boolean;
+    enableExport?: boolean;
+    toolbar?: boolean;
+    selectionMode?: "single" | "multiple";
+    gridCols?: {
+        default: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        "2xl"?: number;
+    };
+    gap?: number;
+    aspectRatio?: "square" | "video" | "auto" | string;
+    minCardWidth?: number;
+    maxCardWidth?: number;
+};
+type DataTemplateType<T> = (item: T, index: number, isSelected: boolean, onToggleSelect: () => void) => ReactNode;
+type DataTemplateProps<T> = {
+    data: T[];
+    template: DataTemplateType<T>;
+    fields: DataTemplateField<T>[];
+    filters?: DataTemplateFilter<T>[];
+    pagination?: DataTemplatePagination;
+    settings?: DataTemplateSettings;
+    header?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    loading?: boolean;
+    error?: string;
+    emptyMessage?: string;
+    emptyIcon?: ReactNode;
+    onSelectionChange?: (selectedItems: T[]) => void;
+    onExport?: (data: T[]) => void;
+    onRefresh?: () => void;
+    onTemplateReady?: (controller: DataTemplateController<T>) => void;
+    children?: (controller: DataTemplateController<T>) => ReactNode;
+};
+type DataTemplateController<T> = {
+    getSelectedItems: () => T[];
+    clearSelection: () => void;
+    selectAll: () => void;
+    getFilteredData: () => T[];
+    getTotalCount: () => number;
+    getVisibleCount: () => number;
+    refresh: () => void;
+    exportData: () => void;
+};
+type DataTemplateActionBarProps<T> = {
+    controller: DataTemplateController<T>;
+    visible?: boolean;
+    container?: Element | DocumentFragment | null;
+    children: React__default.ReactNode;
+    className?: string;
+};
+type DataTemplateActionBarActionProps = {
+    tooltip?: string;
+    isPending?: boolean;
+    size?: "sm" | "icon";
+    variant?: "default" | "secondary" | "outline" | "ghost";
+    disabled?: boolean;
+    className?: string;
+    children: React__default.ReactNode;
+    onClick?: () => void;
+};
+
+declare function DataTemplate<T extends Record<string, any>>({ data, template, fields, filters, pagination, settings, header, footer, className, loading, error, emptyMessage, emptyIcon, onSelectionChange, onExport, onRefresh, onTemplateReady, children, }: DataTemplateProps<T>): React$1.JSX.Element;
+
+declare function DataTemplateActionBar<T>({ controller, visible: visibleProp, container: containerProp, children, className, ...props }: DataTemplateActionBarProps<T> & React$1.ComponentProps<typeof motion.div>): React$1.ReactPortal | null;
+declare function DataTemplateActionBarAction({ size, variant, tooltip, isPending, disabled, className, children, onClick, ...props }: DataTemplateActionBarActionProps): React$1.JSX.Element;
+interface DataTemplateActionBarSelectionProps<T> {
+    controller: DataTemplateController<T>;
+}
+declare function DataTemplateActionBarSelection<T>({ controller }: DataTemplateActionBarSelectionProps<T>): React$1.JSX.Element | null;
+
+type SpacingSize = 'none' | 'tight' | 'default' | 'loose' | 'extra-loose';
+type AppContainerProps = {
+    children: ReactNode;
+    className?: string;
+    spacing?: SpacingSize;
+    padding?: 'none' | 'tight' | 'default' | 'loose';
+};
+
+type BreadcrumbItem<TRoute extends string = string> = {
+    label: string;
+    href?: TRoute;
+};
+type AppMeta<TRoute extends string = string> = {
+    title: ReactNode;
+    description?: string;
+    breadcrumbs?: BreadcrumbItem<TRoute>[];
+    primaryActions?: ReactNode;
+    secondaryActions?: ReactNode;
+    backAction?: {
+        content?: ReactNode;
+        onClick?: () => void;
+        href?: TRoute;
+    };
+    pagination?: {
+        hasNext: boolean;
+        hasPrevious: boolean;
+        onNext?: () => void;
+        onPrevious?: () => void;
+        nextLabel?: string;
+        previousLabel?: string;
+    };
+    tabs?: {
+        id: string;
+        content: ReactNode;
+        onClick?: () => void;
+        href?: TRoute;
+        isActive?: boolean;
+    }[];
+    metadata?: {
+        label: string;
+        value: ReactNode;
+    }[];
+    status?: {
+        color: 'success' | 'warning' | 'critical' | 'info' | 'default';
+        content: ReactNode;
+    };
+};
+type AppMetaContextType<TRoute extends string = string> = {
+    meta: AppMeta<TRoute>;
+    setMeta: (meta: Partial<AppMeta<TRoute>>) => void;
+    resetMeta: () => void;
+};
+
+declare const AppMetaProvider: ({ children }: {
+    children: ReactNode;
+}) => React$1.JSX.Element;
+declare function createTypedAppMetaContext<TRoute extends string>(): {
+    TypedAppMetaProvider: ({ children }: {
+        children: ReactNode;
+    }) => React$1.JSX.Element;
+    useTypedAppMeta: () => AppMetaContextType<TRoute>;
+    TypedAppMetaContext: React$1.Context<AppMetaContextType<TRoute> | undefined>;
+};
+
+declare function createPageTemplateHook<TRoute extends string>({ useTypedAppMeta, }: {
+    useTypedAppMeta: () => AppMetaContextType<TRoute>;
+}): {
+    usePageTemplate: (options: AppMeta<TRoute>) => void;
+};
+
+type ColumnConfig$1 = {
+    content: ReactNode;
+    align?: 'left' | 'center' | 'right';
+    width?: 'auto' | 'fill';
+    className?: string;
+};
+type AppHeaderProps = {
+    className?: string;
+    columns?: [ColumnConfig$1?, ColumnConfig$1?, ColumnConfig$1?];
+    showBackButton?: boolean;
+    meta?: AppMeta;
+};
+
+type SplitRatio = "one-half" | "one-third" | "two-third" | "one-fourth" | "three-fourth" | "one-fifth" | "four-fifth";
+type SheetSide = "right" | "bottom" | "left" | "top";
+type SheetMode = "fullscreen" | "container";
+type BaseAppContentProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    variant?: "default" | "card" | "border" | "transparent";
+    header?: React__default.ReactNode;
+    footer?: React__default.ReactNode;
+    headerClassName?: string;
+    footerClassName?: string;
+    parentContainer?: boolean;
+    padding?: "none" | "tight" | "default" | "loose";
+};
+type FullLayoutProps = BaseAppContentProps & {
+    layout?: "full";
+};
+type SplitLayoutProps = BaseAppContentProps & {
+    layout: "split";
+    splitRatio?: SplitRatio;
+    reverse?: boolean;
+};
+type SheetOptions = {
+    sheetContent: React__default.ReactNode;
+    sheetWidth?: SplitRatio;
+    sheetSide?: SheetSide;
+    sheetMode?: SheetMode;
+    onSheetClose?: () => void;
+    showSheetOverlay?: boolean;
+    sheetClassName?: string;
+    isSheetOpen?: boolean;
+    onSheetOpenChange?: (open: boolean) => void;
+    sheetTrigger?: React__default.ReactNode;
+    disableOverlay?: boolean;
+};
+type WithSheetLayoutProps = BaseAppContentProps & {
+    layout: "with-sheet";
+} & SheetOptions;
+type AppContentProps = FullLayoutProps | SplitLayoutProps | WithSheetLayoutProps;
+
+type ColumnConfig = {
+    content: React.ReactNode;
+    align?: 'left' | 'center' | 'right';
+    width?: 'auto' | 'fill';
+    className?: string;
+};
+type AppFooterProps = {
+    className?: string;
+    columns?: [ColumnConfig?, ColumnConfig?, ColumnConfig?];
+    meta?: AppMeta;
+};
+
+declare function createLayoutComponents<TRoute extends string>({ useTypedAppMeta, }: {
+    useTypedAppMeta: () => AppMetaContextType<TRoute>;
+}): {
+    AppHeader: (props: Omit<AppHeaderProps, "meta">) => React$1.JSX.Element;
+    AppFooter: (props: Omit<AppFooterProps, "meta">) => React$1.JSX.Element;
+    AppContent: (props: AppContentProps) => React$1.JSX.Element;
+    AppContainer: (props: AppContainerProps) => React$1.JSX.Element;
+};
+
+type CopyToClipboardProps = {
+    text: string;
+    children?: React.ReactNode;
+    className?: string;
+    size?: "sm" | "default" | "lg" | "icon";
+    variant?: "ghost" | "outline" | "default" | "secondary" | "destructive" | "link";
+};
+type FormatINROptions = {
+    prefix?: string;
+    suffix?: string;
+    withSymbol?: boolean;
+    compact?: boolean;
+};
+type FormatDateOptions = {
+    format?: "dd-mm-yyyy" | "dd-mmm-yyyy" | "iso" | "long" | "short";
+    separator?: string;
+};
+type StatusBadgeProps = {
+    status: string | boolean | number;
+    className?: string;
+    showDot?: boolean;
+    capitalize?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'solid' | 'outline' | 'subtle';
+    customColors?: {
+        bg?: string;
+        text?: string;
+        border?: string;
+        dot?: string;
+    };
+    icon?: React.ReactNode;
+};
+declare class GeneralHelper {
+    private static currencyFormatter;
+    private static compactFormatter;
+    private static MONTH_NAMES_SHORT;
+    static copyToClipboard(text: string): Promise<void>;
+    static CopyToClipboard: ({ text, children, className, size, variant, }: CopyToClipboardProps) => React$1.JSX.Element;
+    static formatINR(amount: number, options?: FormatINROptions): string;
+    static formatDate(input: string | number | Date, options?: FormatDateOptions): string;
+    static toProperCase(text: string): string;
+    static toProperCaseAdvanced(text: string): string;
+    static StatusBadge: ({ status, className, showDot, capitalize, size, variant, customColors, icon, trueMessage, falseMessage, }: StatusBadgeProps & {
+        trueMessage?: string;
+        falseMessage?: string;
+    }) => React$1.JSX.Element;
+}
+
+export { type AppMeta, AppMetaProvider, DataTable, DataTableActionBar, DataTableActionBarAction, DataTableActionBarSelection, type DataTableProps, DataTemplate, DataTemplateActionBar, DataTemplateActionBarAction, DataTemplateActionBarSelection, type DataTemplateProps, GeneralHelper, createLayoutComponents, createPageTemplateHook, createTypedAppMetaContext };