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

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

@@ -0,0 +1,63 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Bar } from 'react-chartjs-2';
+import { Chart as ChartJS, CategoryScale, LinearScale, BarElement, Tooltip, Legend, } from 'chart.js/auto';
+import { scalingVariants } from '../../../lib/constants';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+import { chartAlphaColorList, chartColorList } from '../../../lib/color/constants';
+import { useDarkMode } from '../../../lib/utils/useDarkMode';
+ChartJS.register(CategoryScale, LinearScale, BarElement, Tooltip, Legend);
+var barChartVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+var BarChart = function (_a) {
+    var className = _a.className, title = _a.title, datasets = _a.datasets, labels = _a.labels, scaling = _a.scaling, legend = _a.legend, width = _a.width, height = _a.height, indexAxis = _a.indexAxis, _b = _a.appearance, appearance = _b === void 0 ? 'solid' : _b, _c = _a.isColorMixed, isColorMixed = _c === void 0 ? true : _c, props = __rest(_a, ["className", "title", "datasets", "labels", "scaling", "legend", "width", "height", "indexAxis", "appearance", "isColorMixed"]);
+    var _d = useDarkMode(), isDark = _d[0], defaultScales = _d[1];
+    datasets.forEach(function (dataset, index) {
+        if (!dataset.backgroundColor) {
+            if (isColorMixed) {
+                datasets[index] = __assign(__assign({}, dataset), { backgroundColor: appearance === 'solid' ? chartColorList.mixed : chartAlphaColorList.mixed, borderColor: chartColorList.mixed });
+            }
+            else {
+                datasets[index] = __assign(__assign({}, dataset), { backgroundColor: appearance === 'solid' ? chartColorList.sorting : chartAlphaColorList.sorting, borderColor: chartColorList.sorting });
+            }
+        }
+    });
+    return (_jsx(Bar, __assign({ data: { labels: labels, datasets: datasets }, options: {
+            plugins: {
+                title: title,
+                legend: legend,
+            },
+            indexAxis: indexAxis,
+            scales: __assign({}, defaultScales.linescale),
+        }, className: cn(barChartVariants({ scaling: scaling }), className), width: width, height: height }, props)));
+};
+BarChart.displayName = 'BarChart';
+export default BarChart;

package/dist/lib/components/Breadcrumb/BreadcrumbEllipsis.d.ts

@@ -0,0 +1,9 @@
+import { ComponentProps } from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbEllipsisProps extends VariantProps<typeof breadcrumbEllipsisVariants> {
+}
+export declare const breadcrumbEllipsisVariants: (props?: ({} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/lib/components/Breadcrumb/BreadcrumbEllipsis.js

@@ -0,0 +1,34 @@
+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 { cva } from 'class-variance-authority';
+import { DotsHorizontalIcon } from '@radix-ui/react-icons';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbEllipsisVariants = cva("flex h-9 w-9 items-center justify-center", {
+    variants: {},
+});
+export var BreadcrumbEllipsis = function (_a) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsxs("span", __assign({ role: "presentation", "aria-hidden": "true", className: cn(breadcrumbEllipsisVariants({}), className) }, props, { children: [_jsx(DotsHorizontalIcon, { className: "h-4 w-4" }), _jsx("span", { className: "sr-only", children: "More" })] })));
+};
+BreadcrumbEllipsis.displayName = 'Breadcrumb.Elipssis';

package/dist/lib/components/Breadcrumb/BreadcrumbItem.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbItemProps extends VariantProps<typeof breadcrumbItemVariants> {
+}
+export declare const breadcrumbItemVariants: (props?: ({} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;

package/dist/lib/components/Breadcrumb/BreadcrumbItem.js

@@ -0,0 +1,32 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbItemVariants = cva("inline-flex items-center gap-1.5", { variants: {} });
+export var BreadcrumbItem = forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx("li", __assign({ ref: ref, className: cn(breadcrumbItemVariants({}), className) }, props)));
+});
+BreadcrumbItem.displayName = 'Breadcrumb.Item';

package/dist/lib/components/Breadcrumb/BreadcrumbLink.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbLinkProps extends VariantProps<typeof breadcrumbLinkVariants> {
+}
+export declare const breadcrumbLinkVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean | undefined;
+} & React.RefAttributes<HTMLAnchorElement>>;

package/dist/lib/components/Breadcrumb/BreadcrumbLink.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 { forwardRef, useContext } from 'react';
+import { cva } from 'class-variance-authority';
+import { BreadCrumbContext } from './BreadcrumbRoot';
+import { Slot } from '@radix-ui/themes';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbLinkVariants = cva("transition-colors", {
+    variants: {
+        size: {
+            small: 'text-xs',
+            medium: 'text-sm',
+            large: 'text-base',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var BreadcrumbLink = forwardRef(function (_a, ref) {
+    var asChild = _a.asChild, className = _a.className, props = __rest(_a, ["asChild", "className"]);
+    var size = useContext(BreadCrumbContext).size;
+    var Comp = asChild ? Slot : 'a';
+    return _jsx(Comp, __assign({ ref: ref, className: cn(breadcrumbLinkVariants({ size: size }), className) }, props));
+});
+BreadcrumbLink.displayName = 'Breadcrumb.Link';

package/dist/lib/components/Breadcrumb/BreadcrumbList.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbListProps extends VariantProps<typeof breadcrumbListVariants> {
+}
+export declare const breadcrumbListVariants: (props?: ({} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;

package/dist/lib/components/Breadcrumb/BreadcrumbList.js

@@ -0,0 +1,34 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { cva } from 'class-variance-authority';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbListVariants = cva("flex flex-wrap items-center gap-1.5 break-words text-sm sm:gap-2.5", {
+    variants: {},
+});
+export var BreadcrumbList = forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    return (_jsx("ol", __assign({ ref: ref, className: cn(breadcrumbListVariants({}), className) }, props)));
+});
+BreadcrumbList.displayName = 'Breadcrumb.List';

package/dist/lib/components/Breadcrumb/BreadcrumbPage.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbPageProps extends VariantProps<typeof breadcrumbPageVariants> {
+}
+export declare const breadcrumbPageVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/lib/components/Breadcrumb/BreadcrumbPage.js

@@ -0,0 +1,45 @@
+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 { BreadCrumbContext } from './BreadcrumbRoot';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbPageVariants = cva("font-medium", {
+    variants: {
+        size: {
+            small: 'text-xs',
+            medium: 'text-sm',
+            large: 'text-base',
+        },
+    },
+    defaultVariants: {
+        size: 'medium',
+    },
+});
+export var BreadcrumbPage = forwardRef(function (_a, ref) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    var size = useContext(BreadCrumbContext).size;
+    return (_jsx("span", __assign({ ref: ref, role: "link", "aria-disabled": "true", "aria-current": "page", className: cn(breadcrumbPageVariants({ size: size }), className) }, props)));
+});
+BreadcrumbPage.displayName = 'Breadcrumb.Page';

package/dist/lib/components/Breadcrumb/BreadcrumbRoot.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbProps extends VariantProps<typeof breadcrumbVariants> {
+}
+declare const breadcrumbVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+    size?: "small" | "medium" | "large" | null | undefined;
+    color?: string | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadCrumbContext: React.Context<BreadcrumbProps>;
+export declare const BreadcrumbRoot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: ReactNode;
+} & BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+export {};

package/dist/lib/components/Breadcrumb/BreadcrumbRoot.js

@@ -0,0 +1,59 @@
+'use client';
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, createContext } from 'react';
+import { cva } from 'class-variance-authority';
+import { scalingVariants, textColorStyle } from '../../../lib/constants';
+import { cn } from '../../../lib/utils/utils';
+import { useTheme } from '../../../lib/theme';
+var breadcrumbVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+        size: {
+            small: 'text-xs',
+            medium: 'text-sm',
+            large: 'text-base',
+        },
+        color: textColorStyle(),
+    },
+    defaultVariants: {
+        scaling: '100%',
+        size: 'medium',
+        color: 'black',
+    },
+});
+export var BreadCrumbContext = createContext({
+    size: 'medium',
+});
+export var BreadcrumbRoot = forwardRef(function (_a, ref) {
+    var className = _a.className, scaling = _a.scaling, size = _a.size, color = _a.color, props = __rest(_a, ["className", "scaling", "size", "color"]);
+    var theme = useTheme().theme;
+    var contextValue = {
+        scaling: scaling !== null && scaling !== void 0 ? scaling : theme.themeScaling,
+        color: color !== null && color !== void 0 ? color : theme.themeColor,
+        size: size,
+    };
+    return (_jsx(BreadCrumbContext.Provider, { value: contextValue, children: _jsx("nav", __assign({ ref: ref, "aria-label": "breadcrumb", className: cn(breadcrumbVariants(contextValue), className) }, props)) }));
+});
+BreadcrumbRoot.displayName = 'Breadcrumb.Root';

package/dist/lib/components/Breadcrumb/BreadcrumbSeparator.d.ts

@@ -0,0 +1,9 @@
+import { ComponentProps } from 'react';
+import { VariantProps } from 'class-variance-authority';
+export interface BreadcrumbSeparatorProps extends VariantProps<typeof breadcrumbSeparatorVariants> {
+}
+export declare const breadcrumbSeparatorVariants: (props?: ({} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: ComponentProps<'li'>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/lib/components/Breadcrumb/BreadcrumbSeparator.js

@@ -0,0 +1,34 @@
+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 { ChevronRightIcon } from '@radix-ui/react-icons';
+import { cn } from '../../../lib/utils/utils';
+export var breadcrumbSeparatorVariants = cva("[&>svg]:h-3.5 [&>svg]:w-3.5", {
+    variants: {},
+});
+export var BreadcrumbSeparator = function (_a) {
+    var children = _a.children, className = _a.className, props = __rest(_a, ["children", "className"]);
+    return (_jsx("li", __assign({ role: "presentation", "aria-hidden": "true", className: cn(breadcrumbSeparatorVariants({}), className) }, props, { children: children !== null && children !== void 0 ? children : _jsx(ChevronRightIcon, {}) })));
+};
+BreadcrumbSeparator.displayName = 'Breadcrumb.Separator';

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

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+declare const Breadcrumb: {
+    Root: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+        separator?: import("react").ReactNode;
+    } & import("./BreadcrumbRoot").BreadcrumbProps & import("react").RefAttributes<HTMLElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    Link: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+        asChild?: boolean | undefined;
+    } & import("react").RefAttributes<HTMLAnchorElement>>;
+    List: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & import("react").RefAttributes<HTMLOListElement>>;
+    Page: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+    Separator: {
+        ({ children, className, ...props }: import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Ellipsis: {
+        ({ className, ...props }: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export default Breadcrumb;

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

@@ -0,0 +1,17 @@
+import { BreadcrumbRoot as Root } from './BreadcrumbRoot';
+import { BreadcrumbItem as Item } from './BreadcrumbItem';
+import { BreadcrumbLink as Link } from './BreadcrumbLink';
+import { BreadcrumbList as List } from './BreadcrumbList';
+import { BreadcrumbPage as Page } from './BreadcrumbPage';
+import { BreadcrumbSeparator as Separator } from './BreadcrumbSeparator';
+import { BreadcrumbEllipsis as Ellipsis } from './BreadcrumbEllipsis';
+var Breadcrumb = {
+    Root: Root,
+    Item: Item,
+    Link: Link,
+    List: List,
+    Page: Page,
+    Separator: Separator,
+    Ellipsis: Ellipsis,
+};
+export default Breadcrumb;

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

@@ -0,0 +1,28 @@
+import { VariantProps } from 'class-variance-authority';
+import { IChartDataLabels, IChartDatasets, IChartLegend, IChartTitle } from '../../../lib/types';
+type IBubbleChartDataset = IChartDatasets & {
+    data: {
+        x: number;
+        y: number;
+        r: number;
+    }[];
+};
+export interface BubbleChartProps extends VariantProps<typeof bubbleChartVariants> {
+    appearance?: 'solid' | 'soft';
+    isColorMixed?: boolean;
+    className?: string;
+    title?: IChartTitle;
+    legend?: IChartLegend;
+    datasets: IBubbleChartDataset[];
+    datalabels?: IChartDataLabels;
+    width?: string | number;
+    height?: string | number;
+}
+declare const bubbleChartVariants: (props?: ({
+    scaling?: "90%" | "95%" | "100%" | "105%" | "110%" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+export declare const BubbleChart: {
+    ({ className, title, legend, datalabels, datasets, scaling, width, height, appearance, isColorMixed, ...props }: BubbleChartProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default BubbleChart;

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

@@ -0,0 +1,82 @@
+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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Bubble } from 'react-chartjs-2';
+import { Chart as ChartJS, registerables } from 'chart.js';
+import { scalingVariants } from '../../../lib/constants';
+import { cva } from 'class-variance-authority';
+import { chartColorList, chartAlphaColorList } from '../../../lib/color/constants';
+import ChartDataLabels from 'chartjs-plugin-datalabels';
+import { useDarkMode } from '../../../lib/utils/useDarkMode';
+import { cn } from '../../../lib/utils/utils';
+ChartJS.register.apply(ChartJS, __spreadArray(__spreadArray([], registerables, false), [ChartDataLabels], false));
+ChartJS.defaults.set('plugins.datalabels', {
+    display: false,
+});
+var bubbleChartVariants = cva('', {
+    variants: {
+        scaling: __assign({}, scalingVariants),
+    },
+    defaultVariants: {
+        scaling: '100%',
+    },
+});
+export var BubbleChart = function (_a) {
+    var className = _a.className, title = _a.title, legend = _a.legend, datalabels = _a.datalabels, datasets = _a.datasets, scaling = _a.scaling, width = _a.width, height = _a.height, _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", "scaling", "width", "height", "appearance", "isColorMixed"]);
+    var _d = useDarkMode(), 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(Bubble, __assign({ data: { datasets: datasets }, options: {
+            plugins: {
+                title: title,
+                legend: legend,
+                datalabels: datalabels,
+            },
+            scales: __assign({}, defaultScales.linescale),
+        }, className: cn(bubbleChartVariants({ scaling: scaling }), className), width: width, height: height }, props)));
+};
+BubbleChart.displayName = 'BubbleChart';
+export default BubbleChart;

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

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