brd-ui-kit 0.1.72 → 0.1.75

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

@@ -1,9 +1,30 @@
-import { ColumnDef, ColumnFiltersState, PaginationState, SortingState, Updater } from '@tanstack/react-table';
+import { ColumnDef, ColumnFiltersState, PaginationState, Row, RowSelectionState, SortingState, Table as TanStackTable, Updater, VisibilityState } from '@tanstack/react-table';
+import * as React from "react";
+export type DataTableColumnMeta<TData = unknown> = {
+    className?: string;
+    headClassName?: string;
+    cellClassName?: string;
+    style?: React.CSSProperties;
+    headStyle?: React.CSSProperties;
+    cellStyle?: React.CSSProperties;
+    editable?: boolean;
+    editKey?: Extract<keyof TData, string>;
+    editComponent?: "input" | "textarea";
+    editClassName?: string;
+    editPlaceholder?: string;
+    getEditValue?: (row: TData) => string;
+};
 export interface DataTableProps<TData, TValue> {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
+    emptyState?: React.ReactNode;
     sorting?: SortingState;
     columnFilters?: ColumnFiltersState;
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (updater: Updater<VisibilityState>) => void;
+    rowSelection?: RowSelectionState;
+    onRowSelectionChange?: (updater: Updater<RowSelectionState>) => void;
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
     pagination?: PaginationState;
     globalFilter?: string;
     setGlobalFilter?: (value: string) => void;
@@ -12,13 +33,23 @@ export interface DataTableProps<TData, TValue> {
     onPaginationChange?: (updater: Updater<PaginationState>) => void;
     rowClickable?: boolean;
     onRowClick?: (row: TData) => void;
+    onTableChange?: (table: TanStackTable<TData>) => void;
+    editableRowId?: string | null;
+    editingValues?: Record<string, string>;
+    onEditingValuesChange?: (updater: Updater<Record<string, string>>) => void;
+    autoResetPageIndex?: boolean;
     className?: {
         className?: string;
         tableClassName?: string;
         headerClassName?: string;
         rowClassName?: string;
+        headRowClassName?: string;
+        bodyRowClassName?: string;
+        editingRowClassName?: string;
+        emptyRowClassName?: string;
         cellClassName?: string;
         headCellClassName?: string;
+        emptyCellClassName?: string;
     };
 }
-export declare function BasicTable<TData, TValue>({ columns, data, sorting, columnFilters, pagination, globalFilter, setGlobalFilter, onSortingChange, onColumnFiltersChange, onPaginationChange, rowClickable, onRowClick, className, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function BasicTable<TData, TValue>({ columns, data, emptyState, sorting, columnFilters, columnVisibility, onColumnVisibilityChange, rowSelection, onRowSelectionChange, getRowId, pagination, globalFilter, setGlobalFilter, onSortingChange, onColumnFiltersChange, onPaginationChange, rowClickable, onRowClick, onTableChange, editableRowId, editingValues, onEditingValuesChange, autoResetPageIndex, className, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

package/dist/components/basic-table/index.d.ts

@@ -1 +1 @@
-export { BasicTable, type DataTableProps } from './basic-table';
+export { BasicTable, type DataTableColumnMeta, type DataTableProps } from './basic-table';

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

@@ -0,0 +1,23 @@
+import { ColumnDef, Row } from '@tanstack/react-table';
+import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
+import * as React from "react";
+type DataTableActionsColumnOptions<TData> = {
+    id?: string;
+    header?: ColumnDef<TData>["header"];
+    renderCell?: (ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => React.ReactNode;
+    trigger?: (ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => React.ReactNode;
+    menuItems?: DropdownMenuConfigNode[] | ((ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => DropdownMenuConfigNode[]);
+    align?: "start" | "center" | "end";
+    ariaLabel?: string;
+};
+export declare function createDataTableActionsColumn<TData>(options?: DataTableActionsColumnOptions<TData>): ColumnDef<TData>;
+export type { DataTableActionsColumnOptions };

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

@@ -0,0 +1,20 @@
+import { Row, Table } from '@tanstack/react-table';
+import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
+import * as React from "react";
+type DataTableBulkActionsContext<TData> = {
+    table: Table<TData>;
+    selectedRows: Row<TData>[];
+    selectedData: TData[];
+    count: number;
+    clearSelection: () => void;
+};
+type DataTableBulkActionsProps<TData> = {
+    table: Table<TData>;
+    children?: (ctx: DataTableBulkActionsContext<TData>) => React.ReactNode;
+    trigger?: React.ReactNode | ((ctx: DataTableBulkActionsContext<TData>) => React.ReactNode);
+    menuItems?: DropdownMenuConfigNode[] | ((ctx: DataTableBulkActionsContext<TData>) => DropdownMenuConfigNode[]);
+    onDeleteSelected?: (ctx: DataTableBulkActionsContext<TData>) => void;
+};
+declare function DataTableBulkActions<TData>({ table, children, trigger, menuItems, onDeleteSelected, }: DataTableBulkActionsProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export { DataTableBulkActions };
+export type { DataTableBulkActionsContext, DataTableBulkActionsProps };

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

@@ -0,0 +1,17 @@
+import { Table, Updater, VisibilityState } from '@tanstack/react-table';
+import * as React from "react";
+type DataTableColumnVisibilityProps<TData> = {
+    table: Table<TData>;
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (updater: Updater<VisibilityState>) => void;
+    triggerLabel?: string;
+    trigger?: React.ReactNode;
+    menuLabel?: string;
+    includeColumnIds?: string[];
+    excludeColumnIds?: string[];
+    align?: "start" | "center" | "end";
+    dropdownWidthClassName?: string;
+};
+declare function DataTableColumnVisibility<TData>({ table, columnVisibility, onColumnVisibilityChange, triggerLabel, trigger, menuLabel, includeColumnIds, excludeColumnIds, align, dropdownWidthClassName, }: DataTableColumnVisibilityProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export { DataTableColumnVisibility };
+export type { DataTableColumnVisibilityProps };

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

@@ -0,0 +1,12 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { DataTableColumnMeta } from '../basic-table';
+type DataTableEditableColumnOptions<TData> = {
+    editKey?: DataTableColumnMeta<TData>["editKey"];
+    editComponent?: DataTableColumnMeta<TData>["editComponent"];
+    editClassName?: DataTableColumnMeta<TData>["editClassName"];
+    editPlaceholder?: DataTableColumnMeta<TData>["editPlaceholder"];
+    getEditValue?: DataTableColumnMeta<TData>["getEditValue"];
+};
+declare function withDataTableEditableColumn<TData, TValue>(column: ColumnDef<TData, TValue>, options?: DataTableEditableColumnOptions<TData>): ColumnDef<TData, TValue>;
+export { withDataTableEditableColumn };
+export type { DataTableEditableColumnOptions };

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

@@ -0,0 +1,12 @@
+import { Table } from '@tanstack/react-table';
+import { Input } from '../ui/input';
+import * as React from "react";
+type DataTableFilterProps<TData> = {
+    table: Table<TData>;
+    searchableColumnIds?: string[];
+    placeholder?: string;
+    inputProps?: Omit<React.ComponentProps<typeof Input>, "value" | "onChange">;
+};
+declare function DataTableFilter<TData>({ table, searchableColumnIds, placeholder, inputProps, }: DataTableFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
+export { DataTableFilter };
+export type { DataTableFilterProps };

package/dist/components/data-table/data-table-row-actions-column.d.ts

@@ -0,0 +1,53 @@
+import { ColumnDef, Row } from '@tanstack/react-table';
+import { IconName } from 'phosphor-strokes-icons/by-name';
+import * as React from "react";
+type DataTableRowActionContext<TData> = {
+    row: Row<TData>;
+    data: TData;
+};
+type DataTableRowActionBase = {
+    hidden?: boolean;
+    id?: string;
+};
+type DataTableRowActionLabel = DataTableRowActionBase & {
+    label: string;
+    type: "label";
+};
+type DataTableRowActionSeparator = DataTableRowActionBase & {
+    type: "separator";
+};
+type DataTableRowActionItem<TData> = DataTableRowActionBase & {
+    type?: "item";
+    label: string;
+    icon?: React.ReactNode;
+    iconType?: IconName;
+    shortcut?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    alert?: boolean;
+    children?: DataTableRowActionNode<TData>[];
+    onSelect?: (ctx: DataTableRowActionContext<TData>) => void;
+};
+type DataTableRowActionNode<TData> = DataTableRowActionItem<TData> | DataTableRowActionLabel | DataTableRowActionSeparator;
+type DataTableRowActionsColumnOptions<TData> = {
+    id?: string;
+    header?: ColumnDef<TData>["header"];
+    align?: "start" | "center" | "end";
+    editingRowId?: string | null;
+    trigger?: (ctx: DataTableRowActionContext<TData>) => React.ReactNode;
+    actions?: DataTableRowActionNode<TData>[] | ((ctx: DataTableRowActionContext<TData>) => DataTableRowActionNode<TData>[]);
+    onStartEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onSaveEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onCancelEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onDelete?: (ctx: DataTableRowActionContext<TData>) => void;
+    includeDefaultActions?: boolean;
+    labels?: {
+        cancelAriaLabel?: string;
+        delete?: string;
+        edit?: string;
+        empty?: string;
+        saveAriaLabel?: string;
+    };
+};
+export declare function createDataTableRowActionsColumn<TData>(options?: DataTableRowActionsColumnOptions<TData>): ColumnDef<TData>;
+export type { DataTableRowActionContext, DataTableRowActionItem, DataTableRowActionLabel, DataTableRowActionNode, DataTableRowActionSeparator, DataTableRowActionsColumnOptions, };

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

@@ -0,0 +1,2 @@
+import { ColumnDef } from '@tanstack/react-table';
+export declare function createDataTableSelectColumn<TData>(): ColumnDef<TData>;

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

@@ -0,0 +1,2 @@
+import { DataTableProps } from '../basic-table';
+export declare function DataTable<TData, TValue>({ className, ...props }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+export declare const dataTableContainerClassName = "w-full overflow-hidden rounded-xl border border-delicate-border bg-primary-bg";
+export declare const dataTableTableClassName = "w-full";
+export declare const dataTableHeadRowClassName = "h-13 border-delicate-border hover:bg-transparent data-[state=selected]:bg-transparent";
+export declare const dataTableBodyRowClassName = "h-15 border-delicate-border hover:bg-transparent data-[state=selected]:bg-transparent";
+export declare const dataTableEditingRowClassName = "h-[7.5rem]";
+export declare const dataTableHeadCellClassName: string;
+export declare const dataTableCellClassName: string;
+export declare const dataTableEmptyCellClassName = "h-24 text-center";

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

@@ -0,0 +1,17 @@
+export { DataTable } from './data-table';
+export type { DataTableColumnMeta, DataTableProps } from '../basic-table';
+export { createDataTableActionsColumn } from './data-table-actions-column';
+export type { DataTableActionsColumnOptions } from './data-table-actions-column';
+export { withDataTableEditableColumn } from './data-table-editable-column';
+export type { DataTableEditableColumnOptions } from './data-table-editable-column';
+export { createDataTableRowActionsColumn } from './data-table-row-actions-column';
+export type { DataTableRowActionContext, DataTableRowActionItem, DataTableRowActionLabel, DataTableRowActionNode, DataTableRowActionSeparator, DataTableRowActionsColumnOptions, } from './data-table-row-actions-column';
+export { DataTableBulkActions } from './data-table-bulk-actions';
+export type { DataTableBulkActionsContext, DataTableBulkActionsProps, } from './data-table-bulk-actions';
+export { DataTableColumnVisibility } from './data-table-column-visibility';
+export type { DataTableColumnVisibilityProps } from './data-table-column-visibility';
+export { DataTableFilter } from './data-table-filter';
+export type { DataTableFilterProps } from './data-table-filter';
+export { createDataTableSelectColumn } from './data-table-select-column';
+export { useDataTableEditableRows } from './use-data-table-editable-rows';
+export type { DataTableRowDeleteEvent, DataTableRowEditCancelEvent, DataTableRowEditSaveEvent, DataTableRowEditStartEvent, DataTableRowsChangeEvent, EditableRowKey, UseDataTableEditableRowsOptions, } from './use-data-table-editable-rows';

package/dist/components/data-table/use-data-table-editable-rows.d.ts

@@ -0,0 +1,60 @@
+import * as React from "react";
+type EditableRowKey<TData> = Extract<keyof TData, string>;
+type EditableValues = Record<string, string>;
+type DataTableRowEditStartEvent<TData> = {
+    editableKeys: readonly EditableRowKey<TData>[];
+    initialValues: EditableValues;
+    row: TData;
+    rowId: string;
+};
+type DataTableRowEditCancelEvent<TData> = {
+    editingValues: EditableValues;
+    row: TData | null;
+    rowId: string | null;
+};
+type DataTableRowEditSaveEvent<TData> = {
+    editingValues: EditableValues;
+    nextRow: TData;
+    previousRow: TData;
+    rowId: string;
+};
+type DataTableRowDeleteEvent<TData> = {
+    row: TData;
+    rowId: string;
+};
+type DataTableRowsChangeEvent<TData> = ({
+    nextRows: TData[];
+    previousRows: TData[];
+    type: "edit-save";
+} & DataTableRowEditSaveEvent<TData>) | ({
+    nextRows: TData[];
+    previousRows: TData[];
+    type: "delete";
+} & DataTableRowDeleteEvent<TData>);
+type UseDataTableEditableRowsOptions<TData> = {
+    rows: TData[];
+    getRowId: (row: TData) => string;
+    setRows?: React.Dispatch<React.SetStateAction<TData[]>>;
+    editingRowId?: string | null;
+    onEditingRowIdChange?: (rowId: string | null) => void;
+    editingValues?: EditableValues;
+    onEditingValuesChange?: React.Dispatch<React.SetStateAction<EditableValues>>;
+    onRowDelete?: (event: DataTableRowDeleteEvent<TData>) => void;
+    onRowEditCancel?: (event: DataTableRowEditCancelEvent<TData>) => void;
+    onRowEditSave?: (event: DataTableRowEditSaveEvent<TData>) => void;
+    onRowEditStart?: (event: DataTableRowEditStartEvent<TData>) => void;
+    onRowsChange?: (event: DataTableRowsChangeEvent<TData>) => void;
+};
+declare function useDataTableEditableRows<TData>({ rows, getRowId, setRows, editingRowId: controlledEditingRowId, onEditingRowIdChange, editingValues: controlledEditingValues, onEditingValuesChange, onRowDelete, onRowEditCancel, onRowEditSave, onRowEditStart, onRowsChange, }: UseDataTableEditableRowsOptions<TData>): {
+    autoResetPageIndex: boolean;
+    cancelEditingRow: () => void;
+    deleteRow: (rowId: string) => void;
+    editingRowId: string | null;
+    editingValues: EditableValues;
+    saveEditingRow: (rowId: string) => void;
+    setEditingValues: (updater: React.SetStateAction<EditableValues>) => void;
+    setEditingRowId: (updater: React.SetStateAction<string | null>) => void;
+    startEditingRow: (row: TData, editableKeys: readonly EditableRowKey<TData>[], overrides?: Partial<Record<EditableRowKey<TData>, string>>) => void;
+};
+export { useDataTableEditableRows };
+export type { DataTableRowDeleteEvent, DataTableRowEditCancelEvent, DataTableRowEditSaveEvent, DataTableRowEditStartEvent, DataTableRowsChangeEvent, EditableRowKey, UseDataTableEditableRowsOptions, };

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

@@ -0,0 +1,2 @@
+export * from './data-table/index'
+export {}

package/dist/components/files-uploader/files-uploader.d.ts

@@ -1,19 +1,22 @@
 import { IconProps } from '../ui/icon';
 type Variant = "grid" | "list" | "compact";
 type AcceptType = "image" | "pdf" | "doc" | "excel" | "text" | "all";
-type UploadedFileData = {
+export type UploadedFileData = {
     url: string;
     name: string;
     size: string;
     addedAt: string;
+    status: "uploaded" | "error";
+    error?: string;
 };
-type FilesUploaderValue = UploadedFileData | UploadedFileData[] | null;
-type PropsFilesUploader = {
+export type FilesUploaderValue = UploadedFileData[] | [];
+export type PropsFilesUploader = {
     value?: FilesUploaderValue;
     onChange?: (value: FilesUploaderValue) => void;
     multiple?: boolean;
     maxFiles?: number;
     disabled?: boolean;
+    isErrorText?: boolean;
     className?: {
         container?: string;
         blockAdd?: string;
@@ -21,7 +24,6 @@ type PropsFilesUploader = {
         text?: string;
         icon?: string;
     };
-    displayFiles?: boolean;
     maxSize?: number;
     variant?: Variant;
     accepts?: AcceptType[];
@@ -30,5 +32,5 @@ type PropsFilesUploader = {
     text?: string;
     showFiles?: boolean;
 };
-export declare const FilesUploader: ({ value, onChange, multiple, maxFiles, disabled, className, maxSize, variant, accepts, icon, title, text, showFiles, }: PropsFilesUploader) => import("react/jsx-runtime").JSX.Element;
-export type { PropsFilesUploader, UploadedFileData, FilesUploaderValue };
+export declare const FilesUploader: ({ value, onChange, multiple, maxFiles, disabled, className, maxSize, variant, accepts, icon, title, text, showFiles, isErrorText, }: PropsFilesUploader) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/textarea-field/index.d.ts

@@ -1,2 +1,2 @@
 export { TextareaField } from './textarea-field';
-export type { TextareaFieldProps, } from './textarea-field';
+export type { TextareaFieldProps } from './textarea-field';

package/dist/components/ui/button/button.styles.d.ts

@@ -1,5 +1,5 @@
 import { ClassProp } from 'class-variance-authority/types';
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "primary" | "secondary" | "secondaryBorder" | "ghost" | "circle" | "circleGhost" | "square" | null | undefined;
-    size?: "lg" | "md" | "sm" | "xs" | "default" | "icon-lg" | "icon-md" | "icon-sm" | "icon-xs" | null | undefined;
+    variant?: "link" | "primary" | "secondary" | "outlined" | "ghost" | "circle" | "circleGhost" | "square" | "pagination-arrow" | "pagination-page" | null | undefined;
+    size?: "lg" | "md" | "sm" | "xs" | "default" | "icon-lg" | "icon-md" | "icon-sm" | "icon-xs" | "pagination" | null | undefined;
 } & ClassProp) | undefined) => string;

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

@@ -1,19 +1,23 @@
-import { DayPicker, DayButton, Locale, DayPickerLocale } from 'react-day-picker';
+import { DayPicker, DayButton } from 'react-day-picker';
 import { Button } from '../button';
 import * as React from "react";
+type CalendarSize = "sm" | "md" | "lg";
+type CalendarPreset = {
+    text: string;
+    days: number;
+};
 type Props = React.ComponentProps<typeof DayPicker> & {
     buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+    size?: CalendarSize;
     classNameWrapper?: string;
     classNameFooter?: string;
     footer?: React.ReactNode;
+    appendFooter?: React.ReactNode;
+    presets?: CalendarPreset[];
+    presetBaseDate?: Date;
+    onPresetClick?: (preset: CalendarPreset, date: Date) => void;
 };
-export declare const localeMode: {
-    ru: DayPickerLocale;
-    es: DayPickerLocale;
-};
-declare function Calendar({ className, classNames, classNameWrapper, classNameFooter, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, footer, ...props }: Props): import("react/jsx-runtime").JSX.Element;
-declare function CalendarDayButton({ className, day, modifiers, locale, children, ...props }: React.ComponentProps<typeof DayButton> & {
-    locale?: Partial<Locale>;
-}): import("react/jsx-runtime").JSX.Element;
+declare function Calendar({ className, classNames, classNameWrapper, classNameFooter, showOutsideDays, captionLayout, buttonVariant, size, locale, formatters, components, footer, appendFooter, presets, presetBaseDate, onPresetClick, onDayClick, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, children, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
 export { Calendar, CalendarDayButton };
-export type { Props as CalendarProps };
+export type { CalendarPreset, Props as CalendarProps };

package/dist/components/ui/calendar/calendar.styles.d.ts

@@ -1,4 +1,62 @@
 import { ClassProp } from 'class-variance-authority/types';
-export declare const calendarVariants: (props?: ({
-    rangeType?: "end" | "start" | "none" | "middle" | "single" | null | undefined;
+export declare const calendarTypographyVariantBySize: {
+    readonly sm: "body-xxs-regular";
+    readonly md: "body-xs-regular";
+    readonly lg: "body-md-regular";
+};
+export declare const calendarWrapperClassName = "border-delicate-border !max-w-none hover:bg-transparent rounded-lg border bg-primary-bg !shadow-[0_0.25rem_1.125rem_0_rgb(0_0_0_/_15%)]";
+export declare const calendarContentPaddingVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
 } & ClassProp) | undefined) => string;
+export declare const calendarRootVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarMonthsClassName = "relative flex flex-col gap-8 md:flex-row";
+export declare const calendarMonthClassName = "flex w-full flex-col gap-4";
+export declare const calendarNavClassName = "absolute inset-x-0 top-0 flex w-full items-center justify-between gap-1";
+export declare const calendarNavButtonClassName = "hover:bg-primary-hover-bg size-(--cell-size) p-0 select-none aria-disabled:bg-primary-bg";
+export declare const calendarMonthCaptionClassName = "flex h-(--cell-size) w-full items-center justify-center px-(--cell-size)";
+export declare const calendarDropdownsVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarDropdownRootClassName = "cn-calendar-dropdown-root relative rounded-sm";
+export declare const calendarDropdownClassName = "absolute inset-0 opacity-0";
+export declare const calendarCaptionLabelVariants: (props?: ({
+    layout?: "label" | "dropdown" | null | undefined;
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekdaysVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekdayVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekNumberHeaderClassName = "size-(--cell-size) shrink-0 select-none";
+export declare const calendarWeekNumberVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarDayVariants: (props?: ({
+    showWeekNumber?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarRangeStartClassName = "relative isolate z-0 rounded-l-sm after:absolute after:inset-y-0 after:left-full after:w-[calc(var(--calendar-gap-x)/2)] after:bg-tertiary-bg after:content-[''] after:-z-10";
+export declare const calendarRangeMiddleClassName = "relative isolate z-0 rounded-none before:absolute before:inset-y-0 before:right-full before:w-[calc(var(--calendar-gap-x)/2)] before:bg-tertiary-bg before:content-[''] before:-z-10 after:absolute after:inset-y-0 after:left-full after:w-[calc(var(--calendar-gap-x)/2)] after:bg-tertiary-bg after:content-[''] after:-z-10";
+export declare const calendarRangeEndClassName = "relative isolate z-0 rounded-r-sm before:absolute before:inset-y-0 before:right-full before:w-[calc(var(--calendar-gap-x)/2)] before:bg-tertiary-bg before:content-[''] before:-z-10";
+export declare const calendarTodayClassName = "bg-tertiary-bg text-primary-text relative rounded-sm data-[selected=true]:rounded-none";
+export declare const calendarTodayButtonIndicatorClassName = "relative z-0 overflow-visible after:pointer-events-none after:absolute after:bottom-[0.1875rem] after:left-1/2 after:z-[1] after:block after:size-[0.1875rem] after:-translate-x-1/2 after:rounded-full after:bg-primary-text data-[range-start=true]:after:bg-primary-inverse-text data-[range-end=true]:after:bg-primary-inverse-text data-[selected-single=true]:after:bg-primary-inverse-text disabled:after:opacity-40";
+export declare const calendarRangeLastClickedClassName = "data-[last-clicked=true]:[box-shadow:inset_0_0_0_0.125rem_var(--color-inp-default-border)]";
+export declare const calendarOutsideClassName = "text-disabled-text aria-selected:text-disabled-text";
+export declare const calendarDisabledClassName = "text-disabled-text bg-transparent pointer-events-none";
+export declare const calendarHiddenClassName = "invisible";
+export declare const calendarDayButtonClassName = "text-primary-text size-(--cell-size) min-h-(--cell-size)\nmax-h-(--cell-size) min-w-(--cell-size) max-w-(--cell-size) rounded-sm p-0 hover:bg-primary-hover-bg\ndisabled:!bg-transparent disabled:hover:!bg-transparent disabled:text-disabled-text\ndata-[selected-single=true]:bg-primary-inverse-bg\ndata-[selected-single=true]:text-primary-inverse-text\ndata-[range-start=true]:bg-primary-inverse-bg\ndata-[range-start=true]:text-primary-inverse-text\ndata-[range-start=true]:rounded-l-sm\ndata-[range-middle=true]:bg-tertiary-bg\ndata-[range-middle=true]:text-primary-text\ndata-[range-middle=true]:rounded-none\ndata-[range-end=true]:bg-primary-inverse-bg\ndata-[range-end=true]:text-primary-inverse-text\ndata-[range-end=true]:rounded-r-sm";
+export declare const calendarDayTextVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarFooterVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarIconClassName = "text-primary-text !size-5";
+export declare const calendarWeekNumberCellClassName = "flex size-(--cell-size) items-center justify-center text-center";
+export declare const calendarDayTextClassName = "leading-none";

package/dist/components/ui/calendar/index.d.ts

@@ -1,2 +1,3 @@
-export { Calendar, localeMode } from './calendar';
-export type { CalendarProps } from './calendar';
+export { Calendar } from './calendar';
+export { localeMode } from '../../../constants/calendar-locale';
+export type { CalendarPreset, CalendarProps } from './calendar';

package/dist/components/ui/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,102 @@
+import { DropdownMenu as DropdownMenuPrimitive } from 'radix-ui';
+import { IconName } from 'phosphor-strokes-icons/by-name';
+import * as React from "react";
+type DropdownMenuRef = React.ComponentRef<typeof DropdownMenuPrimitive.Root>;
+type DropdownMenuProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Root> & {
+    ref?: React.Ref<DropdownMenuRef>;
+};
+type DropdownMenuTriggerRef = React.ComponentRef<typeof DropdownMenuPrimitive.Trigger>;
+type DropdownMenuTriggerProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Trigger> & {
+    ref?: React.Ref<DropdownMenuTriggerRef>;
+};
+type DropdownMenuContentRef = React.ComponentRef<typeof DropdownMenuPrimitive.Content>;
+type DropdownMenuContentProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content> & {
+    ref?: React.Ref<DropdownMenuContentRef>;
+};
+type DropdownMenuItemRef = React.ComponentRef<typeof DropdownMenuPrimitive.Item>;
+type DropdownMenuItemProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
+    ref?: React.Ref<DropdownMenuItemRef>;
+};
+type DropdownMenuCheckboxItemRef = React.ComponentRef<typeof DropdownMenuPrimitive.CheckboxItem>;
+type DropdownMenuCheckboxItemProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem> & {
+    ref?: React.Ref<DropdownMenuCheckboxItemRef>;
+    itemIndicator?: React.ReactNode;
+    closeOnSelect?: boolean;
+};
+type DropdownMenuLabelRef = React.ComponentRef<typeof DropdownMenuPrimitive.Label>;
+type DropdownMenuLabelProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
+    ref?: React.Ref<DropdownMenuLabelRef>;
+};
+type DropdownMenuSeparatorRef = React.ComponentRef<typeof DropdownMenuPrimitive.Separator>;
+type DropdownMenuSeparatorProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator> & {
+    ref?: React.Ref<DropdownMenuSeparatorRef>;
+};
+type DropdownMenuSubTriggerRef = React.ComponentRef<typeof DropdownMenuPrimitive.SubTrigger>;
+type DropdownMenuSubTriggerProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
+    ref?: React.Ref<DropdownMenuSubTriggerRef>;
+};
+type DropdownMenuSubContentRef = React.ComponentRef<typeof DropdownMenuPrimitive.SubContent>;
+type DropdownMenuSubContentProps = React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent> & {
+    ref?: React.Ref<DropdownMenuSubContentRef>;
+};
+type DropdownMenuCheckboxOption = {
+    key: string;
+    label: React.ReactNode;
+    checked: boolean;
+    disabled?: boolean;
+    className?: string;
+    checkedClassName?: string;
+    textValue?: string;
+    itemIndicator?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    checkedEndAdornment?: React.ReactNode;
+};
+type CheckboxDropdownMenuProps = {
+    trigger: React.ReactNode;
+    items: DropdownMenuCheckboxOption[];
+    onItemCheckedChange: (key: string, checked: boolean) => void;
+    contentProps?: Omit<DropdownMenuContentProps, "children">;
+    keepOpenOnItemSelect?: boolean;
+};
+declare function DropdownMenu({ ...props }: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: DropdownMenuTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, align, ...props }: DropdownMenuContentProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, ...props }: DropdownMenuItemProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, itemIndicator, closeOnSelect, onSelect, ...props }: DropdownMenuCheckboxItemProps): import("react/jsx-runtime").JSX.Element;
+declare function CheckboxDropdownMenu({ trigger, items, onItemCheckedChange, contentProps, keepOpenOnItemSelect, }: CheckboxDropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, ...props }: DropdownMenuLabelProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: DropdownMenuSeparatorProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, ...props }: DropdownMenuSubTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, sideOffset, ...props }: DropdownMenuSubContentProps): import("react/jsx-runtime").JSX.Element;
+type DropdownMenuConfigBase = {
+    id?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+};
+type DropdownMenuConfigLabel = DropdownMenuConfigBase & {
+    type: "label";
+    label: string;
+};
+type DropdownMenuConfigSeparator = DropdownMenuConfigBase & {
+    type: "separator";
+};
+type DropdownMenuConfigItem = DropdownMenuConfigBase & {
+    type?: "item";
+    label: string;
+    icon?: React.ReactNode;
+    iconType?: IconName;
+    shortcut?: string;
+    alert?: boolean;
+    children?: DropdownMenuConfigNode[];
+    onSelect?: () => void;
+};
+type DropdownMenuConfigNode = DropdownMenuConfigLabel | DropdownMenuConfigSeparator | DropdownMenuConfigItem;
+type ConfigurableDropdownMenuProps = {
+    trigger: React.ReactNode;
+    items: DropdownMenuConfigNode[];
+    onAction?: (item: DropdownMenuConfigItem) => void;
+    contentProps?: Omit<DropdownMenuContentProps, "children">;
+};
+declare function ConfigurableDropdownMenu({ trigger, items, onAction, contentProps, }: ConfigurableDropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPrimitive, DropdownMenuSeparator, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, ConfigurableDropdownMenu, CheckboxDropdownMenu, };
+export type { ConfigurableDropdownMenuProps, DropdownMenuConfigItem, DropdownMenuConfigLabel, DropdownMenuConfigNode, DropdownMenuConfigSeparator, DropdownMenuContentProps, DropdownMenuCheckboxItemProps, DropdownMenuCheckboxOption, DropdownMenuItemProps, DropdownMenuLabelProps, DropdownMenuProps, DropdownMenuSeparatorProps, DropdownMenuSubContentProps, DropdownMenuSubTriggerProps, DropdownMenuTriggerProps, CheckboxDropdownMenuProps, };

package/dist/components/ui/dropdown-menu/dropdown-menu.styles.d.ts

@@ -0,0 +1,9 @@
+export declare const dropdownMenuContentClassName: string;
+export declare const dropdownMenuItemClassName = "\n  relative flex cursor-pointer select-none rounded-sm items-center gap-4 px-3 py-1.5\n  text-sm outline-none transition-colors\n  data-[disabled]:pointer-events-none data-[disabled]:bg-disabled-bg data-[disabled]:text-disabled-text\n  data-[highlighted]:bg-primary-hover-bg data-[state=open]:bg-negotiation-bg\"\n";
+export declare const dropdownMenuSubTriggerClassName = "\n  \n  relative flex cursor-pointer select-none rounded-sm items-center gap-4 px-3 py-1.5\n  text-sm outline-none transition-colors\n  data-[disabled]:pointer-events-none data-[disabled]:bg-disabled-bg data-[disabled]:text-disabled-text\n  data-[highlighted]:bg-primary-hover-bg data-[state=open]:bg-negotiation-bg\"\n\n  justify-between\n  data-[state=open]:bg-negotiation-bg\n";
+export declare const dropdownMenuReadonlyItemTextClassName = "\n  text-center pr-0\n";
+export declare const dropdownMenuLabelClassName: string;
+export declare const dropdownMenuItemTextClassName = "pr-5";
+export declare const dropdownMenuSeparatorClassName = "\n  my-1 h-[0.125rem] bg-delicate-border transform scale-y-50\n";
+export declare const dropdownMenuShortcutClassName = "\n  ml-auto text-secondary-text\n";
+export declare const dropdownMenuIconClassName = "\n  shrink-0 text-secondary-text\n";

package/dist/components/ui/dropdown-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { ConfigurableDropdownMenu, CheckboxDropdownMenu, DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPrimitive, DropdownMenuSeparator, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from './dropdown-menu';
+export type { ConfigurableDropdownMenuProps, CheckboxDropdownMenuProps, DropdownMenuCheckboxOption, DropdownMenuConfigItem, DropdownMenuConfigLabel, DropdownMenuConfigNode, DropdownMenuConfigSeparator, DropdownMenuContentProps, DropdownMenuCheckboxItemProps, DropdownMenuItemProps, DropdownMenuLabelProps, DropdownMenuProps, DropdownMenuSeparatorProps, DropdownMenuSubContentProps, DropdownMenuSubTriggerProps, DropdownMenuTriggerProps, } from './dropdown-menu';

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,2 @@
+export * from './dropdown-menu/index'
+export {}

package/dist/components/ui/icon/icon-presets.d.ts

@@ -1,15 +1,15 @@
 export declare const iconPresets: {
     readonly "xx-small": {
-        readonly size: "0.5rem";
-        readonly strokeWidth: "0.05625rem";
+        readonly size: "0.75rem";
+        readonly strokeWidth: "0.063rem";
     };
     readonly "x-small": {
-        readonly size: "0.75rem";
-        readonly strokeWidth: "0.06875rem";
+        readonly size: "0.875rem";
+        readonly strokeWidth: "0.069rem";
     };
     readonly small: {
         readonly size: "1rem";
-        readonly strokeWidth: "0.08125rem";
+        readonly strokeWidth: "0.081rem";
     };
     readonly medium: {
         readonly size: "1.25rem";