@lotte-innovate/ui-component-test 0.0.0

package/README.md

@@ -0,0 +1,154 @@
+# radix-ui 라이브러리 활용 Storybook UI Component 만들기
+
+<br />
+
+## 사전 설치 라이브러리
+
+- radix-ui
+  - 주요 컴포넌트 사용 시 활용할 Headless UI 라이브러리
+
+```shell
+npm install @radix-ui/react-popover@latest -E
+```
+
+- storybook
+  - 컴포넌트 관리를 위해 사용
+
+```shell
+npx sb init
+npx storybook@latest add @storybook/addon-styling-webpack
+```
+
+- clsx
+  - 조건부 className 작성을 위해 사용
+
+```shell
+npm i clsx
+```
+
+- tailwind-merge
+  - 스타일 충돌 없이 자바스크립트에서 tailwind CSS 클래스를 효율적으로 병합하는 기능을 가진 라이브러리
+
+```shell
+npm i tailwind-merge
+```
+
+- class-variance-authority (CVA)
+  - 일관성 있는 UI를 정의하고 사용할 수 있도록 도와주는 툴로써 shadcn/ui 컴포넌트의 핵심 도구
+
+```shell
+npm i class-variance-authority
+```
+
+<br />
+
+## 실행
+
+- 스토리북 실행
+
+```shell
+npm run storybook
+```
+
+> 접속주소(포트 6006 사용 시): `http://localhost:6006`
+
+- 웹페이지 실행
+
+```shell
+npm run dev
+```
+
+> 접속주소(포트 3000 사용 시): `http://localhost:3000`
+
+## package publish
+
+- 타입스크립트 컴파일
+
+```shell
+npm run publish:npm
+```
+
+- npm package 배포 시
+
+  - npm 로그인
+
+  ```shell
+  npm login
+  ```
+
+  - package.json 버전 수정 후 컴파일 진행
+
+  ```shell
+  npm run publish:npm
+  ```
+
+  - 패키지 배포
+
+  ```shell
+  npm publish
+  ```
+
+- npm package 미배포시
+
+  - package.json 버전 수정 후 컴파일 진행
+
+  ```shell
+  npm run publish:npm
+  ```
+
+  - dist/ 파일 및 설정파일 추출 후 전달
+
+## 사용자 이용 방법
+
+### npm 배포 시
+
+- npm package 설치
+
+```sh
+npm install <package_name>
+```
+
+### npm 미배포시
+
+- 전달 받은 package 모듈 파일을 node_modules/ 폴더에 추가
+
+### tailwind 설정 방법
+
+- tailwind config 파일 설정
+
+```js
+// tailwind.config.ts
+import type { Config } from 'tailwindcss';
+// UI 라이브러리 tailwind config 파일 호출
+// >>>>>>>> 추가
+ const packageTailwindConfig = require('ui-component-test/tailwind.config.js');
+// >>>>>>>>
+
+const config: Config = {
+  content: [
+    './src/pages/**/*.{js,ts,jsx,tsx,mdx,zip}',
+    './src/components/**/*.{js,ts,jsx,tsx,mdx,zip}',
+    './src/app/**/*.{js,ts,jsx,tsx,mdx,zip}',
+// 해당 프로젝트 css 표준 컴포넌트에 적용 가능
+// >>>>>>>> 추가
+    './node_modules/ui-component-test/**/*.{js,ts,jsx,tsx,mdx,zip}',
+// >>>>>>>>
+  ],
+  theme: {
+    extend: {
+      backgroundImage: {
+        'gradient-radial': 'radial-gradient(var(--tw-gradient-stops))',
+        'gradient-conic': 'conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))',
+      },
+      colors: {},
+// UI 라이브러리 tailwind config 파일 적용
+// >>>>>>>> 추가
+      ...packageTailwindConfig?.theme?.extend,
+// >>>>>>>>
+    },
+  },
+  plugins: [],
+};
+export default config;
+
+```

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import { VariantProps } from 'class-variance-authority';
+import { IColor } from 'types';
+export interface AccordionProps extends React.InputHTMLAttributes<HTMLInputElement>, VariantProps<typeof accoridanVariants> {
+    defaultValue?: string;
+    color?: IColor;
+}
+declare const accoridanVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Accordion: React.ForwardRefExoticComponent<((Omit<AccordionPrimitive.AccordionSingleProps & React.RefAttributes<HTMLDivElement>, "ref"> | Omit<AccordionPrimitive.AccordionMultipleProps & React.RefAttributes<HTMLDivElement>, "ref">) & AccordionProps) & React.RefAttributes<HTMLDivElement>>;
+export declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & AccordionProps & React.RefAttributes<HTMLDivElement>>;
+export declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & AccordionProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & AccordionProps & React.RefAttributes<HTMLDivElement>>;
+export default Accordion;

package/dist/components/Accordion/index.jsx

@@ -0,0 +1,70 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React from 'react';
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import { ChevronDownIcon } from '@radix-ui/react-icons';
+import { cn } from '../../utils/utils';
+import { cva } from 'class-variance-authority';
+import { scalingVariants } from '../../constants';
+var accoridanVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var Accordion = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, children = _a.children, scaling = _a.scaling, rootProps = __rest(_a, ["className", "children", "scaling"]);
+    return (<AccordionPrimitive.Root className={cn('w-[280px] rounded-md border border-slateA-4 dark:border-slateDarkA-4', accoridanVariants({ scaling: scaling }), className)} {...rootProps} ref={forwardedRef}>
+      {children}
+    </AccordionPrimitive.Root>);
+});
+Accordion.displayName = 'AccordionRoot';
+export var AccordionItem = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, children = _a.children, rootProps = __rest(_a, ["className", "children"]);
+    return (<AccordionPrimitive.Item {...rootProps} ref={forwardedRef} className={cn('w-[278px] mt-px overflow-hidden first:mt-0 first:rounded-t last:rounded-b ', className)}>
+      {children}
+    </AccordionPrimitive.Item>);
+});
+AccordionItem.displayName = 'AccordionItem';
+export var AccordionTrigger = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, children = _a.children, _b = _a.color, color = _b === void 0 ? 'red' : _b, rootProps = __rest(_a, ["className", "children", "color"]);
+    return (<AccordionPrimitive.Header {...rootProps} className={cn('flex', className)}>
+      <AccordionPrimitive.Trigger {...rootProps} ref={forwardedRef} className={cn(" w-[278px] group flex h-[44px] cursor-default items-center justify-between py-[10px] px-[20px] text-base font-normal ", "dark:bg-[#111113] text-".concat(color, "A-11 dark:text-").concat(color, "Dark-11 "), "hover:bg-".concat(color, "A-4 dark:hover:bg-").concat(color, "Dark-4 hover:text-").concat(color, "A-11 dark:hover:text-").concat(color, "DarkA-11"), "data-[state=open]:bg-".concat(color, "A-5 dark:data-[state=open]:bg-").concat(color, "DarkA-5"), "disabled:bg-slateA-3 disabled:dark:bg-slateDarkA-3 disabled:text-slateA-3 disabled:dark:text-slateDarkA-8", className)}>
+        {children}
+        <ChevronDownIcon className="ease-[cubic-bezier(0.87,_0,_0.13,_1)] transition-transform duration-300 group-data-[state=open]:rotate-180" aria-hidden/>
+      </AccordionPrimitive.Trigger>
+    </AccordionPrimitive.Header>);
+});
+AccordionTrigger.displayName = 'AccordionTrigger';
+export var AccordionContent = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, children = _a.children, rootProps = __rest(_a, ["className", "children"]);
+    return (<AccordionPrimitive.Content {...rootProps} ref={forwardedRef} className={cn('w-[278px] max-h-[800px] bg-slateA-2 dark:bg-slateDarkA-2 border-t border-t-slateA-4 dark:border-t-slateDarkA-4 text-slateA-11 dark:text-slateDarkA-11 data-[state=open]:animate-slideDown data-[state=closed]:animate-slideUp overflow-hidden text-[16px]', className)}>
+      <div className="px-[20px] py-[15px] text-base font-normal h-auto max-h-[1000px] overflow-y-auto">
+        {children}
+      </div>
+    </AccordionPrimitive.Content>);
+});
+AccordionContent.displayName = 'AccordionContent';
+export default Accordion;

package/dist/components/AlertDialog/AlertDialogAction.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+import { IAppearance } from 'types';
+export interface AlertDialogActionProps extends VariantProps<typeof alertDialogActionVariants> {
+    appearance?: IAppearance;
+}
+export declare const alertDialogActionVariants: (props?: ({
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+    weight?: "medium" | "regular" | "semibold" | "bold" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/AlertDialog/AlertDialogAction.jsx

@@ -0,0 +1,60 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from 'utils/utils';
+import { appearanceStyle, primaryColorStyle, weightVariants } from '../../constants';
+export var alertDialogActionVariants = cva("inline-flex items-center justify-center px-[15px] outline-none focus:shadow-[0_0_0_2px] font-normal", {
+    variants: {
+        radius: {
+            none: 'rounded-none',
+            small: 'rounded-[3px]',
+            medium: 'rounded',
+            large: 'rounded',
+            full: 'rounded-full',
+        },
+        size: {
+            small: 'text-xs h-[24px] px-2',
+            medium: 'text-sm h-[32px] px-3',
+            large: 'text-sm h-[32px] px-3',
+            'x-large': 'text-base h-[40px] px-4',
+        },
+        weight: __assign({}, weightVariants),
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'large',
+        weight: 'medium',
+        size: 'medium',
+        color: 'red',
+    },
+});
+export var AlertDialogAction = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, radius = _a.radius, weight = _a.weight, size = _a.size, _b = _a.color, color = _b === void 0 ? 'red' : _b, _c = _a.appearance, appearance = _c === void 0 ? 'solid' : _c, props = __rest(_a, ["className", "children", "radius", "weight", "size", "color", "appearance"]);
+    var buttonClassName = cn(alertDialogActionVariants({ radius: radius, size: size, weight: weight, color: color }), appearanceStyle(appearance, color), className);
+    return (<AlertDialogPrimitive.Action ref={ref} className={buttonClassName} {...props}>
+        {children}
+      </AlertDialogPrimitive.Action>);
+});
+AlertDialogAction.displayName = 'AlertDialogAction';

package/dist/components/AlertDialog/AlertDialogCancel.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+import { IAppearance } from 'types';
+export interface AlertDialogCancelProps extends VariantProps<typeof alertDialogCancelVariants> {
+    appearance?: IAppearance;
+}
+export declare const alertDialogCancelVariants: (props?: ({
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+    weight?: "medium" | "regular" | "semibold" | "bold" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/AlertDialog/AlertDialogCancel.jsx

@@ -0,0 +1,57 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from 'utils/utils';
+import { weightVariants } from '../../constants';
+export var alertDialogCancelVariants = cva("inline-flex justify-center items-center text-slate-11 bg-slate-3 outline-none border-none\n    dark:text-slateDark-11 dark:bg-slateDark-3 dark:hover:bg-slateDarkA-4\n    active:border-none hover:cursor-pointer hover:bg-slateA-4", {
+    variants: {
+        radius: {
+            none: 'rounded-none',
+            small: 'rounded-[3px]',
+            medium: 'rounded',
+            large: 'rounded',
+            full: 'rounded-full',
+        },
+        size: {
+            small: 'text-xs h-[24px] px-2 mr-2',
+            medium: 'text-sm h-[32px] px-3 mr-2',
+            large: 'text-sm h-[32px] px-3 mr-3',
+            'x-large': 'text-base h-[40px] px-4 mr-3',
+        },
+        weight: __assign({}, weightVariants),
+    },
+    defaultVariants: {
+        radius: 'large',
+        weight: 'medium',
+        size: 'large',
+    },
+});
+export var AlertDialogCancel = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, radius = _a.radius, size = _a.size, weight = _a.weight, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, props = __rest(_a, ["className", "children", "radius", "size", "weight", "appearance"]);
+    return (<AlertDialogPrimitive.Cancel ref={ref} {...props} className={cn(alertDialogCancelVariants({ radius: radius, size: size, weight: weight }), className)}>
+      {children}
+    </AlertDialogPrimitive.Cancel>);
+});
+AlertDialogCancel.displayName = 'AlertDialogCancel';

package/dist/components/AlertDialog/AlertDialogContent.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+export interface AlertDialogContentProps extends VariantProps<typeof alertDialogContentVariants> {
+}
+export declare const alertDialogContentVariants: (props?: ({
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & AlertDialogContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/AlertDialog/AlertDialogContent.jsx

@@ -0,0 +1,53 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from 'utils/utils';
+import { radiusVariants, scalingVariants } from '../../constants';
+export var alertDialogContentVariants = cva("fixed max-h-[85vh] top-[50%] left-[50%] focus:outline-none\n  translate-x-[-50%] translate-y-[-50%] data-[state=open]:animate-contentShow bg-white dark:bg-slateDark-1 \n  shadow-[hsl(206_22%_7%_/_35%)_0px_10px_38px_-10px,_hsl(206_22%_7%_/_20%)_0px_10px_20px_-15px]", {
+    variants: {
+        size: {
+            small: 'p-3 w-[300px]',
+            medium: 'p-4 w-[400px]',
+            large: 'p-5 w-[500px]',
+            'x-large': 'p-6 w-[600px]',
+        },
+        scaling: __assign({}, scalingVariants),
+        radius: __assign({}, radiusVariants['extra-large']),
+    },
+    defaultVariants: {
+        radius: 'large',
+        size: 'large',
+    },
+});
+export var AlertDialogContent = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, radius = _a.radius, size = _a.size, scaling = _a.scaling, props = __rest(_a, ["className", "children", "radius", "size", "scaling"]);
+    return (<AlertDialogPrimitive.Portal>
+      <AlertDialogPrimitive.Overlay className="fixed data-[state=open]:animate-overlayShow inset-0"/>
+      <AlertDialogPrimitive.Content className={cn(alertDialogContentVariants({ radius: radius, size: size, scaling: scaling }), className)} ref={ref} {...props}>
+        {children}
+      </AlertDialogPrimitive.Content>
+    </AlertDialogPrimitive.Portal>);
+});
+AlertDialogContent.displayName = 'AlertDialogContent';

package/dist/components/AlertDialog/AlertDialogDescription.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+export interface AlertDialogDescriptionProps extends VariantProps<typeof alertDialogDescriptionVariants> {
+    contentText?: string;
+}
+export declare const alertDialogDescriptionVariants: (props?: ({
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;

package/dist/components/AlertDialog/AlertDialogDescription.jsx

@@ -0,0 +1,35 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from 'utils/utils';
+export var alertDialogDescriptionVariants = cva("text-slate-12 dark:text-slateDark-12 font-normal", {
+    variants: {
+        size: {
+            small: 'text-xs mb-3',
+            medium: 'text-sm mb-4',
+            large: 'text-base mb-5',
+            'x-large': 'text-lg mb-6',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var AlertDialogDescription = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, size = _a.size, contentText = _a.contentText, props = __rest(_a, ["className", "children", "size", "contentText"]);
+    return (<AlertDialogPrimitive.Description className={cn(alertDialogDescriptionVariants({ size: size }), className)} ref={ref} {...props}>
+      {contentText !== null && contentText !== void 0 ? contentText : children}
+    </AlertDialogPrimitive.Description>);
+});
+AlertDialogDescription.displayName = 'AlertDialogDescription';

package/dist/components/AlertDialog/AlertDialogTitle.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+export interface AlertDialogTitleProps extends VariantProps<typeof alertDialogTitleVariants> {
+    titleText?: string;
+}
+export declare const alertDialogTitleVariants: (props?: ({
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;

package/dist/components/AlertDialog/AlertDialogTitle.jsx

@@ -0,0 +1,35 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from 'utils/utils';
+export var alertDialogTitleVariants = cva("m-0 text-slate-12 dark:text-slateDark-12 font-bold", {
+    variants: {
+        size: {
+            small: 'text-sm mb-1',
+            medium: 'text-lg mb-2',
+            large: 'text-xl mb-3',
+            'x-large': 'text-2xl mb-4',
+        },
+    },
+    defaultVariants: {
+        size: 'large',
+    },
+});
+export var AlertDialogTitle = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, size = _a.size, titleText = _a.titleText, props = __rest(_a, ["className", "children", "size", "titleText"]);
+    return (<AlertDialogPrimitive.Title className={cn(alertDialogTitleVariants({ size: size }), className)} ref={ref} {...props}>
+      {titleText !== null && titleText !== void 0 ? titleText : children}
+    </AlertDialogPrimitive.Title>);
+});
+AlertDialogTitle.displayName = 'AlertDialogTitle';

package/dist/components/AlertDialog/AlertDialogTrigger.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+import { IAppearance, IColor } from 'types';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    color?: IColor;
+    appearance?: IAppearance;
+}
+declare const buttonVariants: (props?: ({
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    weight?: "medium" | "regular" | "semibold" | "bold" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const AlertDialogTrigger: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/AlertDialog/AlertDialogTrigger.jsx

@@ -0,0 +1,56 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { radiusVariants, scalingVariants, weightVariants, primaryColorStyle, appearanceStyle, } from '../../constants';
+import { cn } from 'utils/utils';
+var buttonVariants = cva("inline-flex items-center transition-colors focus:outline-none hover:cursor-pointer\n  disabled:cursor-not-allowed disabled:bg-slate-3 disabled:text-slate-8", {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+        size: {
+            small: 'text-xs h-[24px] px-2',
+            medium: 'text-sm h-[32px] px-3',
+            large: 'text-base h-[40px] px-4',
+            'x-large': 'text-lg h-[48px] px-6',
+        },
+        scaling: __assign({}, scalingVariants),
+        weight: __assign({}, weightVariants),
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'large',
+        scaling: '100%',
+        weight: 'medium',
+        color: 'red',
+        size: 'large',
+    },
+});
+export var AlertDialogTrigger = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, radius = _a.radius, scaling = _a.scaling, size = _a.size, weight = _a.weight, _b = _a.color, color = _b === void 0 ? 'red' : _b, _c = _a.appearance, appearance = _c === void 0 ? 'solid' : _c, props = __rest(_a, ["children", "className", "radius", "scaling", "size", "weight", "color", "appearance"]);
+    var buttonClassName = cn(buttonVariants({ radius: radius, scaling: scaling, size: size, weight: weight, color: color }), appearanceStyle(appearance, color), className);
+    return (<AlertDialogPrimitive.Trigger asChild ref={ref} className={buttonClassName} {...props}>
+        {children}
+      </AlertDialogPrimitive.Trigger>);
+});
+AlertDialogTrigger.displayName = 'AlertDialogTrigger';

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+import { alertDialogContentVariants } from './AlertDialogContent';
+import { alertDialogTitleVariants } from './AlertDialogTitle';
+import { alertDialogDescriptionVariants } from './AlertDialogDescription';
+import { IColor } from 'types';
+export * from './AlertDialogTrigger';
+export * from './AlertDialogContent';
+export * from './AlertDialogTitle';
+export * from './AlertDialogDescription';
+export * from './AlertDialogCancel';
+export * from './AlertDialogAction';
+export interface AlertDialogProps extends VariantProps<typeof alertDialogContentVariants>, VariantProps<typeof alertDialogTitleVariants>, VariantProps<typeof alertDialogDescriptionVariants> {
+    titleText?: string;
+    contentText?: string;
+    color?: IColor;
+}
+export declare const AlertDialog: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogProps & AlertDialogProps & React.RefAttributes<never>>;
+export default AlertDialog;