@bioturing/components 0.13.1

package/dist/VerticalCollapsiblePanel.js

@@ -0,0 +1,414 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_5aaa6934__ from "@base-ui-components/react";
+import * as __WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__ from "@bioturing/assets";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_config_provider_6a57beb3__ from "antd/es/config-provider";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_theme_useToken_e8911485__ from "antd/es/theme/useToken";
+import "tailwind-merge";
+import * as __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_use_render_2fb9dc6d__ from "@base-ui-components/react/use-render";
+import * as __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_merge_props_04b69945__ from "@base-ui-components/react/merge-props";
+import * as __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_utils_d48cdb94__ from "@base-ui-components/react/utils";
+import * as __WEBPACK_EXTERNAL_MODULE_react_dom_7136dc57__ from "react-dom";
+import "antd/es/tooltip/style/css";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_tooltip_1091cc47__ from "antd/es/tooltip";
+function cx(...args) {
+    const classes = [];
+    for (const arg of args)if (arg) {
+        if ("string" == typeof arg || "number" == typeof arg) classes.push(String(arg));
+        else if (Array.isArray(arg)) classes.push(...cx(...arg));
+        else if ("object" == typeof arg) {
+            for (const [key, value] of Object.entries(arg))if (value) classes.push(key);
+        }
+    }
+    return classes;
+}
+function clsx(...args) {
+    return cx(...args).join(" ");
+}
+"use client";
+const useAntdCssVarClassname = ()=>{
+    var _token_;
+    const token = (0, __WEBPACK_EXTERNAL_MODULE_antd_es_theme_useToken_e8911485__["default"])();
+    return null == (_token_ = token[4]) ? void 0 : _token_.key;
+};
+const useCls = ()=>{
+    const { getPrefixCls } = (0, __WEBPACK_EXTERNAL_MODULE_react__.useContext)(__WEBPACK_EXTERNAL_MODULE_antd_es_config_provider_6a57beb3__["default"].ConfigContext);
+    return (...args)=>cx(...args).map((cls)=>getPrefixCls(cls)).join(" ");
+};
+"use client";
+function useControlledState(value, onChange, defaultValue) {
+    const [internalState, setInternalState] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(defaultValue);
+    const isControlled = void 0 !== value;
+    const setState = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((next)=>{
+        const nextValue = "function" == typeof next ? next(value) : next;
+        if ("function" == typeof onChange) onChange(nextValue);
+        if (!isControlled) setInternalState(next);
+    }, [
+        value,
+        onChange,
+        isControlled
+    ]);
+    const state = isControlled ? value : internalState;
+    return [
+        state,
+        setState
+    ];
+}
+"use client";
+const useEnhancedEffect = "undefined" != typeof window ? __WEBPACK_EXTERNAL_MODULE_react__.useLayoutEffect : __WEBPACK_EXTERNAL_MODULE_react__.useEffect;
+function useEventCallback(fn) {
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(fn);
+    useEnhancedEffect(()=>{
+        ref.current = fn;
+    });
+    return (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((...args)=>{
+        var _ref_current;
+        return null == (_ref_current = ref.current) ? void 0 : _ref_current.call(ref, ...args);
+    }, []);
+}
+function useLatestRef(value) {
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(value);
+    useEnhancedEffect(()=>{
+        ref.current = value;
+    });
+    return ref;
+}
+function useAnimationsFinished(ref, waitForNextTick = false) {
+    const frameRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(-1);
+    const timeoutRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(-1);
+    const cancelTasks = useEventCallback(()=>{
+        cancelAnimationFrame(frameRef.current);
+        clearTimeout(timeoutRef.current);
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>cancelTasks, [
+        cancelTasks
+    ]);
+    return useEventCallback((fnToExecute)=>{
+        cancelTasks();
+        const element = ref.current;
+        if (!element) return;
+        if ("function" != typeof element.getAnimations) fnToExecute();
+        else frameRef.current = requestAnimationFrame(()=>{
+            function exec() {
+                if (!element) return;
+                Promise.allSettled(element.getAnimations().map((anim)=>anim.finished)).then(()=>{
+                    (0, __WEBPACK_EXTERNAL_MODULE_react_dom_7136dc57__.flushSync)(fnToExecute);
+                });
+            }
+            if (waitForNextTick) timeoutRef.current = window.setTimeout(exec);
+            else exec();
+        });
+    });
+}
+"use client";
+const Transition = (props)=>{
+    const { children = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {}), className, starting, ending, show = true, keepMounted = false, ...otherProps } = props;
+    const { mounted, setMounted, transitionStatus } = (0, __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_utils_d48cdb94__.useTransitionStatus)(show);
+    const showRef = useLatestRef(show);
+    const combinedClassName = clsx(className, "starting" === transitionStatus && "string" == typeof starting && starting, "ending" === transitionStatus && "string" == typeof ending && ending);
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const runOnceAnimationsFinish = useAnimationsFinished(ref, show);
+    const { renderElement } = (0, __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_use_render_2fb9dc6d__.useRender)({
+        render: "function" == typeof children ? children(otherProps, {}) : children,
+        props: (0, __WEBPACK_EXTERNAL_MODULE__base_ui_components_react_merge_props_04b69945__.mergeProps)({
+            ...otherProps,
+            ref,
+            className: combinedClassName,
+            ...{
+                "data-starting": "starting" === transitionStatus ? "true" : void 0,
+                "data-ending": "ending" === transitionStatus ? "true" : void 0
+            },
+            style: {
+                ..."starting" === transitionStatus && "object" == typeof starting ? starting : {},
+                ..."ending" === transitionStatus && "object" == typeof ending ? ending : {}
+            }
+        })
+    });
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (keepMounted) return;
+        runOnceAnimationsFinish(()=>{
+            if (show === showRef.current) setMounted(show);
+        });
+    }, [
+        show,
+        keepMounted,
+        runOnceAnimationsFinish,
+        setMounted,
+        showRef
+    ]);
+    return mounted ? renderElement() : null;
+};
+"use client";
+const IconButtonImpl = (props, ref)=>{
+    const { label, size = "medium", negativeMargin = true, children, className, tooltipProps = {}, as, href, target, rel, download, hrefLang, referrerPolicy, ...rest } = props;
+    const cls = useCls();
+    const antdCssVarClassname = useAntdCssVarClassname();
+    const buttonClasses = [
+        cls("icon-button"),
+        cls(`icon-button-${size}`),
+        cls(negativeMargin ? "icon-button-negative-margin" : ""),
+        antdCssVarClassname,
+        className
+    ].filter(Boolean).join(" ");
+    const Component = as || (href ? "a" : "button");
+    const anchorProps = "a" === Component ? {
+        ...void 0 !== target && {
+            target
+        },
+        ...void 0 !== rel && {
+            rel
+        },
+        ...void 0 !== download && {
+            download
+        },
+        ...void 0 !== hrefLang && {
+            hrefLang
+        },
+        ...void 0 !== referrerPolicy && {
+            referrerPolicy
+        }
+    } : {};
+    const elementProps = {
+        ref,
+        className: buttonClasses,
+        ..."button" === Component && {
+            type: "button"
+        },
+        ...href && {
+            href
+        },
+        ...anchorProps,
+        ...rest
+    };
+    const element = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Component, {
+        ...elementProps,
+        children: children
+    });
+    return label ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE_antd_es_tooltip_1091cc47__["default"], {
+        title: label,
+        arrow: false,
+        ...tooltipProps,
+        children: element
+    }) : element;
+};
+const IconButton = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(IconButtonImpl);
+const measureText = (container)=>{
+    const span = document.createElement("span");
+    span.style.opacity = "0";
+    span.style.position = "absolute";
+    span.style.top = "-1000px";
+    span.style.left = "-1000px";
+    span.style.whiteSpace = "nowrap";
+    span.style.pointerEvents = "none";
+    container.appendChild(span);
+    return {
+        measure: (text)=>{
+            span.innerText = text;
+            return span.clientWidth;
+        },
+        destroy: ()=>{
+            container.removeChild(span);
+        }
+    };
+};
+const getMiddleTruncatedString = (text, ellipsis, container)=>{
+    var _Object_values_reverse_find;
+    if (!text) return text;
+    const { measure: getTextWidth, destroy: destroyMeasure } = measureText(container);
+    const textWidth = getTextWidth(text);
+    const containerWidth = container.clientWidth;
+    const initialOffset = Math.floor(containerWidth / textWidth * text.length);
+    if (textWidth <= containerWidth) {
+        destroyMeasure();
+        return text;
+    }
+    let offset = initialOffset;
+    const attempts = {};
+    const maxAttempts = 20;
+    const buffer = 10;
+    while(Object.values(attempts).length <= maxAttempts){
+        if (attempts[offset]) break;
+        if (offset <= 1) {
+            attempts[0] = [
+                0,
+                ellipsis
+            ];
+            break;
+        }
+        const start = text.slice(0, Math.ceil((offset - ellipsis.length) / 2 - 1)).trimEnd();
+        const end = text.slice(Math.floor((offset - ellipsis.length) / 2) - offset).trimStart();
+        const truncatedStr = start + ellipsis + end;
+        const width = getTextWidth(truncatedStr);
+        attempts[offset] = [
+            width,
+            truncatedStr
+        ];
+        if (width >= containerWidth) offset -= 2;
+        else {
+            if (containerWidth - width < buffer) break;
+            offset += 2;
+        }
+    }
+    destroyMeasure();
+    return (null == (_Object_values_reverse_find = Object.values(attempts).reverse().find(([width])=>width < containerWidth)) ? void 0 : _Object_values_reverse_find[1]) ?? Object.values(attempts)[0][1];
+};
+"use client";
+const Truncate = ({ children, position = "end", className, style, ...rest })=>{
+    const cls = useCls();
+    const containerRef = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const [isTruncated, setIsTruncated] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(false);
+    const [truncatedText, setTruncatedText] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(children);
+    const text = children;
+    const getContainerStyles = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        const baseStyles = {
+            overflow: "hidden",
+            whiteSpace: "nowrap",
+            textOverflow: "clip",
+            flexGrow: 1,
+            minWidth: 0,
+            maxWidth: "100%",
+            display: "block",
+            ...style
+        };
+        if ("end" === position) return {
+            ...baseStyles,
+            textOverflow: "ellipsis"
+        };
+        return baseStyles;
+    }, [
+        position,
+        style
+    ]);
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useLayoutEffect)(()=>{
+        const container = containerRef.current;
+        if (!container) return;
+        let cancellationToken = {
+            cancelled: false
+        };
+        const calculateTruncatedString = ()=>{
+            if (cancellationToken) cancellationToken.cancelled = true;
+            const requestCancellationToken = {
+                cancelled: false
+            };
+            cancellationToken = requestCancellationToken;
+            const truncated = getMiddleTruncatedString(text, "\u2026", container);
+            if (requestCancellationToken.cancelled) return;
+            setTruncatedText(truncated);
+        };
+        if ("middle" == position) {
+            var _window_document_fonts_ready, _window_document_fonts;
+            null == (_window_document_fonts = window.document.fonts) || null == (_window_document_fonts_ready = _window_document_fonts.ready) || _window_document_fonts_ready.then(calculateTruncatedString);
+        }
+        if ("end" == position) setTruncatedText(text);
+        const observer = new ResizeObserver(()=>{
+            if ("middle" == position) window.requestAnimationFrame(calculateTruncatedString);
+            if ("end" == position) {
+                const isOverflowing = container.scrollWidth > container.clientWidth;
+                if (isOverflowing) setIsTruncated(true);
+            }
+        });
+        observer.observe(container);
+        return ()=>{
+            cancellationToken.cancelled = true;
+            observer.disconnect();
+        };
+    }, [
+        text,
+        position
+    ]);
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("span", {
+        ref: containerRef,
+        style: getContainerStyles(),
+        className: clsx(cls("truncate"), className),
+        title: isTruncated ? text : void 0,
+        ...rest,
+        children: text === truncatedText ? text : /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("span", {
+            children: truncatedText
+        })
+    });
+};
+"use client";
+const VerticalCollapsiblePanel = ({ children, title, defaultOpen = false, open: controlledOpen, onOpenChange, className, headerClassName, headerInnerClassName, bodyClassName, contentPadding = "16px", afterTitle, actions, useTitleAsTrigger = true, keepMounted = false })=>{
+    const cls = useCls();
+    const [isOpen, setIsOpen] = useControlledState(controlledOpen, onOpenChange, defaultOpen);
+    const [isBodyOpen, setIsBodyOpen] = (0, __WEBPACK_EXTERNAL_MODULE_react__.useState)(isOpen);
+    const ref = (0, __WEBPACK_EXTERNAL_MODULE_react__.useRef)(null);
+    const runOnceAnimationsFinish = useAnimationsFinished(ref, isOpen);
+    const cssVars = useAntdCssVarClassname();
+    (0, __WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        runOnceAnimationsFinish(()=>{
+            setIsBodyOpen(isOpen);
+        });
+    }, [
+        isOpen,
+        runOnceAnimationsFinish
+    ]);
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)(__WEBPACK_EXTERNAL_MODULE__base_ui_components_react_5aaa6934__.Collapsible.Root, {
+        className: clsx(cls("collapsible-panel"), cssVars, className),
+        open: isOpen,
+        onOpenChange: setIsOpen,
+        ref: ref,
+        children: [
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
+                className: clsx(cls("collapsible-panel-header"), headerClassName),
+                children: [
+                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
+                        className: clsx(cls("collapsible-panel-header-inner"), headerInnerClassName),
+                        children: [
+                            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
+                                className: cls("collapsible-panel-header-text"),
+                                onClick: useTitleAsTrigger ? ()=>setIsOpen((open)=>!open) : void 0,
+                                style: useTitleAsTrigger ? {
+                                    cursor: "pointer"
+                                } : {},
+                                children: "string" == typeof title ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Truncate, {
+                                    children: title
+                                }) : title
+                            }),
+                            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
+                                className: cls("collapsible-panel-header-actions"),
+                                children: [
+                                    isOpen && actions,
+                                    /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__base_ui_components_react_5aaa6934__.Collapsible.Trigger, {
+                                        className: cls("collapsible-panel-trigger"),
+                                        render: isOpen ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(IconButton, {
+                                            children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.MinusCircle, {
+                                                weight: "bold",
+                                                className: clsx(cls("collapsible-panel-caret"), isOpen && cls("collapsible-panel-caret-open"))
+                                            })
+                                        }) : /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(IconButton, {
+                                            children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.PlusCircle, {
+                                                weight: "bold",
+                                                className: clsx(cls("collapsible-panel-caret"), isOpen && cls("collapsible-panel-caret-open"))
+                                            })
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    isOpen && afterTitle && /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
+                        className: cls("collapsible-panel-header-after"),
+                        children: afterTitle
+                    })
+                ]
+            }),
+            /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__base_ui_components_react_5aaa6934__.Collapsible.Panel, {
+                className: cls("collapsible-panel-content"),
+                style: void 0 !== contentPadding ? {
+                    "--ds-content-padding": false === contentPadding || 0 === contentPadding ? "0" : "number" == typeof contentPadding ? `${contentPadding}px` : contentPadding
+                } : {},
+                keepMounted: keepMounted,
+                children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(Transition, {
+                    show: isBodyOpen,
+                    className: clsx(cls("collapsible-panel-body"), bodyClassName),
+                    keepMounted: true,
+                    children: /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
+                        children: children
+                    })
+                })
+            })
+        ]
+    });
+};
+export { VerticalCollapsiblePanel };

package/dist/assets/src/icons/ANOVAAnalysis.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ANOVAAnalysisProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const ANOVAAnalysis: React.ForwardRefExoticComponent<Omit<ANOVAAnalysisProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default ANOVAAnalysis;

package/dist/assets/src/icons/AUCell.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface AUCellProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const AUCell: React.ForwardRefExoticComponent<Omit<AUCellProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default AUCell;

package/dist/assets/src/icons/Alphabet.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface AlphabetProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Alphabet: React.ForwardRefExoticComponent<Omit<AlphabetProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Alphabet;

package/dist/assets/src/icons/BarChart.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BarChartProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const BarChart: React.ForwardRefExoticComponent<Omit<BarChartProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default BarChart;

package/dist/assets/src/icons/BoxPlot.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BoxPlotProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const BoxPlot: React.ForwardRefExoticComponent<Omit<BoxPlotProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default BoxPlot;

package/dist/assets/src/icons/BubbleHeatmap.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface BubbleHeatmapProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const BubbleHeatmap: React.ForwardRefExoticComponent<Omit<BubbleHeatmapProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default BubbleHeatmap;

package/dist/assets/src/icons/CDR3Spectratyping.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CDR3SpectratypingProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CDR3Spectratyping: React.ForwardRefExoticComponent<Omit<CDR3SpectratypingProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CDR3Spectratyping;

package/dist/assets/src/icons/CancerPrediction.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CancerPredictionProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CancerPrediction: React.ForwardRefExoticComponent<Omit<CancerPredictionProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CancerPrediction;

package/dist/assets/src/icons/Cell.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CellProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Cell: React.ForwardRefExoticComponent<Omit<CellProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Cell;

package/dist/assets/src/icons/CellCellCommunication.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CellCellCommunicationProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CellCellCommunication: React.ForwardRefExoticComponent<Omit<CellCellCommunicationProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CellCellCommunication;

package/dist/assets/src/icons/CellSearch.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CellSearchProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CellSearch: React.ForwardRefExoticComponent<Omit<CellSearchProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CellSearch;

package/dist/assets/src/icons/CellTypePrediction.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CellTypePredictionProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CellTypePrediction: React.ForwardRefExoticComponent<Omit<CellTypePredictionProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CellTypePrediction;

package/dist/assets/src/icons/Cells.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CellsProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Cells: React.ForwardRefExoticComponent<Omit<CellsProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Cells;

package/dist/assets/src/icons/Circos.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CircosProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Circos: React.ForwardRefExoticComponent<Omit<CircosProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Circos;

package/dist/assets/src/icons/Clonotype.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ClonotypeProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Clonotype: React.ForwardRefExoticComponent<Omit<ClonotypeProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Clonotype;

package/dist/assets/src/icons/CoexpressionPlot.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CoexpressionPlotProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const CoexpressionPlot: React.ForwardRefExoticComponent<Omit<CoexpressionPlotProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default CoexpressionPlot;

package/dist/assets/src/icons/Composition.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface CompositionProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Composition: React.ForwardRefExoticComponent<Omit<CompositionProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Composition;

package/dist/assets/src/icons/DEG.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface DEGProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const DEG: React.ForwardRefExoticComponent<Omit<DEGProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default DEG;

package/dist/assets/src/icons/Digits.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface DigitsProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Digits: React.ForwardRefExoticComponent<Omit<DigitsProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Digits;

package/dist/assets/src/icons/DiversityAnalysis.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface DiversityAnalysisProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const DiversityAnalysis: React.ForwardRefExoticComponent<Omit<DiversityAnalysisProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default DiversityAnalysis;

package/dist/assets/src/icons/Embedding.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface EmbeddingProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Embedding: React.ForwardRefExoticComponent<Omit<EmbeddingProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Embedding;

package/dist/assets/src/icons/EnrichmentTest.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface EnrichmentTestProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const EnrichmentTest: React.ForwardRefExoticComponent<Omit<EnrichmentTestProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default EnrichmentTest;

package/dist/assets/src/icons/Eppendorf.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface EppendorfProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Eppendorf: React.ForwardRefExoticComponent<Omit<EppendorfProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Eppendorf;

package/dist/assets/src/icons/FileArrowRight.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface FileArrowRightProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const FileArrowRight: React.ForwardRefExoticComponent<Omit<FileArrowRightProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default FileArrowRight;

package/dist/assets/src/icons/FolderArrowRight.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface FolderArrowRightProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const FolderArrowRight: React.ForwardRefExoticComponent<Omit<FolderArrowRightProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default FolderArrowRight;

package/dist/assets/src/icons/Heatmap.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface HeatmapProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const Heatmap: React.ForwardRefExoticComponent<Omit<HeatmapProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default Heatmap;

package/dist/assets/src/icons/ImageSegmentation.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ImageSegmentationProps extends React.SVGProps<SVGSVGElement> {
+    weight?: 'regular' | 'fill' | 'duotone';
+    size?: number | string;
+}
+declare const ImageSegmentation: React.ForwardRefExoticComponent<Omit<ImageSegmentationProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export default ImageSegmentation;