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

package/dist/lib/components/ContextMenu/ContextMenuLabel.js

@@ -0,0 +1,49 @@
+'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 ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { cn } from '../../../lib/utils/utils';
+import { cva } from 'class-variance-authority';
+import { scalingVariants } from '../../../lib/constants';
+import { useContextMenuContext } from './ContextMenuRoot';
+export var contextMenuLabelVariants = cva("flex relative leading-none select-none outline-none items-center \n    text-slate-11 dark:text-slateDarkA-11 font-normal", {
+    variants: {
+        size: {
+            small: 'text-xs h-[24px] px-2',
+            medium: 'text-sm h-[32px] px-3',
+        },
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+        size: 'medium',
+    },
+});
+export var ContextMenuLabel = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    var _b = useContextMenuContext(), size = _b.size, scaling = _b.scaling;
+    return (_jsx(ContextMenuPrimitive.Label, __assign({ ref: ref, className: cn(contextMenuLabelVariants({ size: size, scaling: scaling }), className) }, props, { children: children })));
+});
+ContextMenuLabel.displayName = 'ContextMenu.Label';

package/dist/lib/components/ContextMenu/ContextMenuRadioGroup.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+type RadioContextType = {
+    selectedValue: string;
+};
+export declare const RadioContext: React.Context<RadioContextType>;
+export declare const ContextMenuRadioGroup: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/lib/components/ContextMenu/ContextMenuRadioGroup.js

@@ -0,0 +1,32 @@
+'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 { createContext, forwardRef } from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+export var RadioContext = createContext({ selectedValue: '' });
+export var ContextMenuRadioGroup = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, value = _a.value, props = __rest(_a, ["className", "children", "value"]);
+    return (_jsx(ContextMenuPrimitive.RadioGroup, __assign({ ref: ref, className: className }, props, { children: _jsx(RadioContext.Provider, { value: { selectedValue: value !== null && value !== void 0 ? value : '' }, children: children }) })));
+});
+ContextMenuRadioGroup.displayName = 'ContextMenu.RadioGroup';

package/dist/lib/components/ContextMenu/ContextMenuRadioItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ContextMenuProps } from './ContextMenuRoot';
+export declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & ContextMenuProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/ContextMenu/ContextMenuRadioItem.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, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useContext } from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { cn } from '../../../lib/utils/utils';
+import { DotFilledIcon } from '@radix-ui/react-icons';
+import { menuItemAppearanceStyle } from '../../../lib/constants';
+import { useContextMenuContext } from './ContextMenuRoot';
+import { contextMenuItemVariants } from './ContextMenuItem';
+import { RadioContext } from './ContextMenuRadioGroup';
+import { ContextMenuItemIndicator } from './ContextMenuItemIndicator';
+export var ContextMenuRadioItem = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    var _b = useContextMenuContext(), radius = _b.radius, scaling = _b.scaling, size = _b.size, color = _b.color, _c = _b.appearance, appearance = _c === void 0 ? 'solid' : _c;
+    var itemClassName = cn(contextMenuItemVariants({
+        radius: radius,
+        scaling: scaling,
+        size: size,
+    }), 'pl-7', menuItemAppearanceStyle(appearance, color), className);
+    var radioGroup = useContext(RadioContext);
+    return (_jsxs(ContextMenuPrimitive.RadioItem, __assign({ ref: ref, className: itemClassName }, props, { children: [_jsx(ContextMenuItemIndicator, { forceMount: true, radius: 'full', size: size, children: radioGroup.selectedValue === props.value && _jsx(DotFilledIcon, {}) }), children] })));
+});
+ContextMenuRadioItem.displayName = 'ContextMenu.RadioItem';

package/dist/lib/components/ContextMenu/ContextMenuRoot.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { VariantProps } from 'class-variance-authority';
+import { IColor } from '../../../lib/types';
+import { contextMenuContentVariants } from './ContextMenuContent';
+import { contextMenuItemVariants } from './ContextMenuItem';
+export interface ContextMenuProps extends VariantProps<typeof contextMenuContentVariants>, VariantProps<typeof contextMenuItemVariants> {
+    color?: IColor;
+    appearance?: 'solid' | 'soft';
+}
+export declare const useContextMenuContext: () => ContextMenuProps;
+export declare const ContextMenuRoot: React.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuProps & ContextMenuProps & React.RefAttributes<never>>;
+export default ContextMenuRoot;

package/dist/lib/components/ContextMenu/ContextMenuRoot.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 } from "react/jsx-runtime";
+import { createContext, forwardRef, useContext, } from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { useTheme } from '../../../lib/theme';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+var ContextMenuContext = createContext({
+    radius: 'medium',
+    scaling: '100%',
+    size: 'medium',
+    color: MAIN_COLOR,
+    appearance: 'solid',
+});
+export var useContextMenuContext = function () {
+    return useContext(ContextMenuContext);
+};
+export var ContextMenuRoot = forwardRef(function (_a, ref) {
+    var children = _a.children, radius = _a.radius, size = _a.size, scaling = _a.scaling, color = _a.color, appearance = _a.appearance, props = __rest(_a, ["children", "radius", "size", "scaling", "color", "appearance"]);
+    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,
+        appearance: appearance,
+    };
+    return (_jsx(ContextMenuContext.Provider, { value: contextValue, children: _jsx("div", { ref: ref, children: _jsx(ContextMenuPrimitive.Root, __assign({}, props, { children: children })) }) }));
+});
+ContextMenuRoot.displayName = 'ContextMenu.Root';
+export default ContextMenuRoot;

package/dist/lib/components/ContextMenu/ContextMenuSeparator.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+export declare const ContextMenuSeparator: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/ContextMenu/ContextMenuSeparator.js

@@ -0,0 +1,31 @@
+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 ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { cn } from '../../../lib/utils/utils';
+export var ContextMenuSeparator = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    return (_jsx(ContextMenuPrimitive.Separator, __assign({ ref: ref, className: cn('h-[1px] m-[5px] bg-slate-6 dark:bg-slateDark-6', className) }, props, { children: children })));
+});
+ContextMenuSeparator.displayName = 'ContextMenu.Separator';

package/dist/lib/components/ContextMenu/ContextMenuSubContent.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { VariantProps } from 'class-variance-authority';
+export interface ContextMenuSubContentProps extends VariantProps<typeof contextMenuSubContentVariants> {
+}
+export declare const contextMenuSubContentVariants: (props?: ({
+    radius?: "none" | "small" | "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 ContextMenuSubContent: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/ContextMenu/ContextMenuSubContent.js

@@ -0,0 +1,55 @@
+'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 ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { cn } from '../../../lib/utils/utils';
+import { cva } from 'class-variance-authority';
+import { radiusVariants, scalingVariants } from '../../../lib/constants';
+import { useContextMenuContext } from './ContextMenuRoot';
+export var contextMenuSubContentVariants = cva("p-[5px] bg-white dark:bg-slateDark-1 will-change-[transform,opacity]\n  shadow-[0px_10px_38px_-10px_rgba(22,_23,_24,_0.35),_0px_10px_20px_-15px_rgba(22,_23,_24,_0.2)] \n  [animation-duration:_400ms] [animation-timing-function:_cubic-bezier(0.16,_1,_0.3,_1)]", {
+    variants: {
+        radius: __assign({}, radiusVariants['extra-large']),
+        size: {
+            small: 'p-1 min-w-[120px]',
+            medium: 'p-2 min-w-[136px]',
+        },
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        radius: 'small',
+        size: 'medium',
+        scaling: '100%',
+    },
+});
+export var ContextMenuSubContent = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    var _b = useContextMenuContext(), radius = _b.radius, size = _b.size, scaling = _b.scaling;
+    return (_jsx(ContextMenuPrimitive.Portal, { children: _jsx(ContextMenuPrimitive.SubContent, __assign({ ref: ref, className: cn(contextMenuSubContentVariants({
+                radius: radius,
+                size: size,
+                scaling: scaling,
+            }), className), sideOffset: 2, alignOffset: -5 }, props, { children: children })) }));
+});
+ContextMenuSubContent.displayName = 'ContextMenu.SubContent';

package/dist/lib/components/ContextMenu/ContextMenuSubTrigger.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ContextMenuItemProps } from './ContextMenuItem';
+export declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & ContextMenuItemProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/ContextMenu/ContextMenuSubTrigger.js

@@ -0,0 +1,42 @@
+'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 ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ChevronRightIcon } from '@radix-ui/react-icons';
+import { cn } from '../../../lib/utils/utils';
+import { contextMenuItemVariants } from './ContextMenuItem';
+import { blackText, menuItemAppearanceStyle } from '../../../lib/constants';
+import { useContextMenuContext } from './ContextMenuRoot';
+import { MAIN_COLOR } from '../../../lib/color/constants';
+export var ContextMenuSubTrigger = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    var _b = useContextMenuContext(), scaling = _b.scaling, size = _b.size, radius = _b.radius, _c = _b.color, color = _c === void 0 ? MAIN_COLOR : _c, _d = _b.appearance, appearance = _d === void 0 ? 'solid' : _d;
+    var triggerClassName = cn(contextMenuItemVariants({ scaling: scaling, size: size, radius: radius }), menuItemAppearanceStyle(appearance, color), className);
+    var iconClassName = cn('group-data-[disabled]:text-slate-8 ', appearance === 'solid' && blackText.includes(color)
+        ? 'hover:fill-slate-12 dark:hover:fill-slateDark-1'
+        : "hover:fill-white dark:hover:fill-slateDark-12 ");
+    return (_jsx(ContextMenuPrimitive.Sub, { children: _jsxs(ContextMenuPrimitive.SubTrigger, __assign({ ref: ref, className: triggerClassName }, props, { children: [children, _jsx("div", { className: "ml-auto pl-5", children: _jsx(ChevronRightIcon, { className: iconClassName }) })] })) }));
+});
+ContextMenuSubTrigger.displayName = 'ContextMenu.SubTrigger';

package/dist/lib/components/ContextMenu/ContextMenuTrigger.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ContextMenuProps } from './ContextMenuRoot';
+export declare const ContextMenuTrigger: React.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>, "ref"> & ContextMenuProps & React.RefAttributes<HTMLSpanElement>>;

package/dist/lib/components/ContextMenu/ContextMenuTrigger.js

@@ -0,0 +1,31 @@
+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 ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { cn } from '../../../lib/utils/utils';
+export var ContextMenuTrigger = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    return (_jsx(ContextMenuPrimitive.Trigger, __assign({ ref: ref, className: cn("flex text-slate-12 dark:text-slateDark-12 text-base text-center justify-center", className) }, props, { children: children })));
+});
+ContextMenuTrigger.displayName = 'ContextMenu.Trigger';

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

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+declare const ContextMenu: {
+    Root: import("react").ForwardRefExoticComponent<import("@radix-ui/react-context-menu").ContextMenuProps & import("./ContextMenuRoot").ContextMenuProps & import("react").RefAttributes<never>>;
+    Content: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuContent").ContextMenuContentProps & import("react").RefAttributes<HTMLDivElement>>;
+    CheckboxItem: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuCheckboxItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuRoot").ContextMenuProps & import("react").RefAttributes<HTMLDivElement>>;
+    Group: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuGroupProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuRoot").ContextMenuProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuItem").ContextMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    ItemIndicator: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("./ContextMenuItemIndicator").ContextMenuItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuLabelProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuLabel").ContextMenuLabelProps & import("react").RefAttributes<HTMLDivElement>>;
+    Trigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuTriggerProps & import("react").RefAttributes<HTMLSpanElement>, "ref"> & import("./ContextMenuRoot").ContextMenuProps & import("react").RefAttributes<HTMLSpanElement>>;
+    RadioGroup: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuRadioGroupProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    RadioItem: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuRadioItemProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuRoot").ContextMenuProps & import("react").RefAttributes<HTMLDivElement>>;
+    Separator: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuSeparatorProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    SubTrigger: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuSubTriggerProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuItem").ContextMenuItemProps & import("react").RefAttributes<HTMLDivElement>>;
+    SubContent: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/react-context-menu").ContextMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./ContextMenuSubContent").ContextMenuSubContentProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export default ContextMenu;

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

@@ -0,0 +1,29 @@
+import { ContextMenuRoot as Root } from './ContextMenuRoot';
+import { ContextMenuContent as Content } from './ContextMenuContent';
+import { ContextMenuCheckboxItem as CheckboxItem } from './ContextMenuCheckboxItem';
+import { ContextMenuGroup as Group } from './ContextMenuGroup';
+import { ContextMenuItem as Item } from './ContextMenuItem';
+import { ContextMenuItemIndicator as ItemIndicator } from './ContextMenuItemIndicator';
+import { ContextMenuLabel as Label } from './ContextMenuLabel';
+import { ContextMenuTrigger as Trigger } from './ContextMenuTrigger';
+import { ContextMenuRadioGroup as RadioGroup } from './ContextMenuRadioGroup';
+import { ContextMenuRadioItem as RadioItem } from './ContextMenuRadioItem';
+import { ContextMenuSeparator as Separator } from './ContextMenuSeparator';
+import { ContextMenuSubTrigger as SubTrigger } from './ContextMenuSubTrigger';
+import { ContextMenuSubContent as SubContent } from './ContextMenuSubContent';
+var ContextMenu = {
+    Root: Root,
+    Content: Content,
+    CheckboxItem: CheckboxItem,
+    Group: Group,
+    Item: Item,
+    ItemIndicator: ItemIndicator,
+    Label: Label,
+    Trigger: Trigger,
+    RadioGroup: RadioGroup,
+    RadioItem: RadioItem,
+    Separator: Separator,
+    SubTrigger: SubTrigger,
+    SubContent: SubContent,
+};
+export default ContextMenu;

package/dist/lib/components/DataList/DataListItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { DataList as DataListTheme } from '@radix-ui/themes';
+import { VariantProps } from 'class-variance-authority';
+export interface DataListItemProps extends VariantProps<typeof dataListItemVariants> {
+}
+export declare const dataListItemVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const DataListItem: React.ForwardRefExoticComponent<Omit<DataListTheme.ItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & DataListItemProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/DataList/DataListItem.js

@@ -0,0 +1,44 @@
+'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 { DataList as DataListTheme } from '@radix-ui/themes';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { scalingVariants } from '../../../lib/constants';
+import { useDataListContext } from './DataListRoot';
+export var dataListItemVariants = cva('flex', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var DataListItem = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, props = __rest(_a, ["className", "children"]);
+    var scaling = useDataListContext().scaling;
+    return (_jsx(DataListTheme.Item, __assign({ ref: ref }, props, { className: cn(dataListItemVariants({ scaling: scaling }), className), children: children })));
+});
+DataListItem.displayName = 'DataList.Item';

package/dist/lib/components/DataList/DataListLabel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DataList as DataListTheme } from '@radix-ui/themes';
+import { VariantProps } from 'class-variance-authority';
+export interface DataListLabelProps extends VariantProps<typeof dataListLabelVariants> {
+}
+export declare const dataListLabelVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "medium" | "regular" | "semibold" | "bold" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const DataListLabel: React.ForwardRefExoticComponent<Omit<DataListTheme.LabelProps & React.RefAttributes<HTMLElement>, "ref"> & DataListLabelProps & React.RefAttributes<HTMLElement>>;

package/dist/lib/components/DataList/DataListLabel.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 } from 'react';
+import { DataList as DataListTheme } from '@radix-ui/themes';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { weightVariants } from '../../../lib/constants';
+import { useDataListContext } from './DataListRoot';
+export var dataListLabelVariants = cva('text-slateA-11 dark:text-slateDarkA-11 w-[120px] mb-1', {
+    variants: {
+        size: {
+            small: 'text-xs mt-[5px]',
+            medium: 'text-sm mt-[3px]',
+            large: 'text-base',
+        },
+        weight: __assign({}, weightVariants),
+    },
+    defaultVariants: {
+        weight: 'regular',
+        size: 'medium',
+    },
+});
+export var DataListLabel = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, weight = _a.weight, color = _a.color, props = __rest(_a, ["children", "className", "weight", "color"]);
+    var size = useDataListContext().size;
+    return (_jsx(DataListTheme.Label, __assign({ ref: ref }, props, { children: _jsx("p", { className: cn(dataListLabelVariants({ weight: weight, size: size }), className), children: children }) })));
+});
+DataListLabel.displayName = 'DataList.Label';

package/dist/lib/components/DataList/DataListRoot.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { DataList as DataListTheme } from '@radix-ui/themes';
+import { dataListValueVariants } from './DataListValue';
+import { dataListItemVariants } from './DataListItem';
+import { VariantProps } from 'class-variance-authority';
+export interface DataListProps extends VariantProps<typeof dataListVariants>, VariantProps<typeof dataListItemVariants>, VariantProps<typeof dataListValueVariants> {
+    orientation?: 'horizontal' | 'vertical';
+}
+export declare const dataListVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const useDataListContext: () => DataListProps;
+export declare const DataListRoot: React.ForwardRefExoticComponent<Omit<DataListTheme.RootProps & React.RefAttributes<HTMLDListElement>, "ref"> & DataListProps & React.RefAttributes<HTMLDListElement>>;
+export default DataListRoot;