@lotte-innovate/ui-component-test 0.0.45 → 0.0.47

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

@@ -0,0 +1,76 @@
+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 { cva } from 'class-variance-authority';
+import { scalingVariants } from '../../../lib/constants';
+import { Radar } from 'react-chartjs-2';
+import { cn } from '../../../lib/utils/utils';
+import { Chart as ChartJS, RadialLinearScale, PointElement, LineElement, Filler, Tooltip, Legend, plugins, } from 'chart.js/auto';
+import { chartColorList, chartAlphaColorList } from '../../../lib/color/constants';
+import { useDarkMode } from '../../../lib/utils/useDarkMode';
+import ChartDataLabels from 'chartjs-plugin-datalabels';
+ChartJS.register(RadialLinearScale, PointElement, LineElement, Filler, Tooltip, Legend, plugins, ChartDataLabels);
+ChartJS.defaults.set('plugins.datalabels', {
+    display: false,
+});
+var radarChartVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var RadarChart = function (_a) {
+    var className = _a.className, title = _a.title, legend = _a.legend, datalabels = _a.datalabels, datasets = _a.datasets, labels = _a.labels, width = _a.width, height = _a.height, scaling = _a.scaling, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, _c = _a.isColorMixed, isColorMixed = _c === void 0 ? true : _c, props = __rest(_a, ["className", "title", "legend", "datalabels", "datasets", "labels", "width", "height", "scaling", "appearance", "isColorMixed"]);
+    var _d = useDarkMode(true), isDark = _d[0], defaultScales = _d[1];
+    var getChartColor = function (isColorMixed, appearance) {
+        if (appearance === 'solid') {
+            return isColorMixed ? chartColorList.mixed : chartColorList.sorting;
+        }
+        if (appearance === 'soft') {
+            return isColorMixed ? chartAlphaColorList.mixed : chartAlphaColorList.sorting;
+        }
+    };
+    datasets.forEach(function (dataset, index) {
+        var ChartColor = getChartColor(isColorMixed, appearance);
+        var BorderColor = getChartColor(isColorMixed, 'solid');
+        if (!ChartColor || !BorderColor)
+            return;
+        dataset.backgroundColor = ChartColor[index];
+        dataset.borderColor = BorderColor[index];
+    });
+    return (_jsx(Radar, __assign({ data: { labels: labels, datasets: datasets }, options: {
+            plugins: {
+                title: title,
+                legend: legend,
+                datalabels: datalabels,
+            },
+            scales: __assign({ r: {
+                    suggestedMin: 50,
+                    suggestedMax: 100,
+                } }, defaultScales.linescale),
+        }, className: cn(radarChartVariants({ scaling: scaling }), className), width: width, height: height }, props)));
+};
+RadarChart.displayName = 'RadarChart';
+export default RadarChart;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IScaling } from '../../../lib/types';
+export interface RadioProps extends VariantProps<typeof radioVariants> {
+    size?: any;
+    scaling?: IScaling;
+    appearance?: 'classic' | 'surface' | 'soft';
+}
+declare const radioVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Radio: React.ForwardRefExoticComponent<Omit<import("@radix-ui/themes").RadioProps & React.RefAttributes<HTMLInputElement>, "ref"> & RadioProps & React.RefAttributes<HTMLInputElement>>;
+export default Radio;

package/dist/lib/components/Radio/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, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { cva } from 'class-variance-authority';
+import { Theme, Radio as RadioTheme, Flex } from '@radix-ui/themes';
+import { Text } from '../../../lib/Typography/Text';
+import { cn } from '../../../lib/utils/utils';
+var radioVariants = cva('font-normal', {
+    variants: {
+        size: {
+            small: 'text-[12px] gap-2',
+            medium: 'text-[14px] gap-2',
+            large: 'text-[16px] gap-3',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var Radio = React.forwardRef(function (_a, ref) {
+    var value = _a.value, scaling = _a.scaling, color = _a.color, _b = _a.size, size = _b === void 0 ? 'medium' : _b, _c = _a.appearance, appearance = _c === void 0 ? 'surface' : _c, children = _a.children, className = _a.className, props = __rest(_a, ["value", "scaling", "color", "size", "appearance", "children", "className"]);
+    if (!color)
+        color = 'red';
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { accentColor: color, scaling: scaling, children: _jsx(Flex, { asChild: true, className: cn(radioVariants({ size: size }), className), children: _jsxs(Text, { as: "label", size: sizeTheme, children: [_jsx(RadioTheme, __assign({ ref: ref, value: value, variant: appearance, size: sizeTheme }, props)), children] }) }) }));
+});
+Radio.displayName = 'Radio';
+export default Radio;

package/dist/lib/components/RadioCards/RadioCardsItem.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { RadioCards as RadioCardsTheme } from '@radix-ui/themes';
+export interface RadioCardsItemProps extends VariantProps<typeof radioCardsItemVariants> {
+}
+export declare const radioCardsItemVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const RadioCardsItem: React.ForwardRefExoticComponent<Omit<RadioCardsTheme.ItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & RadioCardsItemProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/lib/components/RadioCards/RadioCardsItem.js

@@ -0,0 +1,54 @@
+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 { cva } from 'class-variance-authority';
+import { RadioCards as RadioCardsTheme } from '@radix-ui/themes';
+import { cn } from '../../../lib/utils/utils';
+import { RadioCardsContext } from './RadioCardsRoot';
+export var radioCardsItemVariants = cva('min-w-[200px] bg-white dark:bg-slateDark-1 text-slateA-12 dark:text-slateDarkA-12 border-slateA-6 dark:border-slateDarkA-6 font-normal disabled:text-slateA-9 dark:disabled:text-slateDarkA-9', {
+    variants: {
+        radius: {
+            none: 'rounded-none before:rounded-none after:rounded-none',
+            small: 'rounded-[3px] before:rounded-[3px] after:rounded-[3px]',
+            medium: 'rounded before:rounded after:rounded',
+            large: 'rounded-md before:rounded-md after:rounded-md',
+            full: 'rounded-md before:rounded-md after:rounded-md',
+        },
+        size: {
+            small: 'text-sm py-[10px] px-[12px] h-[40px]',
+            medium: 'text-sm py-[14px] px-[16px] h-[48px]',
+            large: 'text-base py-[20px] px-[24px] h-[64px]',
+        },
+    },
+    defaultVariants: {
+        radius: 'medium',
+        size: 'medium',
+    },
+});
+export var RadioCardsItem = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, value = _a.value, props = __rest(_a, ["children", "className", "value"]);
+    var _b = useContext(RadioCardsContext), radius = _b.radius, size = _b.size;
+    return (_jsx(RadioCardsTheme.Item, __assign({ ref: ref, value: value, className: cn(radioCardsItemVariants({ radius: radius, size: size }), className) }, props, { children: children })));
+});
+RadioCardsItem.displayName = 'RadioCards.Item';

package/dist/lib/components/RadioCards/RadioCardsRoot.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { RadioCards as RadioCardsTheme } from '@radix-ui/themes';
+import { radioCardsItemVariants } from './RadioCardsItem';
+export interface RadioCardsProps extends VariantProps<typeof radioCardsVariants>, VariantProps<typeof radioCardsItemVariants> {
+    appearance?: 'classic' | 'surface';
+}
+declare const radioCardsVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const RadioCardsContext: React.Context<RadioCardsProps>;
+export declare const RadioCardsRoot: React.ForwardRefExoticComponent<Omit<RadioCardsTheme.RootProps & React.RefAttributes<HTMLDivElement>, "ref"> & RadioCardsProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/lib/components/RadioCards/RadioCardsRoot.js

@@ -0,0 +1,46 @@
+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 { cva } from 'class-variance-authority';
+import { scalingVariants } from '../../../lib/constants';
+import { Theme, RadioCards as RadioCardsTheme } from '@radix-ui/themes';
+import { cn } from '../../../lib/utils/utils';
+var radioCardsVariants = cva('flex items-center gap-2', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var RadioCardsContext = createContext({
+    radius: 'medium',
+    size: 'medium',
+});
+export var RadioCardsRoot = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, radius = _a.radius, scaling = _a.scaling, size = _a.size, _b = _a.color, color = _b === void 0 ? 'red' : _b, _c = _a.appearance, appearance = _c === void 0 ? 'surface' : _c, props = __rest(_a, ["children", "className", "radius", "scaling", "size", "color", "appearance"]);
+    var contextValue = { radius: radius, size: size };
+    return (_jsx(Theme, { accentColor: color, children: _jsx(RadioCardsContext.Provider, { value: contextValue, children: _jsx(RadioCardsTheme.Root, __assign({ ref: ref, variant: appearance, className: cn(radioCardsVariants({ scaling: scaling }), className) }, props, { children: children })) }) }));
+});
+RadioCardsRoot.displayName = 'RadioCards.Root';

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const RadioCards: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/radio-cards").RootProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./RadioCardsRoot").RadioCardsProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/radio-cards").ItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./RadioCardsItem").RadioCardsItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export default RadioCards;

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

@@ -0,0 +1,7 @@
+import { RadioCardsRoot } from './RadioCardsRoot';
+import { RadioCardsItem } from './RadioCardsItem';
+var RadioCards = {
+    Root: RadioCardsRoot,
+    Item: RadioCardsItem,
+};
+export default RadioCards;

package/dist/lib/components/RadioGroup/RadioGroupItem.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+export interface RadioGroupItemProps extends VariantProps<typeof radioGroupItemVariants> {
+    size?: any;
+    value: string;
+    appearance?: 'classic' | 'surface' | 'soft';
+}
+declare const radioGroupItemVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupTheme.ItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/lib/components/RadioGroup/RadioGroupItem.js

@@ -0,0 +1,46 @@
+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 { cva } from 'class-variance-authority';
+import { RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+import { RadioGroupContext } from './RadioGroupRoot';
+import { cn } from '../../../lib/utils/utils';
+var radioGroupItemVariants = cva('font-normal text-slate-12 dark:text-slateDark-12', {
+    variants: {
+        size: {
+            small: 'text-xs gap-2',
+            medium: 'text-sm gap-2',
+            large: 'text-base gap-3',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var RadioGroupItem = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, value = _a.value, props = __rest(_a, ["className", "children", "value"]);
+    var size = useContext(RadioGroupContext).size;
+    return (_jsx(RadioGroupTheme.Item, __assign({ ref: ref, value: value, className: cn(radioGroupItemVariants({ size: size }), className) }, props, { children: children })));
+});
+RadioGroupItem.displayName = 'RadioGroup.Item';

package/dist/lib/components/RadioGroup/RadioGroupRoot.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+import { VariantProps } from 'class-variance-authority';
+import { IScaling } from '../../../lib/types';
+export interface RadioGroupProps extends VariantProps<typeof radioGroupVariants> {
+    scaling?: IScaling;
+    size?: 'small' | 'medium' | 'large';
+    appearance?: 'classic' | 'surface' | 'soft';
+}
+declare const radioGroupVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const RadioGroupContext: React.Context<RadioGroupProps>;
+export declare const RadioGroupRoot: React.ForwardRefExoticComponent<Omit<RadioGroupTheme.RootProps & React.RefAttributes<HTMLDivElement>, "ref"> & RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/lib/components/RadioGroup/RadioGroupRoot.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 { createContext, forwardRef } from 'react';
+import { Theme, RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+var radioGroupVariants = cva('', {
+    variants: {
+        size: {
+            small: 'gap-1',
+            medium: 'gap-2',
+            large: 'gap-3',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var RadioGroupContext = createContext({
+    size: 'medium',
+});
+export var RadioGroupRoot = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, scaling = _a.scaling, size = _a.size, _b = _a.color, color = _b === void 0 ? 'red' : _b, _c = _a.appearance, appearance = _c === void 0 ? 'surface' : _c, props = __rest(_a, ["className", "children", "scaling", "size", "color", "appearance"]);
+    var contextValue = { size: size };
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { accentColor: color, scaling: scaling, children: _jsx(RadioGroupContext.Provider, { value: contextValue, children: _jsx(RadioGroupTheme.Root, __assign({ ref: ref, size: sizeTheme, variant: appearance, className: cn(radioGroupVariants({ size: size }), className) }, props, { children: children })) }) }));
+});
+RadioGroupRoot.displayName = 'RadioGroup.Root';

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const RadioGroup: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/radio-group").RootProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./RadioGroupRoot").RadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/radio-group").ItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("./RadioGroupItem").RadioGroupItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export default RadioGroup;

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

@@ -0,0 +1,7 @@
+import { RadioGroupRoot } from './RadioGroupRoot';
+import { RadioGroupItem } from './RadioGroupItem';
+var RadioGroup = {
+    Root: RadioGroupRoot,
+    Item: RadioGroupItem,
+};
+export default RadioGroup;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+export interface ScrollAreaProps {
+    size?: any;
+    radius?: 'none' | 'small' | 'medium' | 'large' | 'full';
+    scrollbars?: 'vertical' | 'horizontal' | 'both';
+}
+export declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+export default ScrollArea;

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

@@ -0,0 +1,36 @@
+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 { Theme, ScrollArea as ScrollAreaTheme } from '@radix-ui/themes';
+export var ScrollArea = forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, scrollbars = _a.scrollbars, radius = _a.radius, _b = _a.size, size = _b === void 0 ? 'small' : _b, props = __rest(_a, ["className", "children", "scrollbars", "radius", "size"]);
+    var sizeTheme = '1';
+    if (size === 'medium')
+        sizeTheme = '2';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { children: _jsx(ScrollAreaTheme, __assign({ ref: ref, scrollbars: scrollbars, radius: radius, size: sizeTheme, className: className }, props, { children: children })) }));
+});
+ScrollArea.displayName = 'ScrollArea';
+export default ScrollArea;

package/dist/lib/components/SegmentedControl/SegmentedControlItem.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { SegmentedControl as SegmentedControlTheme } from '@radix-ui/themes';
+export interface SegmentedControlItemProps {
+    appearance?: 'surface' | 'classic';
+}
+export declare const SegmentedControlItem: React.ForwardRefExoticComponent<Omit<SegmentedControlTheme.ItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & SegmentedControlItemProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/lib/components/SegmentedControl/SegmentedControlItem.js

@@ -0,0 +1,35 @@
+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 { SegmentedControl as SegmentedControlTheme } from '@radix-ui/themes';
+import { cn } from '../../../lib/utils/utils';
+export var SegmentedControlItem = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, appearance = _a.appearance, props = __rest(_a, ["children", "className", "appearance"]);
+    var appearanceClassName = '';
+    if (appearance === 'classic') {
+        appearanceClassName = 'dark:data-[state=on]:shadow-segmented-control-dark-classic';
+    }
+    return (_jsx(SegmentedControlTheme.Item, __assign({ ref: ref, className: cn(appearanceClassName, className) }, props, { children: children })));
+});
+SegmentedControlItem.displayName = 'SegmentedControl.Item';

package/dist/lib/components/SegmentedControl/SegmentedControlRoot.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { SegmentedControl as SegmentedControlTheme } from '@radix-ui/themes';
+export * from './SegmentedControlItem';
+import { ISize } from '../../../lib/types';
+export interface SegmentedControlProps extends VariantProps<typeof segmentedControlVariants> {
+    appearance?: 'surface' | 'classic';
+    size?: Exclude<ISize, 'x-small' | 'x-large'>;
+    radius?: 'none' | 'small' | 'medium' | 'large' | 'full';
+}
+declare const segmentedControlVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const SegmentedControlRoot: React.ForwardRefExoticComponent<Omit<SegmentedControlTheme.RootProps & React.RefAttributes<HTMLDivElement>, "ref"> & SegmentedControlProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/components/SegmentedControl/SegmentedControlRoot.js

@@ -0,0 +1,47 @@
+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 { SegmentedControl as SegmentedControlTheme, Theme } from '@radix-ui/themes';
+import { scalingVariants } from '../../../lib/constants';
+export * from './SegmentedControlItem';
+import { cn } from '../../../lib/utils/utils';
+var segmentedControlVariants = cva('text-slateA-12 dark:text-slateDarkA-12', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var SegmentedControlRoot = forwardRef(function (_a, ref) {
+    var children = _a.children, className = _a.className, _b = _a.appearance, appearance = _b === void 0 ? 'surface' : _b, _c = _a.radius, radius = _c === void 0 ? 'medium' : _c, _d = _a.size, size = _d === void 0 ? 'medium' : _d, scaling = _a.scaling, props = __rest(_a, ["children", "className", "appearance", "radius", "size", "scaling"]);
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { children: _jsx(SegmentedControlTheme.Root, __assign({ ref: ref, size: sizeTheme, radius: radius, variant: appearance, className: cn(segmentedControlVariants({ scaling: scaling }), className) }, props, { children: Children.map(children, function (child) { return React.cloneElement(child, { appearance: appearance }); }) })) }));
+});
+SegmentedControlRoot.displayName = 'SegmentedControl.Root';

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare const SegmentedControl: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/segmented-control").RootProps & import("react").RefAttributes<HTMLDivElement>, "ref"> & import("./SegmentedControlRoot").SegmentedControlProps & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("@radix-ui/themes/dist/cjs/components/segmented-control").ItemProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & import("../../../lib/components/SegmentedControl/SegmentedControlItem").SegmentedControlItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+};
+export default SegmentedControl;

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

@@ -0,0 +1,7 @@
+import { SegmentedControlRoot } from './SegmentedControlRoot';
+import { SegmentedControlItem } from './SegmentedControlRoot';
+var SegmentedControl = {
+    Root: SegmentedControlRoot,
+    Item: SegmentedControlItem,
+};
+export default SegmentedControl;