nucleus-core-ts 0.8.0

package/dist/fe/components/Checkbox/theme/index.d.ts

@@ -0,0 +1,218 @@
+export interface CheckboxTheme {
+    container: {
+        base: string;
+        spacing: string;
+        disabled: string;
+    };
+    wrapper: {
+        base: string;
+        gap: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+    };
+    label: {
+        base: string;
+        text: {
+            size: {
+                sm: string;
+                md: string;
+                lg: string;
+            };
+            color: {
+                light: string;
+                dark: string;
+            };
+        };
+        disabled: string;
+    };
+    checkbox: {
+        base: string;
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        border: {
+            base: string;
+            width: string;
+            color: {
+                light: string;
+                dark: string;
+            };
+            focused: string;
+        };
+        background: {
+            unchecked: {
+                light: string;
+                dark: string;
+            };
+            checked: {
+                primary: string;
+                secondary: string;
+                success: string;
+                warning: string;
+                danger: string;
+                info: string;
+            };
+        };
+        rounded: string;
+        shadow: string;
+        transition: string;
+        disabled: {
+            opacity: string;
+            cursor: string;
+        };
+    };
+    checkIcon: {
+        base: string;
+        size: {
+            sm: string;
+            md: string;
+            lg: string;
+        };
+        stroke: {
+            width: string;
+            color: string;
+        };
+    };
+    indeterminateIcon: {
+        base: string;
+        size: {
+            sm: {
+                width: string;
+                height: string;
+            };
+            md: {
+                width: string;
+                height: string;
+            };
+            lg: {
+                width: string;
+                height: string;
+            };
+        };
+        background: string;
+        rounded: string;
+    };
+    switch: {
+        track: {
+            base: string;
+            size: {
+                sm: {
+                    width: string;
+                    height: string;
+                };
+                md: {
+                    width: string;
+                    height: string;
+                };
+                lg: {
+                    width: string;
+                    height: string;
+                };
+            };
+            background: {
+                unchecked: {
+                    light: string;
+                    dark: string;
+                };
+                checked: {
+                    primary: string;
+                    secondary: string;
+                    success: string;
+                    warning: string;
+                    danger: string;
+                    info: string;
+                };
+            };
+            border: {
+                base: string;
+                color: {
+                    light: string;
+                    dark: string;
+                };
+            };
+            rounded: string;
+            shadow: string;
+            transition: string;
+            disabled: {
+                opacity: string;
+                cursor: string;
+            };
+        };
+        thumb: {
+            base: string;
+            size: {
+                sm: string;
+                md: string;
+                lg: string;
+            };
+            background: {
+                light: string;
+                dark: string;
+            };
+            shadow: string;
+            rounded: string;
+            transition: string;
+            position: {
+                sm: {
+                    unchecked: string;
+                    checked: string;
+                };
+                md: {
+                    unchecked: string;
+                    checked: string;
+                };
+                lg: {
+                    unchecked: string;
+                    checked: string;
+                };
+            };
+        };
+        icon: {
+            base: string;
+            size: {
+                sm: string;
+                md: string;
+                lg: string;
+            };
+            color: {
+                unchecked: {
+                    light: string;
+                    dark: string;
+                };
+                checked: string;
+            };
+        };
+    };
+    ripple: {
+        base: string;
+        size: string;
+        color: {
+            primary: string;
+            secondary: string;
+            success: string;
+            warning: string;
+            danger: string;
+            info: string;
+        };
+    };
+    errorText: {
+        base: string;
+        text: string;
+        color: string;
+    };
+    helperText: {
+        base: string;
+        text: string;
+        color: {
+            light: string;
+            dark: string;
+        };
+    };
+}
+export declare const checkboxTheme: CheckboxTheme;
+export declare function extendCheckboxTheme(overrides: Partial<CheckboxTheme>): CheckboxTheme;
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/Checkbox/types/index.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from "react";
+export type CheckboxVariant = "checkbox" | "switch";
+export type CheckboxSize = "sm" | "md" | "lg";
+export type CheckboxColor = "primary" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface CheckboxProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    variant?: CheckboxVariant;
+    size?: CheckboxSize;
+    color?: CheckboxColor;
+    label?: ReactNode;
+    labelPosition?: "left" | "right";
+    disabled?: boolean;
+    indeterminate?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+    required?: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    className?: string;
+    labelClassName?: string;
+    ariaLabel?: string;
+    ariaDescribedBy?: string;
+}
+export interface CheckboxIconProps {
+    checked: boolean;
+    indeterminate?: boolean;
+    size: CheckboxSize;
+    color: CheckboxColor;
+    disabled?: boolean;
+}
+export interface SwitchTrackProps {
+    checked: boolean;
+    size: CheckboxSize;
+    color: CheckboxColor;
+    disabled?: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/Checkbox/utils/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/fe/components/DataTable/DataTable.d.ts

@@ -0,0 +1,3 @@
+import type { DataTableProps } from "./types";
+export declare function DataTable<T>({ data, columns, actionColumns, keyExtractor, callbacks, config: userConfig, className, headerMiddleware, cellMiddleware, isLoading, isPending, skeletonRowCount, emptyMessage, selectionToolbar, isLoadingMore, hasMoreData, }: DataTableProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DataTable.d.ts.map

package/dist/fe/components/DataTable/components/ActionCell.d.ts

@@ -0,0 +1,10 @@
+import type { ActionColumnDefinition } from "../types";
+interface ActionCellProps<T> {
+    column: ActionColumnDefinition<T>;
+    row: T;
+    rowIndex: number;
+    width: number;
+}
+export declare function ActionCell<T>({ column, row, rowIndex, width, }: ActionCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ActionCell.d.ts.map

package/dist/fe/components/DataTable/components/DataCell.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+import type { CellRendererParams, ColumnDefinition } from "../types";
+interface DataCellProps<T> {
+    column: ColumnDefinition<T>;
+    row: T;
+    rowIndex: number;
+    width: number;
+    height?: number;
+    isHovered: boolean;
+    hasClickAction: boolean;
+    hasDoubleClickAction: boolean;
+    onClick?: () => void;
+    onDoubleClick?: () => void;
+    cellMiddleware?: (params: CellRendererParams<T>) => ReactNode;
+}
+export declare function DataCell<T>({ column, row, rowIndex, width, isHovered, hasClickAction, hasDoubleClickAction, onClick, onDoubleClick, cellMiddleware, }: DataCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DataCell.d.ts.map

package/dist/fe/components/DataTable/components/EditableCell.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { CellRendererParams, ColumnDefinition } from "../types";
+interface EditableCellProps<T> {
+    column: ColumnDefinition<T>;
+    row: T;
+    rowIndex: number;
+    width: number;
+    isHovered: boolean;
+    onSave: (newValue: string) => void;
+    cellMiddleware?: (params: CellRendererParams<T>) => ReactNode;
+}
+export declare function EditableCell<T>({ column, row, rowIndex, width, isHovered, onSave, cellMiddleware, }: EditableCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=EditableCell.d.ts.map

package/dist/fe/components/DataTable/components/EmptyState.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+interface EmptyStateProps {
+    message?: ReactNode;
+    className?: string;
+}
+export declare function EmptyState({ message, className, }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=EmptyState.d.ts.map

package/dist/fe/components/DataTable/components/HeaderCell.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+import type { ColumnDefinition, SortDirection } from "../types";
+interface HeaderCellProps<T> {
+    column: ColumnDefinition<T>;
+    width: number;
+    sortDirection: SortDirection;
+    isResizing: boolean;
+    isSorted: boolean;
+    onSort?: () => void;
+    onResizeStart: (e: React.MouseEvent | React.TouchEvent) => void;
+    onDoubleClick: () => void;
+    headerMiddleware?: (column: ColumnDefinition<T>, key: keyof T) => ReactNode;
+}
+export declare function HeaderCell<T>({ column, width, sortDirection, isResizing, isSorted, onSort, onResizeStart, onDoubleClick, headerMiddleware, }: HeaderCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=HeaderCell.d.ts.map

package/dist/fe/components/DataTable/components/InfiniteScrollTrigger.d.ts

@@ -0,0 +1,11 @@
+interface InfiniteScrollTriggerProps {
+    isLoading: boolean;
+    hasMoreData: boolean;
+    onTrigger: () => void;
+    scrollContainerRef: React.RefObject<HTMLDivElement | null>;
+    autoFetchUntilScroll?: boolean;
+    className?: string;
+}
+export declare function InfiniteScrollTrigger({ isLoading, hasMoreData, onTrigger, scrollContainerRef, autoFetchUntilScroll, className, }: InfiniteScrollTriggerProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=InfiniteScrollTrigger.d.ts.map

package/dist/fe/components/DataTable/components/LoadingSpinner.d.ts

@@ -0,0 +1,7 @@
+interface LoadingSpinnerProps {
+    text?: string;
+    className?: string;
+}
+export declare function LoadingSpinner({ text, className, }: LoadingSpinnerProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=LoadingSpinner.d.ts.map

package/dist/fe/components/DataTable/components/ResizeHandle.d.ts

@@ -0,0 +1,9 @@
+interface ResizeHandleProps {
+    type: "column" | "row";
+    isActive: boolean;
+    onResizeStart: (e: React.MouseEvent | React.TouchEvent) => void;
+    className?: string;
+}
+export declare function ResizeHandle({ type, isActive, onResizeStart, className, }: ResizeHandleProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ResizeHandle.d.ts.map

package/dist/fe/components/DataTable/components/SelectionCell.d.ts

@@ -0,0 +1,9 @@
+interface SelectionCellProps {
+    rowIndex: number;
+    isHovered: boolean;
+    isHeader?: boolean;
+    totalRows?: number;
+}
+export declare function SelectionCell({ rowIndex, isHovered, isHeader, totalRows, }: SelectionCellProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SelectionCell.d.ts.map

package/dist/fe/components/DataTable/components/SkeletonRow.d.ts

@@ -0,0 +1,9 @@
+interface SkeletonRowProps {
+    columnCount: number;
+    rowIndex: number;
+    columnWidths: number[];
+    hasActionColumn: boolean;
+}
+export declare function SkeletonRow({ columnCount, rowIndex, columnWidths, hasActionColumn, }: SkeletonRowProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SkeletonRow.d.ts.map

package/dist/fe/components/DataTable/components/SkeletonTable.d.ts

@@ -0,0 +1,10 @@
+import type { ActionColumnDefinition, ColumnDefinition } from "../types";
+interface SkeletonTableProps<T> {
+    columns: ColumnDefinition<T>[];
+    actionColumns?: ActionColumnDefinition<T>[];
+    rowCount?: number;
+    defaultColumnWidth?: number;
+}
+export declare function SkeletonTable<T>({ columns, actionColumns, rowCount, defaultColumnWidth, }: SkeletonTableProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SkeletonTable.d.ts.map

package/dist/fe/components/DataTable/components/SortIcon.d.ts

@@ -0,0 +1,9 @@
+import type { SortDirection } from "../types";
+interface SortIconProps {
+    direction: SortDirection;
+    isActive: boolean;
+    className?: string;
+}
+export declare function SortIcon({ direction, isActive, className }: SortIconProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SortIcon.d.ts.map

package/dist/fe/components/DataTable/components/TableHeader.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+import type { ActionColumnDefinition, ColumnDefinition, ColumnWidthState, SortDirection } from "../types";
+interface TableHeaderProps<T> {
+    columns: ColumnDefinition<T>[];
+    actionColumns?: ActionColumnDefinition<T>[];
+    columnWidths: ColumnWidthState;
+    sortColumnKey: keyof T | string | null;
+    sortDirection: SortDirection;
+    resizingColumn: string | null;
+    defaultColumnWidth: number;
+    onSort: (columnKey: keyof T | string) => void;
+    onResizeStart: (columnKey: string, e: React.MouseEvent | React.TouchEvent) => void;
+    onColumnDoubleClick: (columnKey: string) => void;
+    headerMiddleware?: (column: ColumnDefinition<T>, key: keyof T) => ReactNode;
+    enableSelection?: boolean;
+    totalRows?: number;
+}
+export declare function TableHeader<T>({ columns, actionColumns, columnWidths, sortColumnKey, sortDirection, resizingColumn, defaultColumnWidth, onSort, onResizeStart, onColumnDoubleClick, headerMiddleware, enableSelection, totalRows, }: TableHeaderProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=TableHeader.d.ts.map

package/dist/fe/components/DataTable/components/TableRow.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+import type { ActionColumnDefinition, CellClickParams, CellEditParams, CellRendererParams, ColumnDefinition } from "../types";
+interface TableRowProps<T> {
+    row: T;
+    rowIndex: number;
+    columns: ColumnDefinition<T>[];
+    actionColumns?: ActionColumnDefinition<T>[];
+    defaultColumnWidth: number;
+    hasClickAction: boolean;
+    hasDoubleClickAction: boolean;
+    onCellClick?: (params: CellClickParams<T>) => void;
+    onCellDoubleClick?: (params: CellClickParams<T>) => void;
+    onCellEdit?: (params: CellEditParams<T>) => void;
+    cellMiddleware?: (params: CellRendererParams<T>) => ReactNode;
+    animationDelay?: number;
+    enableSelection?: boolean;
+}
+export declare function TableRow<T>({ row, rowIndex, columns, actionColumns, defaultColumnWidth, hasClickAction, hasDoubleClickAction, onCellClick, onCellDoubleClick, onCellEdit, cellMiddleware, animationDelay, enableSelection, }: TableRowProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=TableRow.d.ts.map

package/dist/fe/components/DataTable/components/index.d.ts

@@ -0,0 +1,15 @@
+export { ActionCell } from "./ActionCell";
+export { DataCell } from "./DataCell";
+export { EditableCell } from "./EditableCell";
+export { EmptyState } from "./EmptyState";
+export { HeaderCell } from "./HeaderCell";
+export { InfiniteScrollTrigger } from "./InfiniteScrollTrigger";
+export { LoadingSpinner } from "./LoadingSpinner";
+export { ResizeHandle } from "./ResizeHandle";
+export { SelectionCell } from "./SelectionCell";
+export { SkeletonRow } from "./SkeletonRow";
+export { SkeletonTable } from "./SkeletonTable";
+export { SortIcon } from "./SortIcon";
+export { TableHeader } from "./TableHeader";
+export { TableRow } from "./TableRow";
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/DataTable/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useAutoFitColumn } from "./useAutoFitColumn";
+export { useResizeColumn } from "./useResizeColumn";
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/DataTable/hooks/useAutoFitColumn.d.ts

@@ -0,0 +1,8 @@
+interface UseAutoFitColumnOptions {
+    onAutoFit: (columnKey: string, contentWidth: number) => void;
+}
+export declare function useAutoFitColumn({ onAutoFit }: UseAutoFitColumnOptions): {
+    autoFit: (columnKey: string, tableRef: HTMLTableElement | null) => void;
+};
+export {};
+//# sourceMappingURL=useAutoFitColumn.d.ts.map

package/dist/fe/components/DataTable/hooks/useResizeColumn.d.ts

@@ -0,0 +1,12 @@
+interface UseResizeColumnOptions {
+    minWidth: number;
+    tableRef: React.RefObject<HTMLTableElement | null>;
+    onResizeStart: (columnKey: string) => void;
+    onResizeEnd: (columnKey: string, width: number) => void;
+}
+export declare function useResizeColumn({ minWidth, tableRef, onResizeStart, onResizeEnd, }: UseResizeColumnOptions): {
+    startResize: (columnKey: string, e: React.MouseEvent | React.TouchEvent) => void;
+    isJustResized: () => boolean;
+};
+export {};
+//# sourceMappingURL=useResizeColumn.d.ts.map

package/dist/fe/components/DataTable/index.d.ts

@@ -0,0 +1,6 @@
+export { DataTable } from "./DataTable";
+export { useDataTableStore } from "./store";
+export type { DataTableTheme } from "./theme";
+export { dataTableTheme, extendTheme } from "./theme";
+export type { ActionColumnDefinition, ActionRendererParams, CellClickParams, CellEditParams, CellRendererParams, ColumnDefinition, DataTableCallbacks, DataTableConfig, DataTableProps, EditConfig, EditInputType, SelectionToolbarProps, SortDirection, SortState, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/DataTable/store/index.d.ts

@@ -0,0 +1,52 @@
+import type { SortDirection } from "../types";
+type DataTableState = {
+    [key: string]: unknown;
+    sortColumnKey: string | null;
+    sortDirection: SortDirection;
+    columnWidths: Record<string, number>;
+    rowHeights: Record<number, number>;
+    resizingColumn: string | null;
+    resizingRow: number | null;
+    hoveredRow: number | null;
+    hoveredCell: {
+        row: number;
+        column: string;
+    } | null;
+    editingCell: {
+        row: number;
+        column: string;
+    } | null;
+    editValue: string;
+    isLoadingMore: boolean;
+    selectedRows: number[];
+};
+type DataTableMethods = {
+    [key: string]: unknown;
+    setSortState: (columnKey: string, direction: SortDirection) => void;
+    setColumnWidth: (columnKey: string, width: number) => void;
+    setRowHeight: (rowIndex: number, height: number) => void;
+    setResizingColumn: (columnKey: string | null) => void;
+    setResizingRow: (rowIndex: number | null) => void;
+    setHoveredRow: (rowIndex: number | null) => void;
+    setHoveredCell: (cell: {
+        row: number;
+        column: string;
+    } | null) => void;
+    setEditingCell: (cell: {
+        row: number;
+        column: string;
+    } | null) => void;
+    setEditValue: (value: string) => void;
+    startEditing: (row: number, column: string, initialValue: string) => void;
+    cancelEditing: () => void;
+    setIsLoadingMore: (isLoading: boolean) => void;
+    resetWidths: () => void;
+    autoFitColumn: (columnKey: string, contentWidth: number) => void;
+    toggleRowSelection: (rowIndex: number) => void;
+    selectAllRows: (rowCount: number) => void;
+    clearSelection: () => void;
+    isRowSelected: (rowIndex: number) => boolean;
+};
+declare const useStore: () => import("h-state").StoreType<DataTableState, DataTableMethods>;
+export { useStore as useDataTableStore };
+//# sourceMappingURL=index.d.ts.map