@lotte-innovate/ui-component-test 0.0.31 → 0.0.33

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

@@ -0,0 +1,44 @@
+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 { RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+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, size = _a.size, _b = _a.appearance, appearance = _b === void 0 ? 'surface' : _b, props = __rest(_a, ["className", "children", "value", "size", "appearance"]);
+    return (_jsx(RadioGroupTheme.Item, __assign({ ref: ref, value: value, className: cn(radioGroupItemVariants({ size: size }), className) }, props, { children: children })));
+});
+RadioGroupItem.displayName = 'RadioGroupItem';

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import { RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+import { VariantProps } from 'class-variance-authority';
+import { IScaling } from 'lib/types';
+export * from './RadioGroupItem';
+export interface RadioGroupProps extends VariantProps<typeof radioGroupVariants> {
+    color?: any;
+    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 RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupTheme.RootProps & React.RefAttributes<HTMLDivElement>, "ref"> & RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export default RadioGroup;

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

@@ -0,0 +1,51 @@
+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, RadioGroup as RadioGroupTheme } from '@radix-ui/themes';
+import { cva } from 'class-variance-authority';
+import { cn } from 'lib/utils/utils';
+export * from './RadioGroupItem';
+var radioGroupVariants = cva('', {
+    variants: {
+        size: {
+            small: 'gap-1',
+            medium: 'gap-2',
+            large: 'gap-3',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var RadioGroup = 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 sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { accentColor: color, scaling: scaling, children: _jsx(RadioGroupTheme.Root, __assign({ ref: ref, size: sizeTheme, variant: appearance, className: cn(radioGroupVariants({ size: size }), className) }, props, { children: children })) }));
+});
+RadioGroup.displayName = 'RadioGroup';
+export default RadioGroup;

package/dist/src/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/src/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/src/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/src/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 = 'SegmentedControlItem';

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

@@ -0,0 +1,15 @@
+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 SegmentedControl: React.ForwardRefExoticComponent<Omit<SegmentedControlTheme.RootProps & React.RefAttributes<HTMLDivElement>, "ref"> & SegmentedControlProps & React.RefAttributes<HTMLDivElement>>;
+export default SegmentedControl;

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

@@ -0,0 +1,48 @@
+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 SegmentedControl = 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 }); }) })) }));
+});
+SegmentedControl.displayName = 'SegmentedControl';
+export default SegmentedControl;

package/dist/src/lib/components/Select/index.d.ts

@@ -0,0 +1,25 @@
+import { Select as SelectTheme } from '@radix-ui/themes';
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IScaling } from 'lib/types';
+export interface SelectProps extends VariantProps<typeof selectVariants> {
+    label?: string;
+    defaultValue?: string;
+    selected?: string;
+    disabled?: boolean;
+    color?: any;
+    scaling?: IScaling;
+    appearance?: 'classic' | 'surface' | 'soft' | 'ghost';
+    size?: 'small' | 'medium' | 'large';
+}
+declare const selectVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Select: React.ForwardRefExoticComponent<SelectTheme.RootProps & SelectProps & React.RefAttributes<never>>;
+export declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectTheme.TriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & SelectProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectTheme.ContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & SelectProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectTheme.ItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & SelectProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectGroup: React.ForwardRefExoticComponent<Omit<SelectTheme.GroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & SelectProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectTheme.LabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & SelectProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectTheme.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & SelectProps & React.RefAttributes<HTMLDivElement>>;
+export default Select;

package/dist/src/lib/components/Select/index.js

@@ -0,0 +1,83 @@
+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 { Theme, Select as SelectTheme } from '@radix-ui/themes';
+import React from 'react';
+import { cva } from 'class-variance-authority';
+import { cn } from 'lib/utils/utils';
+import { radiusVariants, selectAppearanceStyle } from 'lib/constants';
+var selectVariants = cva('', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+    },
+    defaultVariants: {
+        radius: 'medium',
+    },
+});
+export var Select = React.forwardRef(function (_a, ref) {
+    var scaling = _a.scaling, size = _a.size, color = _a.color, children = _a.children, props = __rest(_a, ["scaling", "size", "color", "children"]);
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { scaling: scaling, accentColor: color, hasBackground: false, children: _jsx("div", { ref: ref, children: _jsx(SelectTheme.Root, __assign({ size: sizeTheme }, props, { children: children })) }) }));
+});
+Select.displayName = 'Select';
+export var SelectTrigger = React.forwardRef(function (_a, forwardedRef) {
+    var _b = _a.appearance, appearance = _b === void 0 ? 'surface' : _b, color = _a.color, size = _a.size, radius = _a.radius, children = _a.children, className = _a.className, props = __rest(_a, ["appearance", "color", "size", "radius", "children", "className"]);
+    if (!color)
+        color = 'red';
+    return (_jsx(SelectTheme.Trigger, __assign({ ref: forwardedRef, variant: appearance, radius: radius, className: cn(selectVariants({ radius: radius }), selectAppearanceStyle(appearance, color), className) }, props, { children: children })));
+});
+SelectTrigger.displayName = 'SelectTrigger';
+export var SelectContent = React.forwardRef(function (_a, forwardedRef) {
+    var appearance = _a.appearance, color = _a.color, size = _a.size, radius = _a.radius, children = _a.children, className = _a.className, props = __rest(_a, ["appearance", "color", "size", "radius", "children", "className"]);
+    if (!color)
+        color = 'red';
+    if (radius === 'full')
+        radius = 'large';
+    return (_jsx(SelectTheme.Content, __assign({ ref: forwardedRef, color: color }, props, { className: cn(selectVariants({ radius: radius }), className), children: children })));
+});
+SelectContent.displayName = 'SelectContent';
+export var SelectItem = React.forwardRef(function (_a, forwardedRef) {
+    var value = _a.value, children = _a.children, className = _a.className, radius = _a.radius, props = __rest(_a, ["value", "children", "className", "radius"]);
+    return (_jsx(SelectTheme.Item, __assign({ ref: forwardedRef, value: value }, props, { className: cn(selectVariants({ radius: radius }), className), children: children })));
+});
+SelectItem.displayName = 'SelectItem';
+export var SelectGroup = React.forwardRef(function (_a, forwardedRef) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    return (_jsx(SelectTheme.Group, __assign({ ref: forwardedRef }, props, { className: className, children: children })));
+});
+SelectGroup.displayName = 'SelectGroup';
+export var SelectLabel = React.forwardRef(function (_a, forwardedRef) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    return (_jsx(SelectTheme.Label, __assign({ ref: forwardedRef }, props, { className: className, children: children })));
+});
+SelectLabel.displayName = 'SelectLabel';
+export var SelectSeparator = React.forwardRef(function (_a, forwardedRef) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    return (_jsx(SelectTheme.Separator, __assign({ ref: forwardedRef }, props, { className: className, children: children })));
+});
+SelectSeparator.displayName = 'SelectSeparator';
+export default Select;

package/dist/src/lib/components/Separator/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface SeparatorProps extends VariantProps<typeof separatorVariants> {
+    size?: 'small' | 'medium' | 'large' | 'fill-large';
+}
+declare const separatorVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Separator: React.ForwardRefExoticComponent<Omit<import("@radix-ui/themes").SeparatorProps & React.RefAttributes<HTMLSpanElement>, "ref"> & SeparatorProps & React.RefAttributes<HTMLSpanElement>>;
+export default Separator;

package/dist/src/lib/components/Separator/index.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 from 'react';
+import { cva } from 'class-variance-authority';
+import { cn } from 'lib/utils/utils';
+import { bgColorStyle, scalingVariants } from 'lib/constants';
+import { Separator as SeparatorTheme, Theme } from '@radix-ui/themes';
+var separatorVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+        color: bgColorStyle(),
+    },
+});
+export var Separator = React.forwardRef(function (_a, forwardedRef) {
+    var orientation = _a.orientation, scaling = _a.scaling, size = _a.size, _b = _a.color, color = _b === void 0 ? 'slate' : _b, className = _a.className, children = _a.children, props = __rest(_a, ["orientation", "scaling", "size", "color", "className", "children"]);
+    var sizeTheme = '1';
+    if (size === 'medium')
+        sizeTheme = '2';
+    if (size === 'large')
+        sizeTheme = '3';
+    if (size === 'fill-large')
+        sizeTheme = '4';
+    return (_jsx(Theme, { hasBackground: false, className: "flex justify-center items-center", children: _jsx(SeparatorTheme, __assign({ orientation: orientation, size: sizeTheme, className: cn("bg-".concat(color, "A-6 dark:bg-").concat(color, "DarkA-6"), separatorVariants({ scaling: scaling }), className) }, props, { children: children })) }));
+});
+Separator.displayName = 'Separator';
+export default Separator;

package/dist/src/lib/components/Skeleton/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import '@radix-ui/themes/styles.css';
+import { VariantProps } from 'class-variance-authority';
+import { IColor } from 'lib/types';
+export interface SkeletonProps extends VariantProps<typeof separatorVariants> {
+    color?: IColor;
+    loading?: boolean;
+    width?: string;
+    height?: string;
+}
+declare const separatorVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Skeleton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & SkeletonProps & React.RefAttributes<HTMLSpanElement>>;
+export default Skeleton;

package/dist/src/lib/components/Skeleton/index.js

@@ -0,0 +1,43 @@
+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 from 'react';
+import '@radix-ui/themes/styles.css';
+import { cva } from 'class-variance-authority';
+import { Theme, Skeleton as SkeletonTheme } from '@radix-ui/themes';
+import { cn } from 'lib/utils/utils';
+import { radiusVariants } from 'lib/constants';
+var separatorVariants = cva('', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+    },
+    defaultVariants: {
+        radius: 'medium',
+    },
+});
+export var Skeleton = React.forwardRef(function (_a, forwardedRef) {
+    var children = _a.children, className = _a.className, radius = _a.radius, loading = _a.loading, width = _a.width, height = _a.height, skeletonProps = __rest(_a, ["children", "className", "radius", "loading", "width", "height"]);
+    return (_jsx(Theme, { children: _jsx(SkeletonTheme, __assign({ ref: forwardedRef, loading: loading, width: width, height: height, className: cn('', radius && cn(separatorVariants({ radius: radius }), className)) }, skeletonProps, { children: children })) }));
+});
+Skeleton.displayName = 'Skeleton';
+export default Skeleton;

package/dist/src/lib/components/Slider/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import '@radix-ui/themes/styles.css';
+import { VariantProps } from 'class-variance-authority';
+import { IScaling } from 'lib/types';
+export interface SliderProps extends VariantProps<typeof sliderVariants> {
+    appearance?: 'classic' | 'soft' | 'surface';
+    label?: string;
+    size?: 'small' | 'medium' | 'large';
+    scaling?: IScaling;
+}
+declare const sliderVariants: (props?: ({
+    radius?: "small" | "none" | "medium" | "large" | "full" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Slider: React.ForwardRefExoticComponent<Omit<import("@radix-ui/themes").SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & SliderProps & React.RefAttributes<HTMLSpanElement>>;
+export default Slider;

package/dist/src/lib/components/Slider/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 React from 'react';
+import '@radix-ui/themes/styles.css';
+import { cva } from 'class-variance-authority';
+import { cn } from 'lib/utils/utils';
+import { radiusVariants } from 'lib/constants';
+import { Theme, Slider as SliderTheme } from '@radix-ui/themes';
+var sliderVariants = cva('relative flex items-center select-none touch-none w-[200px] h-5', {
+    variants: {
+        radius: __assign({}, radiusVariants['base']),
+        // color: bgColorStyle(),
+    },
+});
+export var Slider = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, color = _a.color, size = _a.size, appearance = _a.appearance, _b = _a.scaling, scaling = _b === void 0 ? '100%' : _b, radius = _a.radius, tabIndex = _a.tabIndex, sliderProps = __rest(_a, ["className", "color", "size", "appearance", "scaling", "radius", "tabIndex"]);
+    if (!color)
+        color = 'red';
+    if (radius === 'medium' || radius === 'large')
+        radius = 'full';
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { accentColor: color, scaling: scaling, hasBackground: false, children: _jsx(SliderTheme, __assign({ ref: forwardedRef, variant: appearance, size: sizeTheme, radius: radius, color: color, className: cn(sliderVariants({ radius: radius }), className) }, sliderProps)) }));
+});
+Slider.displayName = 'Slider';
+export default Slider;

package/dist/src/lib/components/Spinner/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { IColor } from 'lib/types';
+export interface SpinnerProps extends VariantProps<typeof spinnerVariants> {
+    color?: IColor;
+    loading?: boolean;
+    width?: string;
+    height?: string;
+    size?: 'small' | 'medium' | 'large';
+}
+declare const spinnerVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const Spinner: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & SpinnerProps & React.RefAttributes<HTMLSpanElement>>;
+export default Spinner;

package/dist/src/lib/components/Spinner/index.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 from 'react';
+import { cva } from 'class-variance-authority';
+import { Spinner as SpinnerTheme, Theme } from '@radix-ui/themes';
+import { cn } from 'lib/utils/utils';
+import { scalingVariants } from 'lib/constants';
+var spinnerVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var Spinner = React.forwardRef(function (_a, forwardedRef) {
+    var className = _a.className, children = _a.children, size = _a.size, scaling = _a.scaling, loading = _a.loading, spinnerProps = __rest(_a, ["className", "children", "size", "scaling", "loading"]);
+    var sizeTheme = '2';
+    if (size === 'small')
+        sizeTheme = '1';
+    if (size === 'large')
+        sizeTheme = '3';
+    return (_jsx(Theme, { hasBackground: false, children: _jsx(SpinnerTheme, __assign({ ref: forwardedRef, loading: loading, size: sizeTheme, className: cn('', spinnerVariants({ scaling: scaling }), className) }, spinnerProps, { children: children })) }));
+});
+Spinner.displayName = 'Spinner';
+export default Spinner;