@telepix-lab/telepix-ui 0.1.2 → 0.3.0

package/dist/cjs/tag/index.d.ts

@@ -1,5 +1,5 @@
-import { TagSize, TagVariant } from "./styles";
 import React from "react";
+import { TagSize, TagVariant } from "./types";
 interface TagProps extends React.DetailedHTMLProps<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value">, HTMLButtonElement> {
     value: {
         id: string;

package/dist/cjs/tag/types.d.ts

@@ -0,0 +1,10 @@
+export declare const TAG_VARIANTS: {
+    readonly FILLED: "filled";
+    readonly ACCENT: "accent";
+};
+export type TagVariant = (typeof TAG_VARIANTS)[keyof typeof TAG_VARIANTS];
+export declare const TAG_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+export type TagSize = (typeof TAG_SIZES)[keyof typeof TAG_SIZES];

package/dist/cjs/text/index.d.ts

@@ -1,11 +1,11 @@
 import React from "react";
-import { FontWeightStyles, TextAlignStyles, TextSizeStyles, TextVariantStyles } from "./styles";
+import { FontWeight, TextAlignment, TextSize, TextVariant } from "./types";
 export interface TextProps extends React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> {
     children: React.ReactNode;
-    size?: TextSizeStyles;
-    weight?: FontWeightStyles;
-    align?: TextAlignStyles;
-    variant?: TextVariantStyles;
+    size?: TextSize;
+    weight?: FontWeight;
+    align?: TextAlignment;
+    variant?: TextVariant;
     color?: string;
     as?: React.ElementType;
 }

package/dist/cjs/text/types.d.ts

@@ -0,0 +1,74 @@
+export declare const TEXT_SIZES: {
+    readonly XSMALL: "xsmall";
+    readonly LABEL: "label";
+    readonly BODY: "body";
+    readonly BASE: "base";
+    readonly LARGE: "large";
+    readonly XLARGE: "xl";
+    readonly XXLARGE: "xxl";
+    readonly XXXLARGE: "xxxl";
+    readonly XXXXLARGE: "xxxxl";
+};
+export type TextSize = (typeof TEXT_SIZES)[keyof typeof TEXT_SIZES];
+export declare const FONT_WEIGHTS: {
+    readonly THIN: "thin";
+    readonly EXTRALIGHT: "extralight";
+    readonly LIGHT: "light";
+    readonly REGULAR: "regular";
+    readonly MEDIUM: "medium";
+    readonly SEMIBOLD: "semibold";
+    readonly BOLD: "bold";
+    readonly EXTRABOLD: "extrabold";
+};
+export type FontWeight = (typeof FONT_WEIGHTS)[keyof typeof FONT_WEIGHTS];
+export declare const TEXT_ALIGNMENTS: {
+    readonly LEFT: "left";
+    readonly CENTER: "center";
+    readonly RIGHT: "right";
+    readonly JUSTIFY: "justify";
+};
+export type TextAlignment = (typeof TEXT_ALIGNMENTS)[keyof typeof TEXT_ALIGNMENTS];
+export declare const TEXT_VARIANTS: {
+    BOLD3XLARGEBOLD: string;
+    BOLD2XLARGEBOLDCOMPACT: string;
+    BOLD2XLARGEBOLD: string;
+    BOLDXLARGEBOLDCOMPACT: string;
+    BOLDXLARGEBOLD: string;
+    BOLDLARGEBOLDCOMPACT: string;
+    BOLDLARGEBOLD: string;
+    BOLDBASEBOLDCOMPACT: string;
+    BOLDBASEBOLD: string;
+    BOLDBODYBOLDCOMPACT: string;
+    BOLDBODYBOLD: string;
+    BOLDLABELBOLDCOMPACT: string;
+    BOLDLABELBOLD: string;
+    BOLDXSMALLBOLD: string;
+    SEMIBOLDBASESEMIBOLDCOMPACT: string;
+    SEMIBOLDBASESEMIBOLD: string;
+    SEMIBOLDBODYSEMIBOLDCOMPACT: string;
+    SEMIBOLDBODYSEMIBOLD: string;
+    SEMIBOLDLABELSEMIBOLDCOMPACT: string;
+    MED3XLARGEMED: string;
+    MEDXLARGEMED: string;
+    MEDLARGEMED: string;
+    MEDBASEMEDCOMPACT: string;
+    MEDBASEMED: string;
+    MEDBODYMEDCOMPACT: string;
+    MEDBODYMED: string;
+    MEDLABELMEDCOMPACT: string;
+    MEDLABELMED: string;
+    MEDXSMALLMED: string;
+    REGULAR3XLARGE: string;
+    REGULAR2XLARGE: string;
+    REGULARXLARGE: string;
+    REGULARLARGECOMPACT: string;
+    REGULARLARGE: string;
+    REGULARBASECOMPACT: string;
+    REGULARBASE: string;
+    REGULARBODYCOMPACT: string;
+    REGULARBODY: string;
+    REGULARLABELCOMPACT: string;
+    REGULARLABEL: string;
+    REGULARXSMALL: string;
+};
+export type TextVariant = (typeof TEXT_VARIANTS)[keyof typeof TEXT_VARIANTS];

package/dist/cjs/tooltip/index.d.ts

@@ -1,6 +1,6 @@
 import { Tooltip as TooltipRadix } from "radix-ui";
-import { TooltipShortSizeStyles, TooltipShortVariantStyles } from "./styles";
 import React from "react";
+import { TooltipShortSize, TooltipShortVariant } from "./types";
 export declare const Tooltip: (props: React.ComponentProps<typeof TooltipRadix.Root & typeof TooltipRadix.TooltipProvider>) => import("react/jsx-runtime").JSX.Element;
 export declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipRadix.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
 interface TooltipDescriptionProps {
@@ -8,8 +8,8 @@ interface TooltipDescriptionProps {
 }
 interface TooltipShortDescriptionProps {
     type: "short";
-    variant?: TooltipShortVariantStyles;
-    size?: TooltipShortSizeStyles;
+    variant?: TooltipShortVariant;
+    size?: TooltipShortSize;
 }
 type TooltipContentProps = React.ComponentProps<typeof TooltipRadix.Content> & (TooltipDescriptionProps | TooltipShortDescriptionProps);
 export declare const TooltipContent: ({ type, ...rest }: TooltipContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/cjs/tooltip/types.d.ts

@@ -0,0 +1,10 @@
+export declare const TOOLTIP_SHORT_VARIANTS: {
+    readonly DEFAULT: "default";
+    readonly ACCENT: "accent";
+};
+export type TooltipShortVariant = (typeof TOOLTIP_SHORT_VARIANTS)[keyof typeof TOOLTIP_SHORT_VARIANTS];
+export declare const TOOLTIP_SHORT_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+export type TooltipShortSize = (typeof TOOLTIP_SHORT_SIZES)[keyof typeof TOOLTIP_SHORT_SIZES];

package/dist/cjs/vertical-menu/index.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { VerticalMenuSizeStyles, VerticalMenuVariantStyles } from "./styles";
+import { VerticalMenuSize, VerticalMenuVariant } from "./types";
 interface VerticalMenusProps extends React.HTMLAttributes<HTMLDivElement> {
     disabled?: boolean;
     value?: string;
@@ -10,8 +10,8 @@ interface VerticalMenuProps extends React.DetailedHTMLProps<React.ButtonHTMLAttr
     value: string;
     label?: string;
     icon?: React.ReactNode;
-    variant?: VerticalMenuVariantStyles;
-    size?: VerticalMenuSizeStyles;
+    variant?: VerticalMenuVariant;
+    size?: VerticalMenuSize;
 }
 export declare const VerticalMenu: React.ForwardRefExoticComponent<Omit<VerticalMenuProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export {};

package/dist/cjs/vertical-menu/types.d.ts

@@ -0,0 +1,10 @@
+export declare const VERTICAL_MENU_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+export type VerticalMenuSize = (typeof VERTICAL_MENU_SIZES)[keyof typeof VERTICAL_MENU_SIZES];
+export declare const VERTICAL_MENU_VARIANTS: {
+    readonly ACCENT: "accent";
+    readonly GHOST: "ghost";
+};
+export type VerticalMenuVariant = (typeof VERTICAL_MENU_VARIANTS)[keyof typeof VERTICAL_MENU_VARIANTS];

package/dist/client.d.ts

@@ -0,0 +1,398 @@
+import * as React$1 from 'react';
+import React__default from 'react';
+import { RadioGroup as RadioGroup$1, Checkbox as Checkbox$1, Dialog as Dialog$1, Select as Select$1, Tooltip as Tooltip$1, Popover, ContextMenu as ContextMenu$1 } from 'radix-ui';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DayPicker, DateRange } from 'react-day-picker';
+
+declare const RADIO_GROUP_ORIENTAIONS: {
+    readonly HORIZONTAL: "horizontal";
+    readonly VERTICAL: "vertical";
+};
+type RadioGroupOrientation = (typeof RADIO_GROUP_ORIENTAIONS)[keyof typeof RADIO_GROUP_ORIENTAIONS];
+
+interface RadioGroupProps extends RadioGroup$1.RadioGroupProps {
+    className?: string;
+    orientation?: RadioGroupOrientation;
+}
+/**
+ * 라디오 버튼 그룹을 생성하는 컴포넌트입니다.<br/>
+ * orientation prop을 통해 수평 또는 수직 방향으로 배치할 수 있습니다.<br/>
+ * value prop을 통해 현재 선택된 라디오 버튼의 값을 관리합니다.<br/>
+ * disabled prop을 통해 그룹 전체를 비활성화할 수 있습니다.<br/>
+ * 또는 개별 RadioItem 컴포넌트에 disabled prop을 설정하여 특정 라디오 버튼을 비활성화할 수 있습니다.<br/>
+ * RadioItem 컴포넌트를 자식으로 받아 라디오 버튼을 구성합니다.<br/>
+ * <br/>
+ * ### 사용 예시
+ * ```tsx
+ * <RadioGroup value={selectedValue} onValueChange={setSelectedValue}>
+ *   <RadioItem value="option1" label="Option 1" />
+ *   <RadioItem value="option2" label="Option 2" />
+ *   <RadioItem value="option3" label="Option 3" />
+ * </RadioGroup>
+ * ```
+ */
+declare const RadioGroup: React__default.ForwardRefExoticComponent<RadioGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+interface RadioItemProps extends RadioGroup$1.RadioGroupItemProps {
+    label?: string;
+    labelClassName?: string;
+    wrapperClassName?: string;
+    className?: string;
+}
+declare const RadioItem: React__default.ForwardRefExoticComponent<RadioItemProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface CheckboxProps extends Checkbox$1.CheckboxProps {
+    label?: string;
+    labelClassName?: string;
+    wrapperClassName?: string;
+}
+/**
+ * 체크박스 컴포넌트입니다.<br/>
+ * 사용자는 체크박스의 상태(checked, defaultChecked), ID, disabled 여부, 클래스 이름 등을 지정할 수 있습니다.<br/>
+ * label을 통해 체크박스 옆에 표시할 텍스트를 설정할 수 있으며, labelClassName을 통해 라벨의 스타일을 지정할 수 있습니다.<br/>
+ * wrapperClassName을 통해 체크박스와 라벨을 감싸는 요소의 스타일을 지정할 수 있습니다.<br/>
+ * <br/>
+ * ### 사용 예시
+ * ```tsx
+ * <Checkbox
+ *   label="Accept Terms and Conditions"
+ *   checked={isChecked}
+ *   onCheckedChange={(value) => setIsChecked(value)}
+ * />
+ * ```
+ */
+declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Dialog 컴포넌트는 모달 대화 상자를 생성하는 데 사용됩니다.<br/>
+ * 이 컴포넌트는 Radix UI의 Dialog 컴포넌트를 래핑하여 사용합니다.<br/>
+ * Dialog 컴포넌트는 모달의 상태를 관리하고, 모달을 열고 닫는 기능을 제공합니다.<br/>
+ * DialogTrigger는 모달을 여는 트리거 버튼 역할을 하며, DialogContent는 모달의 실제 콘텐츠를 렌더링합니다.<br/>
+ * DialogClose는 모달을 닫는 버튼 역할을 합니다.<br/>
+ * DialogHeader, DialogFooter, DialogDescription은 모달의 헤더, 푸터, 제목, 설명을 구성하는 데 사용됩니다.<br/>
+ * 이 컴포넌트는 모달 대화 상자를 쉽게 구현할 수 있도록 도와줍니다.<br/>
+ * <br/>
+ * ### 사용 예시
+ * ```tsx
+ * <Dialog>
+ *   <DialogTrigger>Open Dialog</DialogTrigger>
+ *   <DialogContent>
+ *     <DialogHeader>
+ *       Dialog Title
+ *       <DialogClose />
+ *     </DialogHeader>
+ *     <DialogDescription>
+ *       This is a description of the dialog.
+ *     </DialogDescription>
+ *   </DialogContent>
+ * </Dialog>
+ */
+declare const Dialog: any;
+declare const DialogTrigger: (props: React$1.ComponentProps<typeof Dialog$1.Trigger>) => react_jsx_runtime.JSX.Element;
+declare const DialogPortal: any;
+declare const DialogClose: any;
+declare const DialogContent: ({ className, children, ...rest }: React$1.ComponentProps<typeof Dialog$1.Content>) => react_jsx_runtime.JSX.Element;
+declare const DialogHeader: ({ className, ...rest }: React$1.ComponentProps<typeof Dialog$1.Title>) => react_jsx_runtime.JSX.Element;
+declare const DialogFooter: React$1.ForwardRefExoticComponent<Omit<React$1.ClassAttributes<HTMLDivElement> & React$1.HTMLAttributes<HTMLDivElement>, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+declare const DialogDescription: ({ className, ...rest }: React$1.ComponentProps<typeof Dialog$1.Description>) => react_jsx_runtime.JSX.Element;
+
+declare const SELECT_TRIGGER_VARIANTS: {
+    readonly OUTLINE: "outline";
+    readonly GHOST: "ghost";
+};
+type SelectTriggerVariant = (typeof SELECT_TRIGGER_VARIANTS)[keyof typeof SELECT_TRIGGER_VARIANTS];
+declare const SELECT_TRIGGER_SIZES: {
+    readonly REGULAR: "regular";
+    readonly LARGE: "large";
+};
+type SelectTriggerSize = (typeof SELECT_TRIGGER_SIZES)[keyof typeof SELECT_TRIGGER_SIZES];
+
+/**
+ * Select 컴포넌트는 드롭다운 선택 상자를 생성하는 데 사용됩니다.<br/>
+ * 이 컴포넌트는 Radix UI의 Select 컴포넌트를 래핑하여 사용합니다.<br/>
+ * SelectTrigger는 드롭다운을 여는 트리거 버튼 역할을 하며, SelectContent는 드롭다운의 실제 콘텐츠를 렌더링합니다.<br/>
+ * SelectGroup, SelectLabel, SelectSeparator는 드롭다운의 그룹화 및 레이블링을 지원합니다.<br/>
+ * SelectItem은 드롭다운에서 선택 가능한 항목을 나타냅니다.<br/>
+ * 이 컴포넌트는 드롭다운 선택 상자를 쉽게 구현할 수 있도록 도와줍니다.<br/>
+ * <br/>
+ * ### 사용 예시
+ * ```tsx
+ * <Select>
+ *   <SelectTrigger placeholder="Select an option" />
+ *   <SelectContent>
+ *     <SelectItem value="option1">Option 1</SelectItem>
+ *     <SelectItem value="option2">Option 2</SelectItem>
+ *     <SelectItem value="option3">Option 3</SelectItem>
+ *   </SelectContent>
+ * </Select>
+ */
+declare const Select: {
+    (props: React__default.ComponentProps<typeof Select$1.Root>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface SelectTrigger extends React__default.ComponentProps<typeof Select$1.Trigger> {
+    placeholder?: string;
+    variant?: SelectTriggerVariant;
+    size?: SelectTriggerSize;
+    icon?: React__default.ReactNode;
+}
+declare const SelectTrigger: {
+    ({ placeholder, variant, size, icon, ...rest }: SelectTrigger): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface SelectContent extends React__default.ComponentProps<typeof Select$1.Content> {
+    children: React__default.ReactNode;
+}
+declare const SelectContent: {
+    ({ children, ...rest }: SelectContent): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SelectGroup: any;
+declare const SelectLabel: {
+    (props: React__default.ComponentProps<typeof Select$1.Label>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const SelectSeparator: {
+    (props: React__default.ComponentProps<typeof Select$1.Separator>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+interface SelectItem extends React__default.ComponentProps<typeof Select$1.Item> {
+    indicator?: React__default.ReactNode;
+}
+declare const SelectItem: {
+    ({ indicator, ...rest }: SelectItem): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const VERTICAL_MENU_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+type VerticalMenuSize = (typeof VERTICAL_MENU_SIZES)[keyof typeof VERTICAL_MENU_SIZES];
+declare const VERTICAL_MENU_VARIANTS: {
+    readonly ACCENT: "accent";
+    readonly GHOST: "ghost";
+};
+type VerticalMenuVariant = (typeof VERTICAL_MENU_VARIANTS)[keyof typeof VERTICAL_MENU_VARIANTS];
+
+interface VerticalMenusProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const VerticalMenus: React__default.ForwardRefExoticComponent<VerticalMenusProps & React__default.RefAttributes<HTMLDivElement>>;
+interface VerticalMenuProps extends React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
+    value: string;
+    label?: string;
+    icon?: React__default.ReactNode;
+    variant?: VerticalMenuVariant;
+    size?: VerticalMenuSize;
+}
+declare const VerticalMenu: React__default.ForwardRefExoticComponent<Omit<VerticalMenuProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const HORIZONTAL_TAB_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+type HorizontalTabSize = (typeof HORIZONTAL_TAB_SIZES)[keyof typeof HORIZONTAL_TAB_SIZES];
+
+interface HorizontalTabsProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const HorizontalTabs: React__default.ForwardRefExoticComponent<HorizontalTabsProps & React__default.RefAttributes<HTMLDivElement>>;
+interface HorizontalTabProps extends React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
+    value: string;
+    label?: string;
+    icon?: React__default.ReactNode;
+    size?: HorizontalTabSize;
+}
+declare const HorizontalTab: React__default.ForwardRefExoticComponent<Omit<HorizontalTabProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+interface ModeTabsProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare const ModeTabs: React__default.ForwardRefExoticComponent<ModeTabsProps & React__default.RefAttributes<HTMLDivElement>>;
+interface ModeTabProps extends React__default.DetailedHTMLProps<React__default.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
+    value: string;
+    label?: string;
+    icon?: React__default.ReactNode;
+}
+declare const ModeTab: React__default.ForwardRefExoticComponent<Omit<ModeTabProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const TOOLTIP_SHORT_VARIANTS: {
+    readonly DEFAULT: "default";
+    readonly ACCENT: "accent";
+};
+type TooltipShortVariant = (typeof TOOLTIP_SHORT_VARIANTS)[keyof typeof TOOLTIP_SHORT_VARIANTS];
+declare const TOOLTIP_SHORT_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+};
+type TooltipShortSize = (typeof TOOLTIP_SHORT_SIZES)[keyof typeof TOOLTIP_SHORT_SIZES];
+
+declare const Tooltip: (props: React__default.ComponentProps<typeof Tooltip$1.Root & typeof Tooltip$1.TooltipProvider>) => react_jsx_runtime.JSX.Element;
+declare const TooltipTrigger: any;
+interface TooltipDescriptionProps {
+    type: "default";
+}
+interface TooltipShortDescriptionProps {
+    type: "short";
+    variant?: TooltipShortVariant;
+    size?: TooltipShortSize;
+}
+type TooltipContentProps = React__default.ComponentProps<typeof Tooltip$1.Content> & (TooltipDescriptionProps | TooltipShortDescriptionProps);
+declare const TooltipContent: ({ type, ...rest }: TooltipContentProps) => react_jsx_runtime.JSX.Element;
+declare const TooltipArrow: any;
+declare const TooltipHeader: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const TooltipDescription: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+declare const TooltipFooter: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const MULTIPLE_SELECT_SIZES: {
+    readonly REGULAR: "regular";
+    readonly LARGE: "large";
+};
+type MultipleSelectSize = (typeof MULTIPLE_SELECT_SIZES)[keyof typeof MULTIPLE_SELECT_SIZES];
+
+interface Option {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface MultipleSelectProps extends React__default.HTMLAttributes<HTMLDivElement> {
+    disabled?: boolean;
+    open?: boolean;
+    value?: Option[];
+    onOpenChange?: (open: boolean) => void;
+    onValueChange?: (value: Option[]) => void;
+}
+declare const MultipleSelect: React__default.ForwardRefExoticComponent<MultipleSelectProps & React__default.RefAttributes<HTMLDivElement>>;
+interface MultipleSelectTriggerProps extends React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    size?: MultipleSelectSize;
+}
+declare const MultipleSelectTrigger: React__default.ForwardRefExoticComponent<Omit<MultipleSelectTriggerProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+interface MultipleSelectValueProps extends React__default.DetailedHTMLProps<Omit<React__default.HTMLAttributes<HTMLDivElement>, "children">, HTMLDivElement> {
+    placeholder?: string;
+}
+declare const MultipleSelectValue: React__default.ForwardRefExoticComponent<Omit<MultipleSelectValueProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+interface MultipleSelectContentProps extends React__default.DetailedHTMLProps<Omit<React__default.HTMLAttributes<HTMLDivElement>, "children">, HTMLDivElement> {
+    useSearch?: boolean;
+    options: Option[];
+    indicator?: React__default.ReactNode;
+}
+declare const MultipleSelectContent: React__default.ForwardRefExoticComponent<Omit<MultipleSelectContentProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+
+declare const Table: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & React__default.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.TableHTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & React__default.RefAttributes<HTMLTableRowElement>>;
+declare const TableBody: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.TableHTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & React__default.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement> {
+    isSelected?: boolean;
+    shouldLastBorderRender?: boolean;
+}
+declare const TableRow: React__default.ForwardRefExoticComponent<Omit<TableRowProps, "ref"> & React__default.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.ThHTMLAttributes<HTMLTableCellElement>, HTMLTableCellElement>, "ref"> & React__default.RefAttributes<HTMLTableCellElement>>;
+interface TableCellProps extends React__default.DetailedHTMLProps<React__default.TdHTMLAttributes<HTMLTableCellElement>, HTMLTableCellElement> {
+    showTooltip?: boolean;
+}
+declare const TableCell: React__default.ForwardRefExoticComponent<Omit<TableCellProps, "ref"> & React__default.RefAttributes<HTMLTableCellElement>>;
+
+/** table 기반 config로 테이블 완성 component */
+interface TableInfo<T> {
+    header: string;
+    renderFn: (item: T) => React__default.ReactNode;
+    minWidth?: number;
+    maxWidth?: number;
+    showTooltip?: boolean;
+}
+type DataTableConfig<T> = TableInfo<T>[];
+interface DataTableProps<T> {
+    config: DataTableConfig<T>;
+    data: T[];
+    emptyMessage?: string;
+    onRowClick?: (item: T) => void;
+    enableSelection?: boolean;
+    shouldLastBorderRender?: boolean;
+    classNames?: {
+        table?: string;
+        header?: string;
+        head?: string;
+        body?: string;
+        row?: string;
+        cell?: string;
+    };
+    refs?: {
+        tableRef?: React__default.Ref<HTMLTableElement>;
+        headerRef?: React__default.Ref<HTMLTableRowElement>;
+        bodyRef?: React__default.Ref<HTMLTableSectionElement>;
+        rowRef?: React__default.Ref<HTMLTableRowElement>;
+        cellRef?: React__default.Ref<HTMLTableCellElement>;
+        headRef?: React__default.Ref<HTMLTableCellElement>;
+    };
+}
+declare const DataTable: <T extends object>({ config, data, emptyMessage, onRowClick, enableSelection, shouldLastBorderRender, classNames, refs, }: DataTableProps<T>) => react_jsx_runtime.JSX.Element;
+
+interface InteractiveListItemProps extends React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement> {
+    isSelected?: boolean;
+    disabled?: boolean;
+    showHoverActions?: boolean;
+}
+declare const InteractiveListItem: React__default.ForwardRefExoticComponent<Omit<InteractiveListItemProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const InteractiveListItemIcon: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React__default.RefAttributes<HTMLSpanElement>>;
+declare const InteractiveListItemContent: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const InteractiveListItemActions: React__default.ForwardRefExoticComponent<React__default.HTMLAttributes<HTMLDivElement> & React__default.RefAttributes<HTMLDivElement>>;
+
+type CalendarProps = React$1.ComponentProps<typeof DayPicker>;
+declare const Calendar: ({ className, classNames, showOutsideDays, ...props }: CalendarProps) => react_jsx_runtime.JSX.Element;
+
+type AllDatePickerTypes = Date | undefined | DateRange | Date[];
+type DatePickerProps = DatePicker & CalendarProps & Popover.PopoverProps & Popover.PopoverContentProps;
+interface DatePicker {
+    size: "regular" | "large";
+    placeholder?: string;
+    format?: string;
+    value?: AllDatePickerTypes;
+    onChange?: (date: AllDatePickerTypes) => void;
+    isInstantClose?: boolean;
+    disabled?: boolean;
+}
+declare const DatePicker: ({ size, placeholder, format, value, mode, onChange, isInstantClose, open: openProp, onOpenChange: onOpenChangeProp, disabled, ...rest }: DatePickerProps) => react_jsx_runtime.JSX.Element;
+
+declare const ContextMenu: any;
+declare const ContextMenuTrigger: any;
+declare const ContextMenuContent: (props: React.ComponentProps<typeof ContextMenu$1.Content>) => react_jsx_runtime.JSX.Element;
+declare const ContextMenuArrow: any;
+declare const ContextMenuLabel: (props: React.ComponentProps<typeof ContextMenu$1.Label>) => react_jsx_runtime.JSX.Element;
+interface ContextMenuItemProps extends Omit<React.ComponentProps<typeof ContextMenu$1.Item>, "children"> {
+    leftIcon?: React.ReactNode;
+    rightSlot?: React.ReactNode;
+}
+declare const ContextMenuItem: ({ leftIcon, rightSlot, textValue, ...rest }: ContextMenuItemProps) => react_jsx_runtime.JSX.Element;
+declare const ContextMenuGroup: any;
+declare const ContextMenuSub: any;
+declare const ContextMenuSubTrigger: any;
+declare const ContextMenuSubContent: (props: React.ComponentProps<typeof ContextMenu$1.SubContent>) => react_jsx_runtime.JSX.Element;
+declare const ContextMenuSeparator: (props: React.ComponentProps<typeof ContextMenu$1.Separator>) => react_jsx_runtime.JSX.Element;
+declare const ContextMenuCheckboxItem: any;
+declare const ContextMenuRadioGroup: any;
+declare const ContextMenuRadioItem: any;
+declare const ContextMenuItemIndicator: (props: React.ComponentProps<typeof ContextMenu$1.ItemIndicator>) => react_jsx_runtime.JSX.Element;
+
+interface AutocompleteProps<T> {
+    placeholder?: string;
+    data: T[];
+    value?: string;
+    displayValue: (item: T) => string;
+    onSelect?: (selectedItem: T | null) => void;
+    onChange?: (value: string) => void;
+    noResultsMessage?: string;
+    maxResults?: number;
+    debounceTime?: number;
+    wrapperClassName?: string;
+    contentClassName?: string;
+    itemClassName?: string;
+}
+declare const Autocomplete: <T>({ placeholder, data, value, displayValue, onSelect, onChange, noResultsMessage, maxResults, debounceTime, wrapperClassName, contentClassName, itemClassName, }: AutocompleteProps<T>) => react_jsx_runtime.JSX.Element;
+
+export { Autocomplete, Calendar, Checkbox, ContextMenu, ContextMenuArrow, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuItemIndicator, ContextMenuLabel, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, DataTable, DatePicker, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogPortal, DialogTrigger, HorizontalTab, HorizontalTabs, InteractiveListItem, InteractiveListItemActions, InteractiveListItemContent, InteractiveListItemIcon, ModeTab, ModeTabs, MultipleSelect, MultipleSelectContent, MultipleSelectTrigger, MultipleSelectValue, RadioGroup, RadioItem, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectSeparator, SelectTrigger, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, Tooltip, TooltipArrow, TooltipContent, TooltipDescription, TooltipFooter, TooltipHeader, TooltipTrigger, VerticalMenu, VerticalMenus };

package/dist/esm/button/index.d.ts

@@ -1,8 +1,8 @@
-import { ButtonSizeStyles, ButtonVariantStyles } from "../button/styles";
 import React, { ReactNode } from "react";
+import { ButtonSize, ButtonVariant } from "./types";
 export interface ButtonProps extends React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> {
-    variant?: ButtonVariantStyles;
-    size?: ButtonSizeStyles;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
     fullWidth?: boolean;
     isLoading?: boolean;
     leftIcon?: ReactNode;

package/dist/esm/button/types.d.ts

@@ -0,0 +1,12 @@
+export declare const BUTTON_SIZES: {
+    readonly REGULAR: "regular";
+    readonly SMALL: "small";
+    readonly LARGE: "large";
+};
+export type ButtonSize = (typeof BUTTON_SIZES)[keyof typeof BUTTON_SIZES];
+export declare const BUTTON_VARIANTS: {
+    readonly ACCENT: "accent";
+    readonly OUTLINE: "outline";
+    readonly GHOST: "ghost";
+};
+export type ButtonVariant = (typeof BUTTON_VARIANTS)[keyof typeof BUTTON_VARIANTS];

package/dist/esm/client.d.ts

@@ -0,0 +1,16 @@
+export { RadioGroup, RadioItem } from "./radio-group";
+export { Checkbox } from "./checkbox";
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogPortal, DialogTrigger, } from "./dialog";
+export { Select, SelectTrigger, SelectContent, SelectGroup, SelectLabel, SelectSeparator, SelectItem, } from "./select";
+export { VerticalMenus, VerticalMenu } from "./vertical-menu";
+export { HorizontalTabs, HorizontalTab } from "./horizontal-tab";
+export { ModeTabs, ModeTab } from "./mode-tab";
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipArrow, TooltipHeader, TooltipDescription, TooltipFooter, } from "./tooltip";
+export { MultipleSelect, MultipleSelectTrigger, MultipleSelectContent, MultipleSelectValue, } from "./multiple-select";
+export { Table, TableHeader, TableBody, TableRow, TableHead, TableCell, } from "./table";
+export { DataTable } from "./data-table";
+export { InteractiveListItem, InteractiveListItemActions, InteractiveListItemContent, InteractiveListItemIcon, } from "./interactive-list-item";
+export { Calendar } from "./calendar";
+export { DatePicker } from "./date-picker";
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuArrow, ContextMenuLabel, ContextMenuItem, ContextMenuGroup, ContextMenuSub, ContextMenuSubTrigger, ContextMenuSubContent, ContextMenuSeparator, ContextMenuCheckboxItem, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuItemIndicator, } from "./context-menu";
+export { Autocomplete } from "./autocomplete";