@lotte-innovate/ui-component-test 0.1.49 → 0.1.51

package/dist/cjs/lib/components/DropdownMenu/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+declare const DropdownMenu: {
+    Root: {
+        ({ children, radius, size, scaling, color, appearance, ...props }: import("@radix-ui/react-dropdown-menu").DropdownMenuProps & import("./DropdownMenuRoot").DropdownMenuProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./DropdownMenuTrigger").DropdownMenuTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuContent").DropdownMenuContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuLabelProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuLable").DropdownMenuLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuItem").DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    Separator: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    CheckboxItem: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuCheckboxItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuItem").DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    RadioGroup: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuRadioGroupProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    RadioItem: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuRadioItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuRadioItem").DropdownMenuRadioItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    Sub: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuLabelProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<never>>;
+    SubTrigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuSubTriggerProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdownMenuItem").DropdownMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    SubContent: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./DropdonMenuSubContent").DropdownMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    ItemIndicator: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-dropdown-menu").DropdownMenuItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("./DropdownMenuItemIndicator").DropdownMenuItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+};
+export default DropdownMenu;

package/dist/cjs/lib/components/DropdownMenu/index.js

@@ -0,0 +1,29 @@
+import { DropdownMenuRoot } from './DropdownMenuRoot';
+import { DropdownMenuTrigger } from './DropdownMenuTrigger';
+import { DropdownMenuContent } from './DropdownMenuContent';
+import { DropdownMenuLabel } from './DropdownMenuLable';
+import { DropdownMenuItem } from './DropdownMenuItem';
+import { DropdownMenuSeparator } from './DropdownMenuSeparator';
+import { DropdownMenuCheckboxItem } from './DropdownMenuCheckboxItem';
+import { DropdownMenuRadioGroup } from './DropdonMenuRadioGroup';
+import { DropdownMenuRadioItem } from './DropdownMenuRadioItem';
+import { DropdownMenuSub } from './DropdownMenuSub';
+import { DropdownMenuSubTrigger } from './DropdownMenuSubTrigger';
+import { DropdownMenuSubContent } from './DropdonMenuSubContent';
+import { DropdownMenuItemIndicator } from './DropdownMenuItemIndicator';
+var DropdownMenu = {
+    Root: DropdownMenuRoot,
+    Trigger: DropdownMenuTrigger,
+    Content: DropdownMenuContent,
+    Label: DropdownMenuLabel,
+    Item: DropdownMenuItem,
+    Separator: DropdownMenuSeparator,
+    CheckboxItem: DropdownMenuCheckboxItem,
+    RadioGroup: DropdownMenuRadioGroup,
+    RadioItem: DropdownMenuRadioItem,
+    Sub: DropdownMenuSub,
+    SubTrigger: DropdownMenuSubTrigger,
+    SubContent: DropdownMenuSubContent,
+    ItemIndicator: DropdownMenuItemIndicator,
+};
+export default DropdownMenu;

package/dist/cjs/lib/components/HoverCard/HoverCardContent.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { HoverCard as HoverCardTheme } from '@radix-ui/themes';
+export interface HoverCardContentProps extends VariantProps<typeof hoverCardContentVariants> {
+    size?: any;
+}
+export declare const hoverCardContentVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | "x-large" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    weight?: "bold" | "medium" | "regular" | "semibold" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardTheme.ContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & HoverCardContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/cjs/lib/components/HoverCard/HoverCardContent.js

@@ -0,0 +1,61 @@
+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, useContext } from 'react';
+import { primaryColorStyle, radiusVariants, weightVariants, scalingVariants } from 'lib/constants';
+import { cva } from 'class-variance-authority';
+import { HoverCard as HoverCardTheme } from '@radix-ui/themes';
+import { HoverCardContext } from './HoverCardRoot';
+import { cn } from 'lib/utils/utils';
+export var hoverCardContentVariants = cva('', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+        size: {
+            small: 'text-xs w-[250px]',
+            medium: 'text-sm w-[300px]',
+            large: 'text-base w-[350px]',
+            'x-large': 'text-lg w-[400px]',
+        },
+        scaling: __assign({}, scalingVariants),
+        weight: __assign({}, weightVariants),
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'medium',
+        size: 'medium',
+        scaling: '100%',
+        weight: 'medium',
+        color: 'white',
+    },
+});
+export var HoverCardContent = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    var _b = useContext(HoverCardContext), radius = _b.radius, size = _b.size, scaling = _b.scaling, weight = _b.weight, color = _b.color;
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(HoverCardTheme.Content, __assign({ ref: ref }, props, { size: sizeTheme, className: cn(hoverCardContentVariants({ size: size, scaling: scaling, weight: weight, radius: radius, color: color }), size === 'x-large' && 'rt-r-size-4', className), children: children })));
+});
+HoverCardContent.displayName = 'HoverCard.Content';

package/dist/cjs/lib/components/HoverCard/HoverCardRoot.d.ts

@@ -0,0 +1,11 @@
+import React, { ComponentPropsWithoutRef } from 'react';
+import { HoverCard as HoverCardTheme } from '@radix-ui/themes';
+import { hoverCardContentVariants } from './HoverCardContent';
+import { VariantProps } from 'class-variance-authority';
+export interface HoverCardProps extends VariantProps<typeof hoverCardContentVariants> {
+}
+export declare const HoverCardContext: React.Context<HoverCardProps>;
+export declare const HoverCardRoot: {
+    ({ children, radius, size, scaling, weight, color, ...props }: ComponentPropsWithoutRef<typeof HoverCardTheme.Root> & HoverCardProps): React.JSX.Element;
+    displayName: string;
+};

package/dist/cjs/lib/components/HoverCard/HoverCardRoot.js

@@ -0,0 +1,38 @@
+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 { createContext } from 'react';
+import { HoverCard as HoverCardTheme, Theme } from '@radix-ui/themes';
+export var HoverCardContext = createContext({
+    radius: 'medium',
+    size: 'medium',
+    scaling: '100%',
+    weight: 'medium',
+    color: 'red',
+});
+export var HoverCardRoot = function (_a) {
+    var children = _a.children, radius = _a.radius, size = _a.size, scaling = _a.scaling, weight = _a.weight, color = _a.color, props = __rest(_a, ["children", "radius", "size", "scaling", "weight", "color"]);
+    var contextValue = { radius: radius, size: size, scaling: scaling, weight: weight, color: color };
+    return (_jsx(Theme, { children: _jsx(HoverCardContext.Provider, { value: contextValue, children: _jsx(HoverCardTheme.Root, __assign({}, props, { children: children })) }) }));
+};
+HoverCardRoot.displayName = 'HoverCard.Root';

package/dist/cjs/lib/components/HoverCard/HoverCardTrigger.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { HoverCard as HoverCardTheme } from '@radix-ui/themes';
+export declare const HoverCardTrigger: React.ForwardRefExoticComponent<Omit<HoverCardTheme.TriggerProps & React.RefAttributes<HTMLAnchorElement>, "ref"> & React.RefAttributes<HTMLAnchorElement>>;

package/dist/cjs/lib/components/HoverCard/HoverCardTrigger.js

@@ -0,0 +1,30 @@
+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 { HoverCard as HoverCardTheme } from '@radix-ui/themes';
+export var HoverCardTrigger = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    return (_jsx(HoverCardTheme.Trigger, __assign({ ref: ref, className: className }, props, { children: children })));
+});
+HoverCardTrigger.displayName = 'HoverCard.Trigger';

package/dist/cjs/lib/components/HoverCard/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+declare const HoverCard: {
+    Root: {
+        ({ children, radius, size, scaling, weight, color, ...props }: import("@radix-ui/themes/dist/cjs/components/hover-card").RootProps & import("./HoverCardRoot").HoverCardProps): import("react").JSX.Element;
+        displayName: string;
+    };
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/hover-card").TriggerProps & import("react").RefAttributes<HTMLAnchorElement>, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/hover-card").ContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./HoverCardContent").HoverCardContentProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export default HoverCard;

package/dist/cjs/lib/components/HoverCard/index.js

@@ -0,0 +1,9 @@
+import { HoverCardRoot } from './HoverCardRoot';
+import { HoverCardTrigger } from './HoverCardTrigger';
+import { HoverCardContent } from './HoverCardContent';
+var HoverCard = {
+    Root: HoverCardRoot,
+    Trigger: HoverCardTrigger,
+    Content: HoverCardContent,
+};
+export default HoverCard;

package/dist/cjs/lib/components/IconButton/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IAppearance } from 'lib/types';
+export interface IconButtonProps extends VariantProps<typeof iconButtonVariants> {
+    appearance?: IAppearance;
+    size?: 'x-small' | 'small' | 'medium' | 'large' | 'x-large';
+}
+declare const iconButtonVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    size?: "small" | "medium" | "large" | "x-small" | "x-large" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const IconButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default IconButton;

package/dist/cjs/lib/components/IconButton/index.js

@@ -0,0 +1,63 @@
+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 React, { Children, forwardRef } from 'react';
+import { cva } from 'class-variance-authority';
+import { scalingVariants, radiusVariants, primaryColorStyle, appearanceStyle } from 'lib/constants';
+import { cn } from 'lib/utils/utils';
+var iconButtonVariants = cva("grid place-content-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']),
+        scaling: __assign({}, scalingVariants),
+        size: {
+            'x-small': 'p-1 w-5 h-5',
+            small: 'p-[6px] w-6 h-6',
+            medium: 'p-2 w-8 h-8',
+            large: 'p-[11px] w-10 h-10',
+            'x-large': 'p-[14px] w-12 h-12',
+        },
+        color: primaryColorStyle(),
+    },
+    defaultVariants: {
+        radius: 'medium',
+        scaling: '100%',
+        size: 'medium',
+        color: 'red',
+    },
+});
+var iconSize = {
+    'x-small': 12,
+    small: 14,
+    medium: 16,
+    large: 18,
+    'x-large': 20,
+};
+export var IconButton = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, radius = _a.radius, _b = _a.size, size = _b === void 0 ? 'medium' : _b, scaling = _a.scaling, _c = _a.color, color = _c === void 0 ? 'red' : _c, _d = _a.appearance, appearance = _d === void 0 ? 'solid' : _d, props = __rest(_a, ["children", "className", "radius", "size", "scaling", "color", "appearance"]);
+    var width = iconSize[size];
+    var height = iconSize[size];
+    var buttonClassName = cn(iconButtonVariants({ radius: radius, scaling: scaling, size: size, color: color }), appearanceStyle(appearance, color, true), className);
+    return (_jsx("button", __assign({ ref: ref, className: buttonClassName }, props, { children: Children.map(children, function (child) { return React.cloneElement(child, { width: width, height: height }); }) })));
+});
+IconButton.displayName = 'IconButton';
+export default IconButton;

package/dist/cjs/lib/components/Inset/index.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface InsetProps extends VariantProps<typeof insetVariants> {
+}
+declare const insetVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Inset: React.ForwardRefExoticComponent<Omit<import("@radix-ui/themes").InsetProps & React.RefAttributes<HTMLDivElement>, "ref"> & InsetProps & React.RefAttributes<HTMLDivElement>>;
+export default Inset;

package/dist/cjs/lib/components/Inset/index.js

@@ -0,0 +1,50 @@
+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 { Inset as InsetTheme, Theme } from '@radix-ui/themes';
+import { scalingVariants } from 'lib/constants';
+import { cn } from 'lib/utils/utils';
+var insetVariants = cva('border-[1px] border-slate-6 dark:border-slateDark-6 text-slate-12 dark:text-slateDark-12', {
+    variants: {
+        radius: {
+            none: 'rounded-none after:rounded-none',
+            small: 'rounded-[3px] after:rounded-[3px]',
+            medium: 'rounded after:rounded',
+            large: 'rounded-md after:rounded-md',
+            full: 'rounded-md after:rounded-md',
+        },
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        radius: 'medium',
+        scaling: '100%',
+    },
+});
+export var Inset = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, radius = _a.radius, scaling = _a.scaling, props = __rest(_a, ["children", "className", "radius", "scaling"]);
+    return (_jsx(Theme, { children: _jsx(InsetTheme, __assign({ ref: ref, className: cn(insetVariants({ radius: radius, scaling: scaling }), className) }, props, { children: children })) }));
+});
+Inset.displayName = 'Inset';
+export default Inset;

package/dist/cjs/lib/components/Label/index.d.ts

@@ -0,0 +1,17 @@
+import * as LabelPrimitive from '@radix-ui/react-label';
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IColor } from 'lib/types';
+export interface LabelProps extends VariantProps<typeof labeVariants> {
+    defaultValue?: string;
+    color?: IColor;
+    size?: 'small' | 'medium' | 'large';
+}
+declare const labeVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    weight?: "bold" | "medium" | "regular" | "semibold" | null | undefined;
+    size?: "small" | "medium" | "large" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & LabelProps & React.RefAttributes<HTMLLabelElement>>;
+export default Label;

package/dist/cjs/lib/components/Label/index.js

@@ -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 { jsx as _jsx } from "react/jsx-runtime";
+import * as LabelPrimitive from '@radix-ui/react-label';
+import React from 'react';
+import { cn } from 'lib/utils/utils';
+import { cva } from 'class-variance-authority';
+import { scalingVariants, textColorStyle, weightVariants } from 'lib/constants';
+var labeVariants = cva('text-slate-12', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+        weight: __assign({}, weightVariants),
+        size: {
+            small: 'text-xs',
+            medium: 'text-sm',
+            large: 'text-base',
+        },
+        color: textColorStyle(),
+    },
+    defaultVariants: {
+        scaling: '100%',
+        size: 'medium',
+        color: 'black',
+    },
+});
+export var Label = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, scaling = _a.scaling, weight = _a.weight, size = _a.size, color = _a.color, children = _a.children, rootProps = __rest(_a, ["className", "scaling", "weight", "size", "color", "children"]);
+    if (weight === 'medium' || weight === 'semibold')
+        weight = 'bold';
+    return (_jsx(LabelPrimitive.Root, __assign({}, rootProps, { ref: forwardedRef, className: cn('', labeVariants({ scaling: scaling, size: size, weight: weight, color: color }), className), children: children })));
+});
+Label.displayName = 'Label';
+export default Label;

package/dist/cjs/lib/components/LineChart/index.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+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 ILinechartDataset = IChartDatasets & {
+    data: any;
+    barThickness?: number;
+    barPercentage?: number;
+};
+export interface LineChartProps extends VariantProps<typeof lineChartVariants> {
+    labels?: string[];
+    isColorMixed?: boolean;
+    appearance?: 'solid' | 'soft';
+    title?: IChartTitle;
+    legend?: IChartLegend;
+    datasets: ILinechartDataset[];
+    scales?: {
+        x?: {
+            min?: number;
+            max?: number;
+        };
+        y?: {
+            min?: number;
+            max?: number;
+        };
+    };
+    indexAxis?: 'x' | 'y';
+    className?: string;
+    width?: string | number;
+    height?: string | number;
+}
+declare const lineChartVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare const LineChart: {
+    ({ className, title, datasets, labels, scaling, legend, width, height, indexAxis, appearance, scales, isColorMixed, ...props }: LineChartProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default LineChart;

package/dist/cjs/lib/components/LineChart/index.js

@@ -0,0 +1,61 @@
+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 { Line } from 'react-chartjs-2';
+import { Chart as ChartJS, CategoryScale, LinearScale, Tooltip, Legend, LineElement, PointElement, } from 'chart.js/auto';
+import { scalingVariants } from 'lib/constants';
+import { cva } from 'class-variance-authority';
+import { cn } from 'lib/utils/utils';
+import { chartAlphaColorList, chartColorList } from 'lib/color/constants';
+import { useDarkMode } from 'lib/utils/useDarkMode';
+ChartJS.register(CategoryScale, LinearScale, LineElement, PointElement, Tooltip, Legend);
+var lineChartVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+var LineChart = function (_a) {
+    var className = _a.className, title = _a.title, datasets = _a.datasets, labels = _a.labels, scaling = _a.scaling, legend = _a.legend, width = _a.width, height = _a.height, indexAxis = _a.indexAxis, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, scales = _a.scales, _c = _a.isColorMixed, isColorMixed = _c === void 0 ? true : _c, props = __rest(_a, ["className", "title", "datasets", "labels", "scaling", "legend", "width", "height", "indexAxis", "appearance", "scales", "isColorMixed"]);
+    var _d = useDarkMode(), isDark = _d[0], defaultScales = _d[1];
+    var colorset = isColorMixed ? chartColorList.mixed : chartColorList.sorting;
+    var colorAlphaset = isColorMixed ? chartAlphaColorList.mixed : chartAlphaColorList.sorting;
+    datasets.forEach(function (dataset, index) {
+        var _a, _b;
+        datasets[index] = __assign(__assign({}, dataset), { borderColor: (_a = dataset.borderColor) !== null && _a !== void 0 ? _a : colorset[index % colorset.length], backgroundColor: ((_b = dataset.backgroundColor) !== null && _b !== void 0 ? _b : appearance == 'solid')
+                ? colorset[index % colorset.length]
+                : colorAlphaset[index % colorset.length] });
+    });
+    return (_jsx(Line, __assign({ data: { labels: labels, datasets: datasets }, options: {
+            plugins: {
+                title: title,
+                legend: legend,
+            },
+            indexAxis: indexAxis,
+            scales: __assign(__assign({}, defaultScales.linescale), scales),
+        }, className: cn(lineChartVariants({ scaling: scaling }), className), width: width, height: height }, props)));
+};
+LineChart.displayName = 'LineChart';
+export default LineChart;

package/dist/cjs/lib/components/Menubar/MenubarCheckboxItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import * as MenubarPrimitive from '@radix-ui/react-menubar';
+import { MenubarItemProps } from './MenubarItem';
+export declare const MenubarCheckboxItem: React.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & MenubarItemProps & React.RefAttributes<HTMLDivElement>>;

package/dist/cjs/lib/components/Menubar/MenubarCheckboxItem.js

@@ -0,0 +1,38 @@
+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 MenubarPrimitive from '@radix-ui/react-menubar';
+import { CheckIcon } from '@radix-ui/react-icons';
+import { cn } from 'lib/utils/utils';
+import { menubarItemVariants } from './MenubarItem';
+import { MenubarItemIndicator } from './MenubarItemIndicator';
+import { menuItemAppearanceStyle } from 'lib/constants';
+import { useMenubarContext } from './MenubarRoot';
+export var MenubarCheckboxItem = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, checked = _a.checked, props = __rest(_a, ["children", "className", "checked"]);
+    var _b = useMenubarContext(), radius = _b.radius, scaling = _b.scaling, size = _b.size, _c = _b.color, color = _c === void 0 ? 'red' : _c, _d = _b.itemAppearance, itemAppearance = _d === void 0 ? 'solid' : _d;
+    var itemClassName = cn(menubarItemVariants({ radius: radius, scaling: scaling, size: size }), 'pl-7', menuItemAppearanceStyle(itemAppearance, color), className);
+    return (_jsxs(MenubarPrimitive.CheckboxItem, __assign({ ref: ref, className: itemClassName }, props, { children: [_jsx(MenubarItemIndicator, { forceMount: true, radius: 'medium', size: size, children: checked && _jsx(CheckIcon, {}) }), children] })));
+});
+MenubarCheckboxItem.displayName = 'Menubar.CheckboxItem';

package/dist/cjs/lib/components/Menubar/MenubarContent.d.ts

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