@bioturing/components 0.13.1

package/dist/Tooltip.js

@@ -0,0 +1,36 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_tooltip_1091cc47__ from "antd/es/tooltip";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_config_provider_6a57beb3__ from "antd/es/config-provider";
+import "antd/es/theme/useToken";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import "tailwind-merge";
+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 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";
+const Tooltip = ({ className, style, arrow = false, ...rest })=>{
+    const cls = useCls();
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE_antd_es_tooltip_1091cc47__["default"], {
+        className: clsx(cls("tooltip"), className),
+        arrow: arrow,
+        style: style,
+        ...rest
+    });
+};
+export { Tooltip };

package/dist/Tour.js

@@ -0,0 +1,54 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_tour_6998cb50__ from "antd/es/tour";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_config_provider_6a57beb3__ from "antd/es/config-provider";
+import "antd/es/theme/useToken";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import "tailwind-merge";
+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 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";
+const Tour = ({ indicatorsRender, ...rest })=>{
+    const cls = useCls();
+    const defaultIndicatorRender = (current, total)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("div", {
+            className: cls("tour-indicator-wrapper"),
+            children: [
+                /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsxs)("span", {
+                    className: cls("tour-indicator-summary-text"),
+                    children: [
+                        current + 1,
+                        " / ",
+                        total
+                    ]
+                }),
+                /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("div", {
+                    children: Array.from({
+                        length: total
+                    }).map((_, index)=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)("span", {
+                            className: clsx(index === current && cls("tour-indicator-active"), cls("tour-indicator"))
+                        }, index))
+                })
+            ]
+        });
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE_antd_es_tour_6998cb50__["default"], {
+        indicatorsRender: indicatorsRender || defaultIndicatorRender,
+        ...rest
+    });
+};
+export { Tour };

package/dist/Tree.js

@@ -0,0 +1,318 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__ from "react/jsx-runtime";
+import * as __WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__ from "@bioturing/assets";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_tree_05ca9855__ from "antd/es/tree";
+import "tailwind-merge";
+import * as __WEBPACK_EXTERNAL_MODULE_antd_es_config_provider_6a57beb3__ from "antd/es/config-provider";
+import "antd/es/theme/useToken";
+"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 getUniqueKeysFromOriginals = (nodes, originalKeysToFind, map)=>{
+    if (!nodes) return [];
+    let keys = [];
+    nodes.forEach((node)=>{
+        const originalKey = map.get(node.key);
+        if (void 0 !== originalKey && originalKeysToFind.has(originalKey)) keys.push(node.key);
+        if (node.children) keys = keys.concat(getUniqueKeysFromOriginals(node.children, originalKeysToFind, map));
+    });
+    return keys;
+};
+const processTreeData = (nodes, expandedOriginalKeys, parentKeyPrefix = "", keyMap)=>{
+    if (!nodes) return;
+    return nodes.map((node)=>{
+        const originalKey = node.key;
+        if (null == originalKey) {
+            console.warn("Tree node is missing a key. Skipping unique key generation for this node and its children.", node);
+            return {
+                ...node
+            };
+        }
+        const separator = "/";
+        const originalKeyString = String(originalKey);
+        if (originalKeyString.includes(separator)) console.warn(`Tree node original key "${originalKeyString}" contains the separator character "${separator}". This might lead to unexpected behavior if keys are not truly unique.`, node);
+        const uniqueKey = parentKeyPrefix ? `${parentKeyPrefix}${separator}${originalKeyString}` : originalKeyString;
+        keyMap.set(uniqueKey, originalKey);
+        const isExpanded = expandedOriginalKeys.has(originalKey);
+        const icon = node.icon || (node.isLeaf ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.File, {}) : isExpanded ? /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.FolderOpen, {}) : /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.Folder, {}));
+        const processedChildren = processTreeData(node.children, expandedOriginalKeys, uniqueKey, keyMap);
+        return {
+            ...node,
+            key: uniqueKey,
+            icon: icon,
+            children: processedChildren
+        };
+    });
+};
+const useUniqueKeysTree = ({ treeData: originTreeData, expandedKeys, defaultExpandedKeys = [], onExpand, checkedKeys, defaultCheckedKeys = [], onCheck, allowDuplicatedKeys })=>{
+    const [currentOriginalExpandedKeys, setCurrentOriginalExpandedKeys] = useControlledState(expandedKeys, void 0, defaultExpandedKeys);
+    const controlledCheckedKeysValue = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        if (!checkedKeys) return;
+        return Array.isArray(checkedKeys) ? checkedKeys : checkedKeys.checked;
+    }, [
+        checkedKeys
+    ]);
+    const [currentOriginalCheckedKeys, setCurrentOriginalCheckedKeys] = useControlledState(controlledCheckedKeysValue, void 0, defaultCheckedKeys);
+    const { processedTreeData, uniqueToOriginalKeyMap } = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        if (!allowDuplicatedKeys) return {
+            processedTreeData: originTreeData,
+            uniqueToOriginalKeyMap: new Map()
+        };
+        const map = new Map();
+        const expandedOriginalKeySet = new Set(currentOriginalExpandedKeys);
+        const data = processTreeData(originTreeData, expandedOriginalKeySet, "", map);
+        return {
+            processedTreeData: data,
+            uniqueToOriginalKeyMap: map
+        };
+    }, [
+        originTreeData,
+        currentOriginalExpandedKeys,
+        allowDuplicatedKeys
+    ]);
+    const currentUniqueExpandedKeys = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        if (!allowDuplicatedKeys) return currentOriginalExpandedKeys;
+        const originalKeysSet = new Set(currentOriginalExpandedKeys);
+        return getUniqueKeysFromOriginals(processedTreeData, originalKeysSet, uniqueToOriginalKeyMap);
+    }, [
+        currentOriginalExpandedKeys,
+        processedTreeData,
+        uniqueToOriginalKeyMap,
+        allowDuplicatedKeys
+    ]);
+    const currentUniqueCheckedKeys = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        if (!allowDuplicatedKeys) return currentOriginalCheckedKeys;
+        const originalKeysSet = new Set(currentOriginalCheckedKeys);
+        return getUniqueKeysFromOriginals(processedTreeData, originalKeysSet, uniqueToOriginalKeyMap);
+    }, [
+        currentOriginalCheckedKeys,
+        processedTreeData,
+        uniqueToOriginalKeyMap,
+        allowDuplicatedKeys
+    ]);
+    const handleOriginalExpand = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((keys, info)=>{
+        const keysArray = Array.from(keys);
+        setCurrentOriginalExpandedKeys(keysArray);
+        if (onExpand) onExpand(keysArray, info);
+    }, [
+        onExpand,
+        setCurrentOriginalExpandedKeys
+    ]);
+    const handleUniqueExpand = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((uniqueKeys, info)=>{
+        const originalKeys = uniqueKeys.map((uk)=>uniqueToOriginalKeyMap.get(uk)).filter((ok)=>void 0 !== ok);
+        const triggeredOriginalKey = uniqueToOriginalKeyMap.get(info.node.key);
+        setCurrentOriginalExpandedKeys(originalKeys);
+        if (onExpand) onExpand(originalKeys, {
+            ...info,
+            triggeredOriginalKey: triggeredOriginalKey
+        });
+    }, [
+        uniqueToOriginalKeyMap,
+        setCurrentOriginalExpandedKeys,
+        onExpand
+    ]);
+    const handleOriginalCheck = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((checkedInfoOrKeys, info)=>{
+        let checkedArray;
+        checkedArray = Array.isArray(checkedInfoOrKeys) ? Array.from(checkedInfoOrKeys) : checkedInfoOrKeys && "object" == typeof checkedInfoOrKeys && "checked" in checkedInfoOrKeys ? Array.from(checkedInfoOrKeys.checked) : [];
+        setCurrentOriginalCheckedKeys(checkedArray);
+        if (onCheck) onCheck(checkedArray, info);
+    }, [
+        onCheck,
+        setCurrentOriginalCheckedKeys
+    ]);
+    const handleUniqueCheck = (0, __WEBPACK_EXTERNAL_MODULE_react__.useCallback)((checkedInfoOrKeys, info)=>{
+        const triggeredUniqueKey = info.node.key;
+        const triggeredOriginalKey = uniqueToOriginalKeyMap.get(triggeredUniqueKey);
+        if (void 0 === triggeredOriginalKey) return void console.error("Could not find original key for unique key:", triggeredUniqueKey);
+        if (!info.checked) {
+            const currentKeys = [
+                ...currentOriginalCheckedKeys
+            ];
+            const newCheckedKeys = currentKeys.filter((key)=>key !== triggeredOriginalKey);
+            setCurrentOriginalCheckedKeys(newCheckedKeys);
+            if (onCheck) onCheck(newCheckedKeys, {
+                ...info,
+                triggeredOriginalKey: triggeredOriginalKey
+            });
+            return;
+        }
+        let uniqueCheckedKeys;
+        uniqueCheckedKeys = Array.isArray(checkedInfoOrKeys) ? checkedInfoOrKeys : checkedInfoOrKeys && "object" == typeof checkedInfoOrKeys && "checked" in checkedInfoOrKeys ? checkedInfoOrKeys.checked : [];
+        const derivedOriginalKeys = new Set();
+        for (const uniqueKey of uniqueCheckedKeys){
+            const originalKey = uniqueToOriginalKeyMap.get(uniqueKey);
+            if (void 0 !== originalKey) derivedOriginalKeys.add(originalKey);
+        }
+        derivedOriginalKeys.add(triggeredOriginalKey);
+        const originalKeysArray = Array.from(derivedOriginalKeys);
+        setCurrentOriginalCheckedKeys(originalKeysArray);
+        if (onCheck) onCheck(originalKeysArray, {
+            ...info,
+            triggeredOriginalKey: triggeredOriginalKey
+        });
+    }, [
+        uniqueToOriginalKeyMap,
+        setCurrentOriginalCheckedKeys,
+        onCheck,
+        currentOriginalCheckedKeys
+    ]);
+    const handleAntTreeExpand = allowDuplicatedKeys ? handleUniqueExpand : handleOriginalExpand;
+    const handleAntTreeCheck = allowDuplicatedKeys ? handleUniqueCheck : handleOriginalCheck;
+    const finalProcessedTreeData = allowDuplicatedKeys ? processedTreeData : originTreeData;
+    return {
+        processedTreeData: finalProcessedTreeData,
+        currentUniqueExpandedKeys,
+        currentUniqueCheckedKeys,
+        handleAntTreeExpand,
+        handleAntTreeCheck
+    };
+};
+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 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 useTreeCommon(props) {
+    const { treeData: originTreeData = [], expandedKeys: propExpandedKeys, defaultExpandedKeys: propDefaultExpandedKeys = [], defaultExpandAll = false, defaultExpandParent = true, onExpand: propOnExpand, checkedKeys, defaultCheckedKeys, onCheck, allowDuplicatedKeys, className, switcherIcon, ...restProps } = props;
+    const resolvedDefaultExpandedKeys = (0, __WEBPACK_EXTERNAL_MODULE_react__.useMemo)(()=>{
+        if (defaultExpandAll) {
+            const keys = [];
+            const traverse = (nodes = [])=>{
+                nodes.forEach((node)=>{
+                    keys.push(node.key);
+                    if (Array.isArray(node.children)) traverse(node.children);
+                });
+            };
+            traverse(originTreeData);
+            return keys;
+        }
+        if (defaultExpandParent && (null == propDefaultExpandedKeys ? void 0 : propDefaultExpandedKeys.length)) {
+            const parentMap = new Map();
+            const traverse = (nodes, parent)=>{
+                nodes.forEach((node)=>{
+                    if (parent) parentMap.set(node.key, parent.key);
+                    const children = Array.isArray(node.children) ? node.children : [];
+                    if (children.length) traverse(children, node);
+                });
+            };
+            traverse(originTreeData);
+            const expanded = new Set(propDefaultExpandedKeys);
+            propDefaultExpandedKeys.forEach((key)=>{
+                let k = key;
+                while(parentMap.has(k)){
+                    const p = parentMap.get(k);
+                    if (!expanded.has(p)) expanded.add(p);
+                    k = p;
+                }
+            });
+            return Array.from(expanded);
+        }
+        return propDefaultExpandedKeys ?? [];
+    }, [
+        originTreeData,
+        defaultExpandAll,
+        defaultExpandParent,
+        propDefaultExpandedKeys
+    ]);
+    const { processedTreeData, currentUniqueExpandedKeys, currentUniqueCheckedKeys, handleAntTreeExpand, handleAntTreeCheck } = useUniqueKeysTree({
+        treeData: originTreeData,
+        expandedKeys: propExpandedKeys,
+        defaultExpandedKeys: resolvedDefaultExpandedKeys,
+        onExpand: propOnExpand,
+        checkedKeys,
+        defaultCheckedKeys,
+        onCheck,
+        allowDuplicatedKeys
+    });
+    const cls = useCls();
+    const customSwitcherIcon = ()=>/*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE__bioturing_assets_dd0c210d__.CaretRight, {
+            weight: "bold",
+            className: cls("caret-switcher-icon")
+        });
+    return {
+        cls,
+        customSwitcherIcon,
+        processedTreeData,
+        currentUniqueExpandedKeys,
+        currentUniqueCheckedKeys,
+        handleAntTreeExpand,
+        handleAntTreeCheck,
+        restProps,
+        className,
+        switcherIcon
+    };
+}
+"use client";
+const MainTreeInner = (props, ref)=>{
+    const { cls, customSwitcherIcon, processedTreeData, currentUniqueExpandedKeys, currentUniqueCheckedKeys, handleAntTreeExpand, handleAntTreeCheck, restProps, className, switcherIcon } = useTreeCommon(props);
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE_antd_es_tree_05ca9855__["default"], {
+        ref: ref,
+        className: clsx(cls("tree"), className),
+        switcherIcon: switcherIcon || customSwitcherIcon,
+        treeData: processedTreeData,
+        expandedKeys: currentUniqueExpandedKeys,
+        onExpand: handleAntTreeExpand,
+        checkedKeys: {
+            checked: currentUniqueCheckedKeys,
+            halfChecked: []
+        },
+        onCheck: handleAntTreeCheck,
+        ...restProps
+    });
+};
+const DirectoryTreeInner = (props, ref)=>{
+    const { cls, customSwitcherIcon, processedTreeData, currentUniqueExpandedKeys, currentUniqueCheckedKeys, handleAntTreeExpand, handleAntTreeCheck, restProps, className, switcherIcon } = useTreeCommon(props);
+    return /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime_225474f2__.jsx)(__WEBPACK_EXTERNAL_MODULE_antd_es_tree_05ca9855__["default"].DirectoryTree, {
+        ref: ref,
+        className: clsx(cls("directory-tree"), className),
+        switcherIcon: switcherIcon || customSwitcherIcon,
+        treeData: processedTreeData,
+        expandedKeys: currentUniqueExpandedKeys,
+        onExpand: handleAntTreeExpand,
+        checkedKeys: {
+            checked: currentUniqueCheckedKeys,
+            halfChecked: []
+        },
+        onCheck: handleAntTreeCheck,
+        ...restProps
+    });
+};
+const MainTree = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(MainTreeInner);
+const DirectoryTree = /*#__PURE__*/ (0, __WEBPACK_EXTERNAL_MODULE_react__.forwardRef)(DirectoryTreeInner);
+const Tree = Object.assign(MainTree, {
+    DirectoryTree,
+    TreeNode: __WEBPACK_EXTERNAL_MODULE_antd_es_tree_05ca9855__["default"].TreeNode
+});
+export { Tree, getUniqueKeysFromOriginals, processTreeData, useUniqueKeysTree };

package/dist/Truncate.js

@@ -0,0 +1,160 @@
+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_antd_es_config_provider_6a57beb3__ from "antd/es/config-provider";
+import "antd/es/theme/useToken";
+import "tailwind-merge";
+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 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(" ");
+};
+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
+        })
+    });
+};
+export { Truncate };