@bigbinary/neeto-atoms 1.0.133-beta1 → 1.0.133-beta2

package/dist/components/ColorPicker/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT_PALETTE_COLORS: {
+    hex: string;
+}[];
+export declare const RECENTLY_USED_STORAGE_KEY = "recently-used-colors";
+export declare const TARGET_SIZES: {
+    readonly small: "small";
+    readonly medium: "medium";
+    readonly large: "large";
+};
+export declare const PICKER_HEIGHT: Record<string, string>;

package/dist/components/ColorPicker/hooks/useEyeDropper.d.ts

@@ -0,0 +1,15 @@
+interface EyeDropperResult {
+    sRGBHex: string;
+}
+declare global {
+    interface Window {
+        EyeDropper?: new () => {
+            open: () => Promise<EyeDropperResult>;
+        };
+    }
+}
+export declare const useEyeDropper: () => {
+    isSupported: boolean;
+    open: () => Promise<string>;
+};
+export {};

package/dist/components/ColorPicker/hooks/useRecentlyUsedColors.d.ts

@@ -0,0 +1,11 @@
+interface ColorValue {
+    hex: string;
+    rgb: string | {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    };
+}
+export declare const useRecentlyUsedColors: () => [ColorValue[], (value: ColorValue[]) => void];
+export {};

package/dist/components/ColorPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { ColorPicker } from "./ColorPicker";
+export type { ColorPickerProps, ColorPickerSize, ColorValue, PaletteColor, } from "./types";

package/dist/components/ColorPicker/types.d.ts

@@ -0,0 +1,47 @@
+import type React from "react";
+import type { PopoverContent } from "src/primitives/Popover";
+export type ColorPickerSize = "small" | "medium" | "large";
+export interface ColorValue {
+    hex: string;
+    rgb: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+}
+export interface PaletteColor {
+    hex?: string;
+    rgb?: string | {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    };
+}
+export interface ColorPickerProps {
+    /** Current color value (hex string). */
+    color?: string;
+    /** Size of the trigger target. */
+    size?: ColorPickerSize;
+    /** Callback when color changes. */
+    onChange?: (value: ColorValue) => void;
+    /** Custom palette colors. */
+    colorPalette?: PaletteColor[];
+    /** Show eye dropper button. */
+    showEyeDropper?: boolean;
+    /** Show hex value text in the trigger. */
+    showHexValue?: boolean;
+    /** Enable alpha/transparency control. */
+    showTransparencyControl?: boolean;
+    /** Show the color picker (gradient area + input). */
+    showPicker?: boolean;
+    /** Show the hex gradient picker area. */
+    showHexPicker?: boolean;
+    /** Show recently used colors section. */
+    showRecentlyUsedColors?: boolean;
+    /** Props forwarded to the Popover content. */
+    dropdownProps?: Omit<React.ComponentProps<typeof PopoverContent>, "children">;
+    /** Additional CSS class names. */
+    className?: string;
+}

package/dist/components/ColorPicker/utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Validates a hex color string (3, 4, 6, or 8 digits with optional #).
+ */
+export declare const isValidHex: (hex: string) => boolean;
+/**
+ * Parses a hex color string into RGBA components.
+ * Returns { r: 0, g: 0, b: 0, a: 1 } for invalid inputs.
+ */
+export declare const hexToRgb: (hex: string) => {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Converts a hex color to an 8-digit hex string (#RRGGBBAA).
+ */
+export declare const hexToHex8: (hex: string) => string;
+/**
+ * Converts a color value to a normalized { hex, rgb } object.
+ * Handles transparency and validity checks.
+ */
+export declare const getColor: (colorValue: string, showTransparencyControl: boolean) => {
+    hex: string;
+    rgb: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+};

package/dist/components/ColorPicker.js

@@ -0,0 +1,31 @@
+export { C as ColorPicker } from '../ColorPicker-ClnRUq9y.js';
+import 'react/jsx-runtime';
+import 'react';
+import 'react-i18next';
+import 'react-colorful';
+import '../primitives/Button.js';
+import '../utils-BJnb9o5c.js';
+import '../button-DTkEk06V.js';
+import '../index-Bo3AAQJp.js';
+import '../index-CfriMyrd.js';
+import '../index-BtkPdosV.js';
+import '../primitives/Popover.js';
+import '../index-DNzunGHb.js';
+import '../index-CiyxEyB0.js';
+import '../index-BNPynZWM.js';
+import '../index-DhnfW8wQ.js';
+import 'react-dom';
+import '../index-CSUSJzOJ.js';
+import '../index-Jr4soqx3.js';
+import '../index-zW4GjM5L.js';
+import '../index-DOzu5J1s.js';
+import '../index-XvwNqU74.js';
+import '../floating-ui.react-dom-BtFUJRfb.js';
+import '../floating-ui.utils.dom-Bw_Rc4bg.js';
+import '../index-BYZaLNq1.js';
+import '../index-fV_U4ZJM.js';
+import '../index-yFgkK_AM.js';
+import '../index-Cor698lu.js';
+import '../chevron-down-BNi0ntys.js';
+import '../createLucideIcon-C8ycilSN.js';
+//# sourceMappingURL=ColorPicker.js.map

package/dist/components/ColorPicker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorPicker.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,2 @@
+import type { DataTableProps } from "./types";
+export declare const DataTable: <TData>({ columns, data, getRowId: getRowIdProp, sorting: sortingProp, onSortingChange: onSortingChangeProp, onSort: onSortProp, enableSorting, enableURLSort, totalCount, pageSize, currentPage: currentPageProp, onPageChange: onPageChangeProp, enableURLPagination, enableRowSelection: enableRowSelectionProp, selectedRowKeys, onRowSelect, bulkSelectAllRowsProps, enableColumnResize, persistColumnSizing, columnSizing: columnSizingProp, onColumnSizingChange: onColumnSizingChangeProp, enableColumnFreeze, columnPinning: columnPinningProp, onColumnPinningChange: onColumnPinningChangeProp, localStorageKeyPrefix, columnVisibility: columnVisibilityProp, onColumnVisibilityChange: onColumnVisibilityChangeProp, onColumnHide: onColumnHideProp, enableColumnReorder, columnOrder: columnOrderProp, onColumnOrderChange: onColumnOrderChangeProp, enableAddColumn, onColumnAdd, onColumnDelete, onColumnUpdate, onMoreActionClick, enableHeaderMenu, loading, bordered, className, emptyMessage, onRowClick, allowRowClick, renderBody, }: DataTableProps<TData>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { BulkSelectAllRowsProps } from "../types";
+interface BulkSelectCalloutProps {
+    bulkSelectAllRowsProps: BulkSelectAllRowsProps;
+    isAllPageRowsSelected: boolean;
+    isBulkAllSelected: boolean;
+    onBulkSelectAll: () => void;
+    onClearBulkSelection: () => void;
+}
+export declare const BulkSelectCallout: ({ bulkSelectAllRowsProps, isAllPageRowsSelected, isBulkAllSelected, onBulkSelectAll, onClearBulkSelection, }: BulkSelectCalloutProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,7 @@
+interface DataTablePaginationProps {
+    currentPage: number;
+    pageCount: number;
+    onPageChange: (page: number) => void;
+}
+export declare const DataTablePagination: ({ currentPage, pageCount, onPageChange, }: DataTablePaginationProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,7 @@
+import type React from "react";
+interface EmptyStateProps {
+    colSpan: number;
+    message?: string | React.ReactNode;
+}
+export declare const EmptyState: ({ colSpan, message }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+import type { Column } from "@tanstack/react-table";
+interface HeaderCellMenuProps<TData> {
+    column: Column<TData, unknown>;
+    enableAddColumn?: boolean;
+    enableColumnFreeze?: boolean;
+    isColumnPinned?: boolean;
+    canMoveLeft?: boolean;
+    canMoveRight?: boolean;
+    onSort?: (columnId: string, desc: boolean) => void;
+    onHideColumn?: (columnId: string) => void;
+    onTogglePin?: (columnId: string) => void;
+    onAddColumn?: (position: number) => void;
+    onDeleteColumn?: (columnId: string) => void;
+    onMoveColumn?: (columnId: string, direction: -1 | 1) => void;
+    onMoreActionClick?: (actionType: string, columnId: string) => void;
+    columnIndex: number;
+}
+export declare const HeaderCellMenu: <TData>({ column, enableAddColumn, enableColumnFreeze, isColumnPinned, canMoveLeft, canMoveRight, onSort, onHideColumn, onTogglePin, onAddColumn, onDeleteColumn, onMoveColumn, onMoreActionClick, columnIndex, }: HeaderCellMenuProps<TData>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,6 @@
+import type { Column } from "@tanstack/react-table";
+interface HeaderDescriptionProps<TData> {
+    column: Column<TData, unknown>;
+}
+export declare const HeaderDescription: <TData>({ column, }: HeaderDescriptionProps<TData>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1 @@
+export declare const LoadingOverlay: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { Header } from "@tanstack/react-table";
+interface ResizeHandleProps<TData> {
+    header: Header<TData, unknown>;
+    onReset?: (columnId: string) => void;
+}
+export declare const ResizeHandle: <TData>({ header, onReset, }: ResizeHandleProps<TData>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,7 @@
+interface SelectionCheckboxProps {
+    checked: boolean | "indeterminate";
+    onCheckedChange: (checked: boolean, shiftKey: boolean) => void;
+    ariaLabel?: string;
+}
+export declare const SelectionCheckbox: ({ checked, onCheckedChange, ariaLabel, }: SelectionCheckboxProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import type { Column } from "@tanstack/react-table";
+interface SortIndicatorProps<TData> {
+    column: Column<TData, unknown>;
+}
+export declare const SortIndicator: <TData>({ column, }: SortIndicatorProps<TData>) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+interface SortableColumnLabelProps {
+    id: string;
+    disabled: boolean;
+    children: ReactNode;
+}
+export declare const SortableColumnLabel: ({ id, disabled, children, }: SortableColumnLabelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+export declare const DEFAULT_PAGE_SIZE = 30;
+export declare const URL_SORT_PARAMS: {
+    readonly SORT_BY: "sort_by";
+    readonly ORDER_BY: "order_by";
+};
+export declare const URL_PAGE_PARAM = "page";
+export declare const SORT_DIRECTIONS: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+export declare const STORAGE_KEY_PREFIX = "NEETOUI";
+export declare const STORAGE_KEY_SUFFIX = "FIXED_COLUMNS";
+export declare const COLUMN_SIZING_STORAGE_KEY_SUFFIX = "COLUMN_SIZING";

package/dist/components/DataTable/hooks/useColumnDrag.d.ts

@@ -0,0 +1,11 @@
+import { type CollisionDetection, type DragEndEvent } from "@dnd-kit/core";
+interface UseColumnDragOptions {
+    availableColumnIds: string[];
+    onReorder: (fromId: string, toId: string, availableColumnIds: string[]) => void;
+}
+export declare const useColumnDrag: ({ availableColumnIds, onReorder, }: UseColumnDragOptions) => {
+    sensors: import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+    collisionDetection: CollisionDetection;
+    handleDragEnd: ({ active, over }: DragEndEvent) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useColumnOrdering.d.ts

@@ -0,0 +1,13 @@
+import type { ColumnOrderState, OnChangeFn } from "@tanstack/react-table";
+interface UseColumnOrderingOptions {
+    enabled?: boolean;
+    columnOrder?: ColumnOrderState;
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+}
+export declare const useColumnOrdering: ({ enabled, columnOrder: controlledOrder, onColumnOrderChange: controlledOnChange, }: UseColumnOrderingOptions) => {
+    columnOrder: ColumnOrderState;
+    onColumnOrderChange: OnChangeFn<ColumnOrderState>;
+    moveColumn: (columnId: string, direction: -1 | 1, availableColumnIds?: string[]) => void;
+    reorderColumn: (fromId: string, toId: string, availableColumnIds?: string[]) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useColumnPinning.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnPinningState, OnChangeFn } from "@tanstack/react-table";
+interface UseColumnPinningOptions {
+    enabled?: boolean;
+    columnPinning?: ColumnPinningState;
+    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+    localStorageKeyPrefix?: string;
+    initialPinnedColumns?: string[];
+}
+export declare const useColumnPinning: ({ enabled, columnPinning: controlledPinning, onColumnPinningChange: controlledOnChange, localStorageKeyPrefix, initialPinnedColumns, }: UseColumnPinningOptions) => {
+    columnPinning: ColumnPinningState;
+    onColumnPinningChange: OnChangeFn<ColumnPinningState>;
+    toggleColumnPin: (columnId: string) => void;
+    isColumnPinned: (columnId: string) => boolean;
+};
+export {};

package/dist/components/DataTable/hooks/useColumnResize.d.ts

@@ -0,0 +1,18 @@
+import type { ColumnSizingState, Table, VisibilityState } from "@tanstack/react-table";
+interface UseColumnResizeOptions<TData> {
+    enabled: boolean;
+    table: Table<TData>;
+    columnVisibility: VisibilityState;
+    hasSelectionColumn: boolean;
+    scrollContainerRef: React.RefObject<HTMLDivElement | null>;
+    columnSizing: ColumnSizingState;
+    setColumnSizing: (updater: ColumnSizingState | ((old: ColumnSizingState) => ColumnSizingState)) => void;
+    initialUserResizedIds?: string[];
+    onUserResize?: (sizing: ColumnSizingState, userResizedIds: Set<string>) => void;
+}
+export declare const useColumnResize: <TData>({ enabled, table, columnVisibility, hasSelectionColumn, scrollContainerRef, columnSizing, setColumnSizing, initialUserResizedIds, onUserResize, }: UseColumnResizeOptions<TData>) => {
+    trackUserResize: (updaterOrValue: ColumnSizingState | ((old: ColumnSizingState) => ColumnSizingState)) => void;
+    lastDataColumnId: string | undefined;
+    clearUserResized: (columnId: string) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useColumnSizingPersistence.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnSizingState, OnChangeFn, Updater } from "@tanstack/react-table";
+interface UseColumnSizingPersistenceOptions {
+    enabled?: boolean;
+    persistToLocalStorage?: boolean;
+    columnSizing?: ColumnSizingState;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    localStorageKeyPrefix?: string;
+}
+export declare const useColumnSizingPersistence: ({ enabled, persistToLocalStorage, columnSizing: controlledSizing, onColumnSizingChange: controlledOnChange, localStorageKeyPrefix, }: UseColumnSizingPersistenceOptions) => {
+    columnSizing: ColumnSizingState;
+    setColumnSizing: (updaterOrValue: Updater<ColumnSizingState>) => void;
+    initialUserResizedIds: string[];
+    persistUserResizedSizing: (sizingState: ColumnSizingState, userResizedIds: Set<string>) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useColumnVisibility.d.ts

@@ -0,0 +1,14 @@
+import type { OnChangeFn, VisibilityState } from "@tanstack/react-table";
+interface UseColumnVisibilityOptions {
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    onColumnHide?: (columnId: string) => void;
+}
+export declare const useColumnVisibility: ({ columnVisibility: controlledVisibility, onColumnVisibilityChange: controlledOnChange, onColumnHide, }: UseColumnVisibilityOptions) => {
+    columnVisibility: VisibilityState;
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+    hideColumn: (columnId: string) => void;
+    showColumn: (columnId: string) => void;
+    toggleColumnVisibility: (columnId: string) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useTablePagination.d.ts

@@ -0,0 +1,18 @@
+interface UseTablePaginationOptions {
+    totalCount?: number;
+    pageSize?: number;
+    currentPage?: number;
+    onPageChange?: (page: number) => void;
+    enableURLPagination?: boolean;
+}
+export declare const useTablePagination: ({ totalCount, pageSize, currentPage: controlledPage, onPageChange: controlledOnPageChange, enableURLPagination, }: UseTablePaginationOptions) => {
+    currentPage: number;
+    pageCount: number;
+    pageSize: number;
+    paginationState: {
+        pageIndex: number;
+        pageSize: number;
+    };
+    onPageChange: (page: number) => void;
+};
+export {};

package/dist/components/DataTable/hooks/useTableSelection.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnDef, OnChangeFn, Row, RowSelectionState } from "@tanstack/react-table";
+interface UseTableSelectionOptions<TData> {
+    enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
+    selectedRowKeys?: string[];
+    onRowSelect?: (keys: string[], rows: TData[]) => void;
+    data: TData[];
+    getRowId: (row: TData) => string;
+}
+export declare const useTableSelection: <TData>({ enableRowSelection, selectedRowKeys, onRowSelect, data, getRowId, }: UseTableSelectionOptions<TData>) => {
+    rowSelection: RowSelectionState;
+    onRowSelectionChange: OnChangeFn<RowSelectionState>;
+    selectionColumn: ColumnDef<TData, unknown> | null;
+    enableRowSelection: boolean | ((row: Row<TData>) => boolean);
+};
+export {};

package/dist/components/DataTable/hooks/useTableSort.d.ts

@@ -0,0 +1,16 @@
+import type { SortingState, OnChangeFn } from "@tanstack/react-table";
+export interface SortInfo {
+    field: string;
+    order: "ascend" | "descend";
+}
+interface UseTableSortOptions {
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
+    onSort?: (sort: SortInfo | null) => void;
+    enableURLSort?: boolean;
+}
+export declare const useTableSort: ({ sorting: controlledSorting, onSortingChange: controlledOnSortingChange, onSort, enableURLSort, }: UseTableSortOptions) => {
+    sorting: SortingState;
+    onSortingChange: OnChangeFn<SortingState>;
+};
+export {};

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

@@ -0,0 +1,9 @@
+export { DataTable } from "./DataTable";
+export { useTableSort } from "./hooks/useTableSort";
+export type { SortInfo } from "./hooks/useTableSort";
+export { useTablePagination } from "./hooks/useTablePagination";
+export { useTableSelection } from "./hooks/useTableSelection";
+export { useColumnPinning } from "./hooks/useColumnPinning";
+export { useColumnVisibility } from "./hooks/useColumnVisibility";
+export { useColumnOrdering } from "./hooks/useColumnOrdering";
+export type { DataTableProps, BulkSelectAllRowsProps, DataTableColumnMeta, ColumnMoreAction, } from "./types";

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

@@ -0,0 +1,74 @@
+import type { ColumnDef, ColumnOrderState, ColumnPinningState, ColumnSizingState, OnChangeFn, Row, SortingState, VisibilityState } from "@tanstack/react-table";
+import type { SortInfo } from "./hooks/useTableSort";
+export interface BulkSelectAllRowsProps {
+    selectAllRowMessage: string;
+    selectAllRowButtonLabel: string;
+    setBulkSelectedAllRows: (value: boolean) => void;
+    allRowsSelectedMessage?: string;
+    clearSelectionButtonLabel?: string;
+}
+export interface ColumnMoreAction {
+    type: string;
+    label: string;
+    icon?: React.ComponentType<{
+        className?: string;
+        size?: number;
+    }>;
+}
+export interface DataTableColumnMeta {
+    enableDelete?: boolean;
+    moreActions?: ColumnMoreAction[];
+    description?: string;
+    align?: "left" | "center" | "right";
+}
+export interface DataTableProps<TData> {
+    columns: ColumnDef<TData, unknown>[];
+    data?: TData[];
+    getRowId?: (row: TData) => string;
+    sorting?: SortingState;
+    onSortingChange?: OnChangeFn<SortingState>;
+    onSort?: (sort: SortInfo | null) => void;
+    enableSorting?: boolean;
+    enableURLSort?: boolean;
+    totalCount?: number;
+    pageSize?: number;
+    currentPage?: number;
+    onPageChange?: (page: number) => void;
+    enableURLPagination?: boolean;
+    enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
+    selectedRowKeys?: string[];
+    onRowSelect?: (keys: string[], rows: TData[]) => void;
+    bulkSelectAllRowsProps?: BulkSelectAllRowsProps;
+    enableColumnResize?: boolean;
+    persistColumnSizing?: boolean;
+    columnSizing?: ColumnSizingState;
+    onColumnSizingChange?: OnChangeFn<ColumnSizingState>;
+    /**
+     * Opts the table into column freezing. Defaults to `false`: it gates the
+     * "Freeze column" header-menu item, the `columnPinning` state and its
+     * persistence, so pinning is inert unless this is set.
+     */
+    enableColumnFreeze?: boolean;
+    columnPinning?: ColumnPinningState;
+    onColumnPinningChange?: OnChangeFn<ColumnPinningState>;
+    localStorageKeyPrefix?: string;
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
+    onColumnHide?: (columnId: string) => void;
+    enableColumnReorder?: boolean;
+    columnOrder?: ColumnOrderState;
+    onColumnOrderChange?: OnChangeFn<ColumnOrderState>;
+    enableAddColumn?: boolean;
+    onColumnAdd?: (position: number) => void;
+    onColumnDelete?: (columnId: string) => void;
+    onColumnUpdate?: (columns: ColumnDef<TData, unknown>[]) => void;
+    onMoreActionClick?: (actionType: string, columnId: string) => void;
+    enableHeaderMenu?: boolean;
+    loading?: boolean;
+    bordered?: boolean;
+    className?: string;
+    emptyMessage?: string | React.ReactNode;
+    onRowClick?: (event: React.MouseEvent, row: TData, index: number) => void;
+    allowRowClick?: boolean;
+    renderBody?: () => React.ReactNode;
+}

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

@@ -0,0 +1,24 @@
+import type { ColumnSizingState, SortingState, RowSelectionState } from "@tanstack/react-table";
+export declare const readSortFromURL: (search: string) => SortingState;
+export declare const buildSortQuery: (search: string, sorting: SortingState) => string;
+export declare const readPageFromURL: () => number;
+export declare const writePageToURL: (page: number) => void;
+export declare const keysToRowSelection: (keys: string[]) => RowSelectionState;
+export declare const rowSelectionToKeys: (selection: RowSelectionState) => string[];
+export declare const hashPathname: () => string;
+export declare const getStorageKey: (prefix?: string, suffix?: string) => string;
+export declare const readFromLocalStorage: (key: string) => string[];
+export declare const writeToLocalStorage: (key: string, value: string[]) => void;
+export declare const readSizingFromLocalStorage: (key: string) => ColumnSizingState;
+export declare const writeSizingToLocalStorage: (key: string, value: ColumnSizingState) => void;
+export declare const getResizeColumnStyle: ({ size, isSelectionCol, isLastDataCol, enableResize, pinned, pinnedStart, pinnedEnd, percentageWidth, }: {
+    size: number;
+    isSelectionCol: boolean;
+    isLastDataCol: boolean;
+    enableResize: boolean;
+    pinned: false | "left" | "right";
+    pinnedStart?: number;
+    pinnedEnd?: number;
+    percentageWidth?: string;
+}) => React.CSSProperties;
+export declare const getPageNumbers: (current: number, total: number) => (number | "ellipsis")[];

package/dist/components/DataTable.js

@@ -0,0 +1,55 @@
+export { D as DataTable, u as useColumnOrdering, a as useColumnPinning, b as useColumnVisibility, c as useTablePagination, d as useTableSelection, e as useTableSort } from '../DataTable-DKYkrFfk.js';
+import 'react/jsx-runtime';
+import 'react';
+import 'react-dom';
+import 'ramda';
+import '../primitives/Table.js';
+import '../utils-BJnb9o5c.js';
+import '../hyphenize-TRhMI0tl.js';
+import 'react-router-dom';
+import 'react-i18next';
+import '../primitives/Checkbox.js';
+import '../check-Cpkv29p1.js';
+import '../createLucideIcon-C8ycilSN.js';
+import '../index-BtkPdosV.js';
+import '../index-CiyxEyB0.js';
+import '../index-DNzunGHb.js';
+import '../index-Cor698lu.js';
+import '../index-DOzu5J1s.js';
+import '../index-30QpKM0j.js';
+import '../index-BYZaLNq1.js';
+import '../index-yFgkK_AM.js';
+import '../index-DhnfW8wQ.js';
+import '../primitives/Spinner.js';
+import '../loader-circle-DycHUAWN.js';
+import '../primitives/Button.js';
+import '../button-DTkEk06V.js';
+import '../index-Bo3AAQJp.js';
+import '../index-CfriMyrd.js';
+import '../primitives/Pagination.js';
+import '../chevron-left-BDoT8E2-.js';
+import '../ellipsis-lb8Ws6br.js';
+import '../chevron-right-DQnrO-ek.js';
+import '../primitives/DropdownMenu.js';
+import '../index-BQtGUR27.js';
+import '../index-Dd1i1d2M.js';
+import '../index-d0BBQf5t.js';
+import '../index-BNPynZWM.js';
+import '../index-CSUSJzOJ.js';
+import '../index-Jr4soqx3.js';
+import '../index-zW4GjM5L.js';
+import '../index-XvwNqU74.js';
+import '../floating-ui.react-dom-BtFUJRfb.js';
+import '../floating-ui.utils.dom-Bw_Rc4bg.js';
+import '../index-fV_U4ZJM.js';
+import '../index-DT56XkyA.js';
+import '../Button-ZssOVkG0.js';
+import '../renderIcon-C6twJSqH.js';
+import '../primitives/Tooltip.js';
+import '../tooltip-BUYRFmEv.js';
+import '../index-CSggBaQF.js';
+import '../Popover-BHGvcdV2.js';
+import '../primitives/HoverCard.js';
+import '../Typography-CmILccNh.js';
+import '../info-BlwkmMZr.js';
+//# sourceMappingURL=DataTable.js.map

package/dist/components/DataTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataTable.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { DatePickerProps } from "./types";
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLDivElement>>;
+export { DatePicker };

package/dist/components/DatePicker/DatePickerField.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+interface DatePickerFieldProps {
+    disabled: boolean;
+    error: React.ReactNode | undefined;
+    className?: string;
+    label?: React.ReactNode;
+    required?: boolean;
+    helpText?: React.ReactNode;
+    labelProps?: Record<string, unknown>;
+    errorId: string;
+    helpTextId: string;
+    errorTestId?: string;
+    children: React.ReactNode;
+}
+export declare const DatePickerField: React.ForwardRefExoticComponent<DatePickerFieldProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/DatePicker/DatePickerFooter.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+interface DatePickerFooterProps {
+    showTime?: boolean;
+    needConfirm?: boolean;
+    timezone?: string;
+    onTimezoneChange?: (tz: string | undefined) => void;
+    nowDisabled?: boolean;
+    onNow: () => void;
+    onOk: () => void;
+    okLabel?: string;
+    className?: string;
+}
+declare const DatePickerFooter: React.FC<DatePickerFooterProps>;
+export { DatePickerFooter };