@lotte-innovate/ui-component-test 0.2.25 → 0.2.27

package/dist/lib/components/AlertDialog/AlertDialogContent.js

@@ -0,0 +1,52 @@
+'use client';
+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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { radiusVariants, scalingVariants } from '../../../lib/constants';
+import { useAlertDialogContext } from './AlertDialogRoot';
+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, props = __rest(_a, ["className", "children"]);
+    var _b = useAlertDialogContext(), radius = _b.radius, size = _b.size, scaling = _b.scaling;
+    return (_jsxs(AlertDialogPrimitive.Portal, { children: [_jsx(AlertDialogPrimitive.Overlay, { className: "fixed inset-0 data-[state=open]:animate-overlayShow" }), _jsx(AlertDialogPrimitive.Content, __assign({ className: cn(alertDialogContentVariants({ radius: radius, size: size, scaling: scaling }), className), ref: ref }, props, { children: children }))] }));
+});
+AlertDialogContent.displayName = 'AlertDialog.Content';

package/dist/lib/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/lib/components/AlertDialog/AlertDialogDescription.js

@@ -0,0 +1,48 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { useAlertDialogContext } from './AlertDialogRoot';
+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, contentText = _a.contentText, props = __rest(_a, ["className", "children", "contentText"]);
+    var size = useAlertDialogContext().size;
+    return (_jsx(AlertDialogPrimitive.Description, __assign({ className: cn(alertDialogDescriptionVariants({ size: size }), className), ref: ref }, props, { children: contentText !== null && contentText !== void 0 ? contentText : children })));
+});
+AlertDialogDescription.displayName = 'AlertDialog.Description';

package/dist/lib/components/AlertDialog/AlertDialogRoot.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { VariantProps } from 'class-variance-authority';
+import { IAppearance, IColor } from '../../../lib/types';
+import { alertDialogContentVariants } from './AlertDialogContent';
+import { alertDialogTitleVariants } from './AlertDialogTitle';
+import { alertDialogDescriptionVariants } from './AlertDialogDescription';
+import { alertDialogActionVariants } from './AlertDialogAction';
+export interface AlertDialogProps extends VariantProps<typeof alertDialogContentVariants>, VariantProps<typeof alertDialogTitleVariants>, VariantProps<typeof alertDialogDescriptionVariants>, VariantProps<typeof alertDialogActionVariants> {
+    titleText?: string;
+    contentText?: string;
+    color?: IColor;
+    appearance?: IAppearance;
+}
+export declare const useAlertDialogContext: () => AlertDialogProps;
+export declare const AlertDialogRoot: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogProps & AlertDialogProps & React.RefAttributes<never>>;

package/dist/lib/components/AlertDialog/AlertDialogRoot.js

@@ -0,0 +1,50 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, createContext, useContext, } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { useTheme } from '../../../lib/theme';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+var AlertDialogContext = createContext({
+    size: 'medium',
+    scaling: '100%',
+    color: MAIN_COLOR,
+    radius: 'medium',
+    appearance: 'solid',
+});
+export var useAlertDialogContext = function () {
+    return useContext(AlertDialogContext);
+};
+export var AlertDialogRoot = forwardRef(function (_a, ref) {
+    var children = _a.children, radius = _a.radius, size = _a.size, scaling = _a.scaling, color = _a.color, props = __rest(_a, ["children", "radius", "size", "scaling", "color"]);
+    var theme = useTheme().theme;
+    var contextValue = {
+        radius: radius !== null && radius !== void 0 ? radius : theme.themeRadius,
+        scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling,
+        color: color !== null && color !== void 0 ? color : theme.themeColor,
+        size: size,
+    };
+    return (_jsx(AlertDialogContext.Provider, { value: contextValue, children: _jsx("div", { ref: ref, children: _jsx(AlertDialogPrimitive.Root, __assign({}, props, { children: children })) }) }));
+});
+AlertDialogRoot.displayName = 'AlertDialog.Root';

package/dist/lib/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/lib/components/AlertDialog/AlertDialogTitle.js

@@ -0,0 +1,48 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { useAlertDialogContext } from './AlertDialogRoot';
+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, titleText = _a.titleText, props = __rest(_a, ["className", "children", "titleText"]);
+    var size = useAlertDialogContext().size;
+    return (_jsx(AlertDialogPrimitive.Title, __assign({ className: cn(alertDialogTitleVariants({ size: size }), className), ref: ref }, props, { children: titleText !== null && titleText !== void 0 ? titleText : children })));
+});
+AlertDialogTitle.displayName = 'AlertDialog.Title';

package/dist/lib/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 '../../../lib/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/lib/components/AlertDialog/AlertDialogTrigger.js

@@ -0,0 +1,67 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { radiusVariants, scalingVariants, weightVariants, primaryColorStyle, appearanceStyle, } from '../../../lib/constants';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+import { useTheme } from '../../../lib/theme';
+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: MAIN_COLOR,
+        size: 'medium',
+    },
+});
+export var AlertDialogTrigger = forwardRef(function (_a, ref) {
+    var _b;
+    var children = _a.children, className = _a.className, radius = _a.radius, scaling = _a.scaling, size = _a.size, weight = _a.weight, color = _a.color, _c = _a.appearance, appearance = _c === void 0 ? 'solid' : _c, props = __rest(_a, ["children", "className", "radius", "scaling", "size", "weight", "color", "appearance"]);
+    var theme = useTheme().theme;
+    var buttonStyle = {
+        radius: radius !== null && radius !== void 0 ? radius : theme.themeRadius,
+        scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling,
+        weight: weight !== null && weight !== void 0 ? weight : theme.themeWeight,
+        color: (_b = color !== null && color !== void 0 ? color : theme.themeColor) !== null && _b !== void 0 ? _b : MAIN_COLOR,
+        size: size,
+    };
+    var buttonClassName = cn(buttonVariants(buttonStyle), appearanceStyle(appearance, buttonStyle.color), className);
+    return (_jsx(AlertDialogPrimitive.Trigger, __assign({ asChild: true, ref: ref, className: buttonClassName }, props, { children: children })));
+});
+AlertDialogTrigger.displayName = 'AlertDialog.Trigger';

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+declare const AlertDialog: {
+    Root: import("react").ForwardRefExoticComponent<import("@radix-ui/react-alert-dialog").AlertDialogProps & import("./AlertDialogRoot").AlertDialogProps & import("react").RefAttributes<never>>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./AlertDialogTrigger").ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./AlertDialogContent").AlertDialogContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Title: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>, "ref"> & import("./AlertDialogTitle").AlertDialogTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+    Description: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>, "ref"> & import("./AlertDialogDescription").AlertDialogDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
+    Cancel: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogCancelProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./AlertDialogCancel").AlertDialogCancelProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Action: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-alert-dialog").AlertDialogActionProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./AlertDialogAction").AlertDialogActionProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export default AlertDialog;

package/dist/lib/components/AlertDialog/index.js

@@ -0,0 +1,17 @@
+import { AlertDialogRoot as Root } from './AlertDialogRoot';
+import { AlertDialogTrigger as Trigger } from './AlertDialogTrigger';
+import { AlertDialogContent as Content } from './AlertDialogContent';
+import { AlertDialogTitle as Title } from './AlertDialogTitle';
+import { AlertDialogDescription as Description } from './AlertDialogDescription';
+import { AlertDialogCancel as Cancel } from './AlertDialogCancel';
+import { AlertDialogAction as Action } from './AlertDialogAction';
+var AlertDialog = {
+    Root: Root,
+    Trigger: Trigger,
+    Content: Content,
+    Title: Title,
+    Description: Description,
+    Cancel: Cancel,
+    Action: Action,
+};
+export default AlertDialog;

package/dist/lib/components/AspectRatio/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import { VariantProps } from 'class-variance-authority';
+export interface AspectRatioProps extends VariantProps<typeof aspectRatioVariants> {
+}
+export declare const aspectRatioVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const AspectRatio: React.ForwardRefExoticComponent<Omit<AspectRatioPrimitive.AspectRatioProps & React.RefAttributes<HTMLDivElement>, "ref"> & AspectRatioProps & React.RefAttributes<HTMLDivElement>>;
+export default AspectRatio;

package/dist/lib/components/AspectRatio/index.js

@@ -0,0 +1,45 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { scalingVariants } from '../../../lib/constants';
+import { useTheme } from '../../../lib/theme';
+export var aspectRatioVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+var AspectRatio = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, _b = _a.ratio, ratio = _b === void 0 ? 16 / 9 : _b, scaling = _a.scaling, props = __rest(_a, ["children", "className", "ratio", "scaling"]);
+    var theme = useTheme().theme;
+    return (_jsx(AspectRatioPrimitive.Root, __assign({ ratio: ratio, ref: ref }, props, { className: cn(aspectRatioVariants({ scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling }), className), children: children })));
+});
+AspectRatio.displayName = 'AspectRatio';
+export default AspectRatio;

package/dist/lib/components/Avatar/index.d.ts

@@ -0,0 +1,21 @@
+import React, { ReactElement } from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface AvatarProps extends VariantProps<typeof AvatarVariants> {
+    imagePath?: string;
+    alt?: string;
+    fallback?: ReactElement | string;
+    appearance?: 'solid' | 'soft';
+    fallbackClassName?: string;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    title?: string;
+    delayMs?: number;
+}
+declare const AvatarVariants: (props?: ({
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const Avatar: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export default Avatar;

package/dist/lib/components/Avatar/index.js

@@ -0,0 +1,67 @@
+'use client';
+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 { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import * as AvatarPrimitive from '@radix-ui/react-avatar';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { appearanceStyle, primaryColorStyle, radiusVariants, scalingVariants } from '../../../lib/constants';
+import { useTheme } from '../../../lib/theme/ThemeProvider';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+var AvatarVariants = cva('font-medium', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+        size: {
+            '1': 'h-[24px] w-[24px] text-[12px]',
+            '2': 'h-[32px] w-[32px] text-[14px]',
+            '3': 'h-[40px] w-[40px] text-[16px]',
+            '4': 'h-[48px] w-[48px] text-[18px]',
+            '5': 'h-[64px] w-[64px] text-[24px]',
+            '6': 'h-[80px] w-[80px] text-[28px]',
+            '7': 'h-[96px] w-[96px] text-[28px]',
+            '8': 'h-[128px] w-[128px] text-[35px]',
+            '9': 'h-[160px] w-[160px] text-[60px]',
+        },
+        scaling: __assign({}, scalingVariants),
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'full',
+        color: MAIN_COLOR,
+        size: '3',
+    },
+});
+var Avatar = forwardRef(function (_a, ref) {
+    var className = _a.className, fallbackClassName = _a.fallbackClassName, radius = _a.radius, scaling = _a.scaling, size = _a.size, fallback = _a.fallback, imagePath = _a.imagePath, alt = _a.alt, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, color = _a.color, ariaLabel = _a.ariaLabel, ariaLabelledby = _a.ariaLabelledby, title = _a.title, _c = _a.delayMs, delayMs = _c === void 0 ? 300 : _c, props = __rest(_a, ["className", "fallbackClassName", "radius", "scaling", "size", "fallback", "imagePath", "alt", "appearance", "color", "ariaLabel", "ariaLabelledby", "title", "delayMs"]);
+    var theme = useTheme().theme;
+    var avatarStyle = {
+        radius: radius !== null && radius !== void 0 ? radius : theme.themeRadius,
+        scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling,
+        color: color !== null && color !== void 0 ? color : theme.themeColor,
+    };
+    var imgAltText = alt || ariaLabel || 'Avatar Image';
+    return (_jsxs(AvatarPrimitive.Root, __assign({ className: cn("inline-flex select-none items-center justify-center overflow-hidden align-middle", AvatarVariants(avatarStyle), appearanceStyle(appearance, avatarStyle.color, false), className) }, props, { ref: ref, role: "img", "aria-label": ariaLabel || imgAltText, "aria-labelledby": ariaLabelledby, title: title || imgAltText, tabIndex: 0, children: [_jsx(AvatarPrimitive.Image, { className: "h-full w-full border-none object-cover", src: imagePath, alt: imgAltText, title: title || imgAltText }), _jsx(AvatarPrimitive.Fallback, { className: cn("leading-1 flex h-full w-full items-center justify-center", className), delayMs: delayMs, "aria-hidden": "true", children: fallback })] })));
+});
+Avatar.displayName = 'Avatar';
+export default Avatar;

package/dist/lib/components/Badge/index.d.ts

@@ -0,0 +1,18 @@
+import React, { HTMLAttributes } from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IColor, IAppearance, ISize, IWeight } from '../../../lib/types';
+export interface BadgeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof BadgeVariants> {
+    color?: IColor;
+    appearance?: Exclude<IAppearance, 'classic' | 'ghost'>;
+    size?: Exclude<ISize, 'x-small' | 'x-large'>;
+    weight?: IWeight;
+}
+declare const BadgeVariants: (props?: ({
+    radius?: "none" | "small" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "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;
+declare const Badge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & BadgeProps & React.RefAttributes<HTMLDivElement>>;
+export default Badge;

package/dist/lib/components/Badge/index.js

@@ -0,0 +1,65 @@
+'use client';
+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 { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { appearanceStyle, primaryColorStyle, radiusVariants, scalingVariants, weightVariants, } from '../../../lib/constants';
+import { useTheme } from '../../../lib/theme';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+var BadgeVariants = cva('inline-flex items-center transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 w-fit', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+        size: {
+            small: 'text-xs h-[20px] px-1.5 py-0.5',
+            medium: 'text-xs h-[24px] px-2 py-1',
+            large: 'text-sm h-[28px] px-2.5 py-1',
+        },
+        scaling: __assign({}, scalingVariants),
+        weight: __assign({}, weightVariants),
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'medium',
+        size: 'medium',
+        scaling: '100%',
+        weight: 'medium',
+        color: MAIN_COLOR,
+    },
+});
+var Badge = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, radius = _a.radius, scaling = _a.scaling, weight = _a.weight, size = _a.size, color = _a.color, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, props = __rest(_a, ["className", "children", "radius", "scaling", "weight", "size", "color", "appearance"]);
+    var theme = useTheme().theme;
+    var badgeStyle = {
+        radius: radius !== null && radius !== void 0 ? radius : theme.themeRadius,
+        scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling,
+        weight: weight !== null && weight !== void 0 ? weight : theme.themeWeight,
+        color: color !== null && color !== void 0 ? color : theme.themeColor,
+        size: size,
+    };
+    var badgeClassName = cn(BadgeVariants(badgeStyle), appearanceStyle(appearance, badgeStyle.color, false), className);
+    return (_jsx("div", __assign({ ref: ref, className: badgeClassName }, props, { children: children })));
+});
+Badge.displayName = 'Badge';
+export default Badge;

package/dist/lib/components/BarChart/index.d.ts

@@ -0,0 +1,33 @@
+import { VariantProps } from 'class-variance-authority';
+import { IChartDatasets, IChartLegend, IChartTitle } from '../../../lib/types';
+export interface BorderRadius {
+    topLeft: number;
+    topRight: number;
+    bottomLeft: number;
+    bottomRight: number;
+}
+type IBarchartDataset = IChartDatasets & {
+    data: number[];
+    barThickness?: number;
+    barPercentage?: number;
+};
+export interface BarChartProps extends VariantProps<typeof barChartVariants> {
+    labels?: string[];
+    isColorMixed?: boolean;
+    appearance?: 'solid' | 'soft';
+    title?: IChartTitle;
+    legend?: IChartLegend;
+    datasets: IBarchartDataset[];
+    indexAxis?: 'x' | 'y';
+    className?: string;
+    width?: string | number;
+    height?: string | number;
+}
+declare const barChartVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const BarChart: {
+    ({ className, title, datasets, labels, scaling, legend, width, height, indexAxis, appearance, isColorMixed, ...props }: BarChartProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default BarChart;