@bioturing/components 0.15.0 → 0.15.1

package/dist/components/Transition/component.js

@@ -0,0 +1,44 @@
+import { jsx as h } from "react/jsx-runtime";
+import { useRef as y, useEffect as R } from "react";
+import { useRender as b } from "@base-ui-components/react/use-render";
+import { mergeProps as j } from "@base-ui-components/react/merge-props";
+import { useTransitionStatus as v } from "@base-ui-components/react/utils";
+import { useLatestRef as x, useAnimationsFinished as N } from "../hooks/base-ui.js";
+import { clsx as w } from "../utils/cn.js";
+const k = (c) => {
+  const {
+    children: r = /* @__PURE__ */ h("div", {}),
+    className: d,
+    starting: n,
+    ending: o,
+    show: t = !0,
+    keepMounted: s = !1,
+    ...i
+  } = c, { mounted: p, setMounted: a, transitionStatus: e } = v(t), m = x(t), g = w(
+    d,
+    e === "starting" && typeof n == "string" && n,
+    e === "ending" && typeof o == "string" && o
+  ), f = y(null), u = N(f, t), { renderElement: l } = b({
+    render: typeof r == "function" ? r(i, {}) : r,
+    props: j({
+      ...i,
+      ref: f,
+      className: g,
+      "data-starting": e === "starting" ? "true" : void 0,
+      "data-ending": e === "ending" ? "true" : void 0,
+      style: {
+        ...e === "starting" && typeof n == "object" ? n : {},
+        ...e === "ending" && typeof o == "object" ? o : {}
+      }
+    })
+  });
+  return R(() => {
+    s || u(() => {
+      t === m.current && a(t);
+    });
+  }, [t, s, u, a, m]), p ? l() : null;
+};
+export {
+  k as Transition
+};
+//# sourceMappingURL=component.js.map

package/dist/components/Transition/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sources":["../../../src/components/Transition/component.tsx"],"sourcesContent":["\"use client\";\nimport { CSSProperties, useEffect, useRef } from \"react\";\nimport { useRender } from \"@base-ui-components/react/use-render\";\nimport { mergeProps } from \"@base-ui-components/react/merge-props\";\nimport { useTransitionStatus } from \"@base-ui-components/react/utils\";\nimport { clsx } from \"../utils\";\nimport { useAnimationsFinished, useLatestRef } from \"../hooks\";\n\nexport interface TransitionProps\n  extends Omit<useRender.ComponentProps<\"div\">, \"render\" | \"children\"> {\n  /** Whether the component should be shown */\n  show?: boolean;\n  /** CSS classes to apply when the component is opened */\n  starting?: string | CSSProperties;\n  /** CSS classes to apply when the component is closed */\n  ending?: string | CSSProperties;\n  /** CSS classes to apply to the component */\n  className?: string;\n  /** Child component to render */\n  children: useRender.ComponentProps<\"div\">[\"render\"];\n  /** Keep mounted */\n  keepMounted?: boolean;\n}\n\nexport const Transition = (props: TransitionProps) => {\n  const {\n    children = <div />,\n    className,\n    starting,\n    ending,\n    show = true,\n    keepMounted = false,\n    ...otherProps\n  } = props;\n\n  const { mounted, setMounted, transitionStatus } = useTransitionStatus(show);\n  const showRef = useLatestRef(show);\n\n  const combinedClassName = clsx(\n    className,\n    transitionStatus === \"starting\" && typeof starting == \"string\" && starting,\n    transitionStatus === \"ending\" && typeof ending == \"string\" && ending\n  );\n\n  const ref = useRef<HTMLDivElement>(null);\n  const runOnceAnimationsFinish = useAnimationsFinished(ref, show);\n\n  const { renderElement } = useRender({\n    render: typeof children == \"function\" ? children(otherProps, {}) : children,\n    props: mergeProps<\"div\">({\n      ...otherProps,\n      ref,\n      className: combinedClassName,\n      ...{\n        \"data-starting\": transitionStatus === \"starting\" ? \"true\" : undefined,\n        \"data-ending\": transitionStatus === \"ending\" ? \"true\" : undefined,\n      },\n      style: {\n        ...(transitionStatus === \"starting\" && typeof starting === \"object\"\n          ? starting\n          : {}),\n        ...(transitionStatus === \"ending\" && typeof ending === \"object\"\n          ? ending\n          : {}),\n      },\n    } as React.HTMLAttributes<HTMLDivElement>),\n  });\n\n  useEffect(() => {\n    if (keepMounted) return;\n    runOnceAnimationsFinish(() => {\n      if (show === showRef.current) {\n        setMounted(show);\n      }\n    });\n  }, [show, keepMounted, runOnceAnimationsFinish, setMounted, showRef]);\n\n  return mounted ? renderElement() : null;\n};\n"],"names":["Transition","props","children","className","starting","ending","show","keepMounted","otherProps","mounted","setMounted","transitionStatus","useTransitionStatus","showRef","useLatestRef","combinedClassName","clsx","ref","useRef","runOnceAnimationsFinish","useAnimationsFinished","renderElement","useRender","mergeProps","useEffect"],"mappings":";;;;;;;AAwBa,MAAAA,IAAa,CAACC,MAA2B;AAC9C,QAAA;AAAA,IACJ,UAAAC,sBAAY,OAAI,EAAA;AAAA,IAChB,WAAAC;AAAA,IACA,UAAAC;AAAA,IACA,QAAAC;AAAA,IACA,MAAAC,IAAO;AAAA,IACP,aAAAC,IAAc;AAAA,IACd,GAAGC;AAAA,EAAA,IACDP,GAEE,EAAE,SAAAQ,GAAS,YAAAC,GAAY,kBAAAC,EAAiB,IAAIC,EAAoBN,CAAI,GACpEO,IAAUC,EAAaR,CAAI,GAE3BS,IAAoBC;AAAA,IACxBb;AAAA,IACAQ,MAAqB,cAAc,OAAOP,KAAY,YAAYA;AAAA,IAClEO,MAAqB,YAAY,OAAON,KAAU,YAAYA;AAAA,EAChE,GAEMY,IAAMC,EAAuB,IAAI,GACjCC,IAA0BC,EAAsBH,GAAKX,CAAI,GAEzD,EAAE,eAAAe,EAAc,IAAIC,EAAU;AAAA,IAClC,QAAQ,OAAOpB,KAAY,aAAaA,EAASM,GAAY,CAAE,CAAA,IAAIN;AAAA,IACnE,OAAOqB,EAAkB;AAAA,MACvB,GAAGf;AAAA,MACH,KAAAS;AAAA,MACA,WAAWF;AAAA,MAET,iBAAiBJ,MAAqB,aAAa,SAAS;AAAA,MAC5D,eAAeA,MAAqB,WAAW,SAAS;AAAA,MAE1D,OAAO;AAAA,QACL,GAAIA,MAAqB,cAAc,OAAOP,KAAa,WACvDA,IACA,CAAC;AAAA,QACL,GAAIO,MAAqB,YAAY,OAAON,KAAW,WACnDA,IACA,CAAA;AAAA,MAAC;AAAA,IAEgC,CAAA;AAAA,EAAA,CAC1C;AAED,SAAAmB,EAAU,MAAM;AACd,IAAIjB,KACJY,EAAwB,MAAM;AACxB,MAAAb,MAASO,EAAQ,WACnBH,EAAWJ,CAAI;AAAA,IACjB,CACD;AAAA,EAAA,GACA,CAACA,GAAMC,GAAaY,GAAyBT,GAAYG,CAAO,CAAC,GAE7DJ,IAAUY,MAAkB;AACrC;"}

package/dist/components/Tree/components.js

@@ -0,0 +1,67 @@
+import { jsx as T } from "react/jsx-runtime";
+import p from "antd/es/tree";
+import { forwardRef as l } from "react";
+import { useTreeCommon as u } from "./useTreeCommon.js";
+import { clsx as k } from "../utils/cn.js";
+const y = (e, r) => {
+  const {
+    cls: c,
+    customSwitcherIcon: n,
+    processedTreeData: t,
+    currentUniqueExpandedKeys: s,
+    currentUniqueCheckedKeys: o,
+    handleAntTreeExpand: a,
+    handleAntTreeCheck: d,
+    restProps: h,
+    className: i,
+    switcherIcon: m
+  } = u(e);
+  return /* @__PURE__ */ T(
+    p,
+    {
+      ref: r,
+      className: k(c("tree"), i),
+      switcherIcon: m || n,
+      treeData: t,
+      expandedKeys: s,
+      onExpand: a,
+      checkedKeys: { checked: o, halfChecked: [] },
+      onCheck: d,
+      ...h
+    }
+  );
+}, x = (e, r) => {
+  const {
+    cls: c,
+    customSwitcherIcon: n,
+    processedTreeData: t,
+    currentUniqueExpandedKeys: s,
+    currentUniqueCheckedKeys: o,
+    handleAntTreeExpand: a,
+    handleAntTreeCheck: d,
+    restProps: h,
+    className: i,
+    switcherIcon: m
+  } = u(e);
+  return /* @__PURE__ */ T(
+    p.DirectoryTree,
+    {
+      ref: r,
+      className: k(c("directory-tree"), i),
+      switcherIcon: m || n,
+      treeData: t,
+      expandedKeys: s,
+      onExpand: a,
+      checkedKeys: { checked: o, halfChecked: [] },
+      onCheck: d,
+      ...h
+    }
+  );
+}, f = l(y), C = l(x), N = Object.assign(f, {
+  DirectoryTree: C,
+  TreeNode: p.TreeNode
+});
+export {
+  N as Tree
+};
+//# sourceMappingURL=components.js.map

package/dist/components/Tree/components.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.js","sources":["../../../src/components/Tree/components.tsx"],"sourcesContent":["\"use client\";\nimport {\n  default as AntTree,\n  type DataNode as AntTreeDataNode,\n} from \"antd/es/tree\";\n\nimport { forwardRef } from \"react\";\nimport { clsx } from \"../utils\";\nimport type { TreeDataNode, TreeProps, DirectoryTreeProps } from \"./types\";\nimport { useTreeCommon } from \"./useTreeCommon\";\n\n// Create inner function for main Tree with forwarded ref\n// Ensure generic constraint matches TreeProps if it uses AntTreeDataNode\nconst MainTreeInner = <T extends AntTreeDataNode = TreeDataNode>(\n  props: TreeProps<T>,\n  ref: React.Ref<React.ComponentRef<typeof AntTree<T>>>\n) => {\n  const {\n    cls,\n    customSwitcherIcon,\n    processedTreeData,\n    currentUniqueExpandedKeys,\n    currentUniqueCheckedKeys,\n    handleAntTreeExpand,\n    handleAntTreeCheck,\n    restProps,\n    className,\n    switcherIcon,\n  } = useTreeCommon(props);\n\n  return (\n    <AntTree\n      ref={ref}\n      className={clsx(cls(\"tree\"), className)}\n      switcherIcon={switcherIcon || customSwitcherIcon}\n      // Pass processed props to AntTree\n      treeData={processedTreeData}\n      expandedKeys={currentUniqueExpandedKeys}\n      onExpand={handleAntTreeExpand}\n      // Pass checked keys in the object format\n      checkedKeys={{ checked: currentUniqueCheckedKeys, halfChecked: [] }}\n      onCheck={handleAntTreeCheck}\n      {...restProps} // Pass other props like checkable, showLine, etc.\n    />\n  );\n};\n\n// Create inner function for DirectoryTree with forwarded ref\nconst DirectoryTreeInner = <T extends AntTreeDataNode = TreeDataNode>(\n  props: DirectoryTreeProps<T>,\n  ref: React.Ref<React.ComponentRef<typeof AntTree<T>>>\n) => {\n  const {\n    cls,\n    customSwitcherIcon,\n    processedTreeData,\n    currentUniqueExpandedKeys,\n    currentUniqueCheckedKeys,\n    handleAntTreeExpand,\n    handleAntTreeCheck,\n    restProps,\n    className,\n    switcherIcon,\n  } = useTreeCommon(props as any);\n\n  return (\n    <AntTree.DirectoryTree\n      ref={ref}\n      className={clsx(cls(\"directory-tree\"), className)}\n      switcherIcon={switcherIcon || customSwitcherIcon}\n      // Pass processed props to AntTree.DirectoryTree\n      treeData={processedTreeData as T[]}\n      expandedKeys={currentUniqueExpandedKeys}\n      onExpand={handleAntTreeExpand}\n      // Pass checked keys in the object format\n      checkedKeys={{ checked: currentUniqueCheckedKeys, halfChecked: [] }}\n      onCheck={handleAntTreeCheck}\n      {...restProps} // Pass other props like checkable, showLine, etc.\n    />\n  );\n};\n\n// Use forwardRef with type assertion for main Tree\n// Ensure the generic constraint here matches TreeProps\nconst MainTree = forwardRef(MainTreeInner) as <\n  T extends AntTreeDataNode = TreeDataNode // Use AntTreeDataNode if TreeProps uses it\n>(\n  props: TreeProps<T> & {\n    ref?: React.ForwardedRef<React.ComponentRef<typeof AntTree<T>>>;\n  }\n) => ReturnType<typeof MainTreeInner<T>>;\n\n// Use forwardRef with type assertion for DirectoryTree\nconst DirectoryTree = forwardRef(DirectoryTreeInner) as <\n  T extends AntTreeDataNode = AntTreeDataNode\n>(\n  props: DirectoryTreeProps<T> & {\n    ref?: React.ForwardedRef<React.ComponentRef<typeof AntTree<T>>>; // Check ref type consistency\n  }\n) => ReturnType<typeof DirectoryTreeInner<T>>;\n\n// Create the final component with DirectoryTree property\nexport const Tree = Object.assign(MainTree, {\n  DirectoryTree,\n  TreeNode: AntTree.TreeNode,\n});\n"],"names":["MainTreeInner","props","ref","cls","customSwitcherIcon","processedTreeData","currentUniqueExpandedKeys","currentUniqueCheckedKeys","handleAntTreeExpand","handleAntTreeCheck","restProps","className","switcherIcon","useTreeCommon","jsx","AntTree","clsx","DirectoryTreeInner","MainTree","forwardRef","DirectoryTree","Tree"],"mappings":";;;;;AAaA,MAAMA,IAAgB,CACpBC,GACAC,MACG;AACG,QAAA;AAAA,IACJ,KAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,mBAAAC;AAAA,IACA,2BAAAC;AAAA,IACA,0BAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,WAAAC;AAAA,IACA,WAAAC;AAAA,IACA,cAAAC;AAAA,EAAA,IACEC,EAAcZ,CAAK;AAGrB,SAAA,gBAAAa;AAAA,IAACC;AAAA,IAAA;AAAA,MACC,KAAAb;AAAA,MACA,WAAWc,EAAKb,EAAI,MAAM,GAAGQ,CAAS;AAAA,MACtC,cAAcC,KAAgBR;AAAA,MAE9B,UAAUC;AAAA,MACV,cAAcC;AAAA,MACd,UAAUE;AAAA,MAEV,aAAa,EAAE,SAASD,GAA0B,aAAa,CAAA,EAAG;AAAA,MAClE,SAASE;AAAA,MACR,GAAGC;AAAA,IAAA;AAAA,EACN;AAEJ,GAGMO,IAAqB,CACzBhB,GACAC,MACG;AACG,QAAA;AAAA,IACJ,KAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,mBAAAC;AAAA,IACA,2BAAAC;AAAA,IACA,0BAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,WAAAC;AAAA,IACA,WAAAC;AAAA,IACA,cAAAC;AAAA,EAAA,IACEC,EAAcZ,CAAY;AAG5B,SAAA,gBAAAa;AAAA,IAACC,EAAQ;AAAA,IAAR;AAAA,MACC,KAAAb;AAAA,MACA,WAAWc,EAAKb,EAAI,gBAAgB,GAAGQ,CAAS;AAAA,MAChD,cAAcC,KAAgBR;AAAA,MAE9B,UAAUC;AAAA,MACV,cAAcC;AAAA,MACd,UAAUE;AAAA,MAEV,aAAa,EAAE,SAASD,GAA0B,aAAa,CAAA,EAAG;AAAA,MAClE,SAASE;AAAA,MACR,GAAGC;AAAA,IAAA;AAAA,EACN;AAEJ,GAIMQ,IAAWC,EAAWnB,CAAa,GASnCoB,IAAgBD,EAAWF,CAAkB,GAStCI,IAAO,OAAO,OAAOH,GAAU;AAAA,EAC1C,eAAAE;AAAA,EACA,UAAUL,EAAQ;AACpB,CAAC;"}

package/dist/components/Tree/helpers.js

@@ -0,0 +1,53 @@
+import { jsx as l } from "react/jsx-runtime";
+import { File as g, FolderOpen as y, Folder as p } from "@bioturing/assets";
+const k = (n, t, s) => {
+  if (!n) return [];
+  let i = [];
+  return n.forEach((e) => {
+    const r = s.get(e.key);
+    r !== void 0 && t.has(r) && i.push(e.key), e.children && (i = i.concat(
+      k(e.children, t, s)
+    ));
+  }), i;
+}, m = (n, t, s = "", i) => {
+  if (n)
+    return n.map((e) => {
+      const r = e.key;
+      if (r == null)
+        return console.warn(
+          "Tree node is missing a key. Skipping unique key generation for this node and its children.",
+          e
+        ), {
+          ...e
+          // Optionally process children even if parent key is missing
+          // children: processTreeData(node.children as T[] | undefined, expandedOriginalKeys, '', keyMap)
+        };
+      const c = "/", o = String(r);
+      o.includes(c) && console.warn(
+        `Tree node original key "${o}" contains the separator character "${c}". This might lead to unexpected behavior if keys are not truly unique.`,
+        e
+      );
+      const a = s ? `${s}${c}${o}` : o;
+      i.set(a, r);
+      const u = t.has(r), h = e.icon || (e.isLeaf ? /* @__PURE__ */ l(g, {}) : u ? /* @__PURE__ */ l(y, {}) : /* @__PURE__ */ l(p, {})), f = m(
+        e.children,
+        // Cast children to T[]
+        t,
+        a,
+        // Pass the generated unique key as the prefix for children
+        i
+      );
+      return {
+        ...e,
+        key: a,
+        // Override key with the unique one
+        icon: h,
+        children: f
+      };
+    });
+};
+export {
+  k as getUniqueKeysFromOriginals,
+  m as processTreeData
+};
+//# sourceMappingURL=helpers.js.map

package/dist/components/Tree/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":["../../../src/components/Tree/helpers.tsx"],"sourcesContent":["\"use client\";\nimport React, { type Key } from \"react\";\nimport { type DataNode as AntTreeDataNode } from \"antd/es/tree\";\nimport { File, Folder, FolderOpen } from \"@bioturing/assets\";\n\n// Function to recursively find unique keys corresponding to original keys\nexport const getUniqueKeysFromOriginals = (\n  nodes: AntTreeDataNode[] | undefined,\n  originalKeysToFind: Set<Key>,\n  map: Map<Key, Key>\n): Key[] => {\n  if (!nodes) return [];\n  let keys: Key[] = [];\n  nodes.forEach((node) => {\n    const originalKey = map.get(node.key);\n    if (originalKey !== undefined && originalKeysToFind.has(originalKey)) {\n      keys.push(node.key); // Add the unique key\n    }\n    if (node.children) {\n      keys = keys.concat(\n        getUniqueKeysFromOriginals(node.children, originalKeysToFind, map)\n      );\n    }\n  });\n  return keys;\n};\n\n// Helper function to generate unique keys and apply icons\nexport const processTreeData = <T extends AntTreeDataNode = AntTreeDataNode>(\n  nodes: T[] | undefined,\n  expandedOriginalKeys: Set<Key>, // Use Set for faster lookups\n  parentKeyPrefix: string = \"\",\n  keyMap: Map<Key, Key> // Map uniqueKey -> originalKey\n): T[] | undefined => {\n  if (!nodes) return undefined;\n\n  return nodes.map((node) => {\n    const originalKey = node.key;\n    // Ensure nodes have a valid key for unique key generation\n    if (originalKey === null || originalKey === undefined) {\n      console.warn(\n        \"Tree node is missing a key. Skipping unique key generation for this node and its children.\",\n        node\n      );\n      // Return node as is, or handle based on requirements\n      return {\n        ...node,\n        // Optionally process children even if parent key is missing\n        // children: processTreeData(node.children as T[] | undefined, expandedOriginalKeys, '', keyMap)\n      };\n    }\n\n    const separator = \"/\"; // Use / as the separator\n    const originalKeyString = String(originalKey);\n\n    // Warn if the original key contains the separator\n    if (originalKeyString.includes(separator)) {\n      console.warn(\n        `Tree node original key \"${originalKeyString}\" contains the separator character \"${separator}\". This might lead to unexpected behavior if keys are not truly unique.`,\n        node\n      );\n    }\n\n    const uniqueKey = parentKeyPrefix\n      ? `${parentKeyPrefix}${separator}${originalKeyString}` // Use separator\n      : originalKeyString;\n    keyMap.set(uniqueKey, originalKey); // Store mapping uniqueKey -> originalKey\n\n    const isExpanded = expandedOriginalKeys.has(originalKey);\n    // Apply default icons based on expansion state and type (leaf/directory)\n    const icon =\n      node.icon ||\n      (node.isLeaf ? <File /> : isExpanded ? <FolderOpen /> : <Folder />);\n\n    // Recursively process children\n    const processedChildren = processTreeData(\n      node.children as T[] | undefined, // Cast children to T[]\n      expandedOriginalKeys,\n      uniqueKey, // Pass the generated unique key as the prefix for children\n      keyMap\n    );\n\n    return {\n      ...node,\n      key: uniqueKey, // Override key with the unique one\n      icon: icon,\n      children: processedChildren,\n    };\n  });\n};\n"],"names":["getUniqueKeysFromOriginals","nodes","originalKeysToFind","map","keys","node","originalKey","processTreeData","expandedOriginalKeys","parentKeyPrefix","keyMap","separator","originalKeyString","uniqueKey","isExpanded","icon","jsx","File","FolderOpen","Folder","processedChildren"],"mappings":";;AAMO,MAAMA,IAA6B,CACxCC,GACAC,GACAC,MACU;AACN,MAAA,CAACF,EAAO,QAAO,CAAC;AACpB,MAAIG,IAAc,CAAC;AACb,SAAAH,EAAA,QAAQ,CAACI,MAAS;AACtB,UAAMC,IAAcH,EAAI,IAAIE,EAAK,GAAG;AACpC,IAAIC,MAAgB,UAAaJ,EAAmB,IAAII,CAAW,KAC5DF,EAAA,KAAKC,EAAK,GAAG,GAEhBA,EAAK,aACPD,IAAOA,EAAK;AAAA,MACVJ,EAA2BK,EAAK,UAAUH,GAAoBC,CAAG;AAAA,IACnE;AAAA,EACF,CACD,GACMC;AACT,GAGaG,IAAkB,CAC7BN,GACAO,GACAC,IAA0B,IAC1BC,MACoB;AAChB,MAACT;AAEE,WAAAA,EAAM,IAAI,CAACI,MAAS;AACzB,YAAMC,IAAcD,EAAK;AAErB,UAAAC,KAAgB;AACV,uBAAA;AAAA,UACN;AAAA,UACAD;AAAA,QACF,GAEO;AAAA,UACL,GAAGA;AAAA;AAAA;AAAA,QAGL;AAGF,YAAMM,IAAY,KACZC,IAAoB,OAAON,CAAW;AAGxC,MAAAM,EAAkB,SAASD,CAAS,KAC9B,QAAA;AAAA,QACN,2BAA2BC,CAAiB,uCAAuCD,CAAS;AAAA,QAC5FN;AAAA,MACF;AAGI,YAAAQ,IAAYJ,IACd,GAAGA,CAAe,GAAGE,CAAS,GAAGC,CAAiB,KAClDA;AACG,MAAAF,EAAA,IAAIG,GAAWP,CAAW;AAE3B,YAAAQ,IAAaN,EAAqB,IAAIF,CAAW,GAEjDS,IACJV,EAAK,SACJA,EAAK,SAAS,gBAAAW,EAACC,GAAK,CAAA,CAAA,IAAKH,IAAa,gBAAAE,EAACE,GAAW,CAAA,CAAA,sBAAMC,GAAO,CAAA,CAAA,IAG5DC,IAAoBb;AAAA,QACxBF,EAAK;AAAA;AAAA,QACLG;AAAA,QACAK;AAAA;AAAA,QACAH;AAAA,MACF;AAEO,aAAA;AAAA,QACL,GAAGL;AAAA,QACH,KAAKQ;AAAA;AAAA,QACL,MAAAE;AAAA,QACA,UAAUK;AAAA,MACZ;AAAA,IAAA,CACD;AACH;"}

package/dist/components/Tree/useTreeCommon.js

@@ -0,0 +1,86 @@
+import { jsx as v } from "react/jsx-runtime";
+import { useMemo as I } from "react";
+import { CaretRight as M } from "@bioturing/assets";
+import { useUniqueKeysTree as S } from "./useUniqueKeysTree.js";
+import { useCls as U } from "../utils/antdUtils.js";
+function z(h) {
+  const {
+    treeData: o = [],
+    expandedKeys: u,
+    defaultExpandedKeys: r = [],
+    defaultExpandAll: d = !1,
+    defaultExpandParent: i = !0,
+    onExpand: f,
+    checkedKeys: y,
+    defaultCheckedKeys: m,
+    onCheck: x,
+    allowDuplicatedKeys: E,
+    className: K,
+    switcherIcon: k,
+    ...w
+  } = h, A = I(() => {
+    if (d) {
+      const n = [], s = (c = []) => {
+        c.forEach((t) => {
+          n.push(t.key), Array.isArray(t.children) && s(t.children);
+        });
+      };
+      return s(o), n;
+    }
+    if (i && (r != null && r.length)) {
+      const n = /* @__PURE__ */ new Map(), s = (t, a) => {
+        t.forEach((e) => {
+          a && n.set(e.key, a.key);
+          const p = Array.isArray(e.children) ? e.children : [];
+          p.length && s(p, e);
+        });
+      };
+      s(o);
+      const c = new Set(r);
+      return r.forEach((t) => {
+        let a = t;
+        for (; n.has(a); ) {
+          const e = n.get(a);
+          c.has(e) || c.add(e), a = e;
+        }
+      }), Array.from(c);
+    }
+    return r ?? [];
+  }, [
+    o,
+    d,
+    i,
+    r
+  ]), {
+    processedTreeData: C,
+    currentUniqueExpandedKeys: g,
+    currentUniqueCheckedKeys: T,
+    handleAntTreeExpand: D,
+    handleAntTreeCheck: q
+  } = S({
+    treeData: o,
+    expandedKeys: u,
+    defaultExpandedKeys: A,
+    onExpand: f,
+    checkedKeys: y,
+    defaultCheckedKeys: m,
+    onCheck: x,
+    allowDuplicatedKeys: E
+  }), l = U();
+  return {
+    cls: l,
+    customSwitcherIcon: () => /* @__PURE__ */ v(M, { weight: "bold", className: l("caret-switcher-icon") }),
+    processedTreeData: C,
+    currentUniqueExpandedKeys: g,
+    currentUniqueCheckedKeys: T,
+    handleAntTreeExpand: D,
+    handleAntTreeCheck: q,
+    restProps: w,
+    className: K,
+    switcherIcon: k
+  };
+}
+export {
+  z as useTreeCommon
+};
+//# sourceMappingURL=useTreeCommon.js.map

package/dist/components/Tree/useTreeCommon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeCommon.js","sources":["../../../src/components/Tree/useTreeCommon.tsx"],"sourcesContent":["\"use client\";\nimport { type DataNode as AntTreeDataNode } from \"antd/es/tree\";\n\nimport { useMemo, type Key } from \"react\";\nimport { useCls } from \"../utils\";\nimport { CaretRight } from \"@bioturing/assets\";\nimport type { TreeDataNode, TreeProps, DirectoryTreeProps } from \"./types\";\nimport { useUniqueKeysTree } from \"./useUniqueKeysTree\";\n\nexport function useTreeCommon<T extends AntTreeDataNode>(\n  props: TreeProps<T> | DirectoryTreeProps<T>\n) {\n  const {\n    treeData: originTreeData = [],\n    expandedKeys: propExpandedKeys,\n    defaultExpandedKeys: propDefaultExpandedKeys = [],\n    defaultExpandAll = false,\n    defaultExpandParent = true,\n    onExpand: propOnExpand,\n    checkedKeys,\n    defaultCheckedKeys,\n    onCheck,\n    allowDuplicatedKeys,\n    className,\n    switcherIcon,\n    ...restProps\n  } = props;\n\n  // compute resolved defaultExpandedKeys\n  const resolvedDefaultExpandedKeys = useMemo<Key[]>(() => {\n    if (defaultExpandAll) {\n      const keys: Key[] = [];\n      const traverse = (nodes: TreeDataNode[] = []) => {\n        nodes.forEach((node) => {\n          keys.push(node.key);\n          if (Array.isArray(node.children))\n            traverse(node.children as TreeDataNode[]);\n        });\n      };\n      traverse(originTreeData as TreeDataNode[]);\n      return keys;\n    }\n    if (defaultExpandParent && propDefaultExpandedKeys?.length) {\n      // build parent map\n      const parentMap = new Map<Key, Key>();\n      const traverse = (nodes: TreeDataNode[], parent?: TreeDataNode) => {\n        nodes.forEach((node) => {\n          if (parent) parentMap.set(node.key, parent.key);\n          const children = Array.isArray(node.children)\n            ? (node.children as TreeDataNode[])\n            : [];\n          if (children.length) traverse(children, node);\n        });\n      };\n      traverse(originTreeData as TreeDataNode[]);\n      // collect all expansions: original keys + their ancestors\n      const expanded = new Set<Key>(propDefaultExpandedKeys);\n      propDefaultExpandedKeys.forEach((key) => {\n        let k = key;\n        while (parentMap.has(k)) {\n          const p = parentMap.get(k)!;\n          if (!expanded.has(p)) expanded.add(p);\n          k = p;\n        }\n      });\n      return Array.from(expanded);\n    }\n    return propDefaultExpandedKeys ?? [];\n  }, [\n    originTreeData,\n    defaultExpandAll,\n    defaultExpandParent,\n    propDefaultExpandedKeys,\n  ]);\n\n  // use unique keys hook\n  const {\n    processedTreeData,\n    currentUniqueExpandedKeys,\n    currentUniqueCheckedKeys,\n    handleAntTreeExpand,\n    handleAntTreeCheck,\n  } = useUniqueKeysTree({\n    treeData: originTreeData,\n    expandedKeys: propExpandedKeys,\n    defaultExpandedKeys: resolvedDefaultExpandedKeys,\n    onExpand: propOnExpand,\n    checkedKeys,\n    defaultCheckedKeys,\n    onCheck,\n    allowDuplicatedKeys,\n  });\n\n  const cls = useCls();\n  const customSwitcherIcon: TreeProps<T>[\"switcherIcon\"] = () => (\n    <CaretRight weight=\"bold\" className={cls(\"caret-switcher-icon\")} />\n  );\n\n  return {\n    cls,\n    customSwitcherIcon,\n    processedTreeData,\n    currentUniqueExpandedKeys,\n    currentUniqueCheckedKeys,\n    handleAntTreeExpand,\n    handleAntTreeCheck,\n    restProps,\n    className,\n    switcherIcon,\n  };\n}\n"],"names":["useTreeCommon","props","originTreeData","propExpandedKeys","propDefaultExpandedKeys","defaultExpandAll","defaultExpandParent","propOnExpand","checkedKeys","defaultCheckedKeys","onCheck","allowDuplicatedKeys","className","switcherIcon","restProps","resolvedDefaultExpandedKeys","useMemo","keys","traverse","nodes","node","parentMap","parent","children","expanded","key","k","p","processedTreeData","currentUniqueExpandedKeys","currentUniqueCheckedKeys","handleAntTreeExpand","handleAntTreeCheck","useUniqueKeysTree","cls","useCls","jsx","CaretRight"],"mappings":";;;;;AASO,SAASA,EACdC,GACA;AACM,QAAA;AAAA,IACJ,UAAUC,IAAiB,CAAC;AAAA,IAC5B,cAAcC;AAAA,IACd,qBAAqBC,IAA0B,CAAC;AAAA,IAChD,kBAAAC,IAAmB;AAAA,IACnB,qBAAAC,IAAsB;AAAA,IACtB,UAAUC;AAAA,IACV,aAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,SAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,WAAAC;AAAA,IACA,cAAAC;AAAA,IACA,GAAGC;AAAA,EAAA,IACDb,GAGEc,IAA8BC,EAAe,MAAM;AACvD,QAAIX,GAAkB;AACpB,YAAMY,IAAc,CAAC,GACfC,IAAW,CAACC,IAAwB,OAAO;AACzC,QAAAA,EAAA,QAAQ,CAACC,MAAS;AACjB,UAAAH,EAAA,KAAKG,EAAK,GAAG,GACd,MAAM,QAAQA,EAAK,QAAQ,KAC7BF,EAASE,EAAK,QAA0B;AAAA,QAAA,CAC3C;AAAA,MACH;AACA,aAAAF,EAAShB,CAAgC,GAClCe;AAAA,IAAA;AAEL,QAAAX,MAAuBF,KAAA,QAAAA,EAAyB,SAAQ;AAEpD,YAAAiB,wBAAgB,IAAc,GAC9BH,IAAW,CAACC,GAAuBG,MAA0B;AAC3D,QAAAH,EAAA,QAAQ,CAACC,MAAS;AACtB,UAAIE,KAAkBD,EAAA,IAAID,EAAK,KAAKE,EAAO,GAAG;AACxC,gBAAAC,IAAW,MAAM,QAAQH,EAAK,QAAQ,IACvCA,EAAK,WACN,CAAC;AACL,UAAIG,EAAS,UAAiBL,EAAAK,GAAUH,CAAI;AAAA,QAAA,CAC7C;AAAA,MACH;AACA,MAAAF,EAAShB,CAAgC;AAEnC,YAAAsB,IAAW,IAAI,IAASpB,CAAuB;AAC7B,aAAAA,EAAA,QAAQ,CAACqB,MAAQ;AACvC,YAAIC,IAAID;AACD,eAAAJ,EAAU,IAAIK,CAAC,KAAG;AACjB,gBAAAC,IAAIN,EAAU,IAAIK,CAAC;AACzB,UAAKF,EAAS,IAAIG,CAAC,KAAGH,EAAS,IAAIG,CAAC,GAChCD,IAAAC;AAAA,QAAA;AAAA,MACN,CACD,GACM,MAAM,KAAKH,CAAQ;AAAA,IAAA;AAE5B,WAAOpB,KAA2B,CAAC;AAAA,EAAA,GAClC;AAAA,IACDF;AAAA,IACAG;AAAA,IACAC;AAAA,IACAF;AAAA,EAAA,CACD,GAGK;AAAA,IACJ,mBAAAwB;AAAA,IACA,2BAAAC;AAAA,IACA,0BAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,oBAAAC;AAAA,MACEC,EAAkB;AAAA,IACpB,UAAU/B;AAAA,IACV,cAAcC;AAAA,IACd,qBAAqBY;AAAA,IACrB,UAAUR;AAAA,IACV,aAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,SAAAC;AAAA,IACA,qBAAAC;AAAA,EAAA,CACD,GAEKuB,IAAMC,EAAO;AAKZ,SAAA;AAAA,IACL,KAAAD;AAAA,IACA,oBANuD,MACtD,gBAAAE,EAAAC,GAAA,EAAW,QAAO,QAAO,WAAWH,EAAI,qBAAqB,GAAG;AAAA,IAMjE,mBAAAN;AAAA,IACA,2BAAAC;AAAA,IACA,0BAAAC;AAAA,IACA,qBAAAC;AAAA,IACA,oBAAAC;AAAA,IACA,WAAAlB;AAAA,IACA,WAAAF;AAAA,IACA,cAAAC;AAAA,EACF;AACF;"}

package/dist/components/Tree/useUniqueKeysTree.js

@@ -0,0 +1,142 @@
+import { useMemo as p, useCallback as q } from "react";
+import { processTreeData as V, getUniqueKeysFromOriginals as v } from "./helpers.js";
+import { useControlledState as U } from "../hooks/useControlledState.js";
+const N = ({
+  treeData: A,
+  expandedKeys: M,
+  defaultExpandedKeys: K = [],
+  onExpand: u,
+  checkedKeys: d,
+  defaultCheckedKeys: h = [],
+  onCheck: a,
+  allowDuplicatedKeys: i
+}) => {
+  const [c, m] = U(
+    M,
+    void 0,
+    // Handle onChange manually in handlers
+    K
+  ), x = p(() => {
+    if (d)
+      return Array.isArray(d) ? d : d.checked;
+  }, [d]), [g, y] = U(
+    x,
+    // Pass the array of original keys
+    void 0,
+    // Handle onChange manually in handlers
+    h
+  ), { processedTreeData: l, uniqueToOriginalKeyMap: n } = p(() => {
+    if (!i)
+      return {
+        processedTreeData: A,
+        uniqueToOriginalKeyMap: /* @__PURE__ */ new Map()
+      };
+    const e = /* @__PURE__ */ new Map(), t = new Set(c);
+    return { processedTreeData: V(
+      A,
+      t,
+      "",
+      e
+    ), uniqueToOriginalKeyMap: e };
+  }, [A, c, i]), O = p(() => {
+    if (!i)
+      return c;
+    const e = new Set(c);
+    return v(
+      l,
+      e,
+      n
+    );
+  }, [
+    c,
+    l,
+    n,
+    i
+  ]), b = p(() => {
+    if (!i)
+      return g;
+    const e = new Set(g);
+    return v(
+      l,
+      e,
+      n
+    );
+  }, [
+    g,
+    l,
+    n,
+    i
+  ]), j = q(
+    (e, t) => {
+      const r = Array.from(e);
+      m(r), u && u(r, t);
+    },
+    [u, m]
+  ), k = q(
+    (e, t) => {
+      const r = e.map((s) => n.get(s)).filter((s) => s !== void 0), o = n.get(t.node.key);
+      m(r), u && u(r, {
+        ...t,
+        triggeredOriginalKey: o
+      });
+    },
+    [n, m, u]
+  ), E = q(
+    (e, t) => {
+      let r;
+      Array.isArray(e) ? r = Array.from(e) : e && typeof e == "object" && "checked" in e ? r = Array.from(e.checked) : r = [], y(r), a && a(r, t);
+    },
+    [a, y]
+  ), P = q(
+    (e, t) => {
+      const r = t.node.key, o = n.get(r);
+      if (o === void 0) {
+        console.error(
+          "Could not find original key for unique key:",
+          r
+        );
+        return;
+      }
+      if (!t.checked) {
+        const f = [...g].filter(
+          (F) => F !== o
+        );
+        y(f), a && a(f, {
+          ...t,
+          triggeredOriginalKey: o
+        });
+        return;
+      }
+      let s;
+      Array.isArray(e) ? s = e : e && typeof e == "object" && "checked" in e ? s = e.checked : s = [];
+      const T = /* @__PURE__ */ new Set();
+      for (const S of s) {
+        const f = n.get(S);
+        f !== void 0 && T.add(f);
+      }
+      T.add(o);
+      const C = Array.from(T);
+      y(C), a && a(C, {
+        ...t,
+        triggeredOriginalKey: o
+      });
+    },
+    [
+      n,
+      y,
+      a,
+      g
+    ]
+  );
+  return {
+    processedTreeData: i ? l : A,
+    currentUniqueExpandedKeys: O,
+    currentUniqueCheckedKeys: b,
+    handleAntTreeExpand: i ? k : j,
+    handleAntTreeCheck: i ? P : E
+  };
+};
+export {
+  N as useUniqueKeysTree
+};
+//# sourceMappingURL=useUniqueKeysTree.js.map

package/dist/components/Tree/useUniqueKeysTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUniqueKeysTree.js","sources":["../../../src/components/Tree/useUniqueKeysTree.ts"],"sourcesContent":["import { useCallback, useMemo, type Key } from \"react\";\nimport type { DataNode as AntTreeDataNode, EventDataNode } from \"antd/es/tree\";\nimport { useControlledState } from \"../hooks\";\nimport { processTreeData, getUniqueKeysFromOriginals } from \"./helpers\";\nimport type { CheckInfo, ExpandInfo } from \"./types\";\n\ninterface UseUniqueKeysTreeProps<T extends AntTreeDataNode> {\n  treeData: T[] | undefined;\n  expandedKeys?: Key[];\n  defaultExpandedKeys?: Key[];\n  onExpand?: (expandedKeys: Key[], info: ExpandInfo<T>) => void;\n  checkedKeys?: Key[] | { checked: Key[]; halfChecked: Key[] };\n  defaultCheckedKeys?: Key[];\n  onCheck?: (\n    checkedKeys: Key[],\n    info: CheckInfo<T> & { triggeredOriginalKey?: Key }\n  ) => void;\n  allowDuplicatedKeys?: boolean;\n}\n\nexport const useUniqueKeysTree = <T extends AntTreeDataNode>({\n  treeData: originTreeData,\n  expandedKeys,\n  defaultExpandedKeys = [],\n  onExpand,\n  checkedKeys,\n  defaultCheckedKeys = [],\n  onCheck,\n  allowDuplicatedKeys,\n}: UseUniqueKeysTreeProps<T>) => {\n  // Always define all hooks at the top level, regardless of allowDuplicatedKeys\n  // State hook for ORIGINAL expanded keys\n  const [currentOriginalExpandedKeys, setCurrentOriginalExpandedKeys] =\n    useControlledState<Key[]>(\n      expandedKeys,\n      undefined, // Handle onChange manually in handlers\n      defaultExpandedKeys\n    );\n\n  // State hook for ORIGINAL checked keys\n  const controlledCheckedKeysValue = useMemo(() => {\n    if (!checkedKeys) return undefined;\n    return Array.isArray(checkedKeys) ? checkedKeys : checkedKeys.checked;\n  }, [checkedKeys]);\n\n  const [currentOriginalCheckedKeys, setCurrentOriginalCheckedKeys] =\n    useControlledState<Key[]>(\n      controlledCheckedKeysValue, // Pass the array of original keys\n      undefined, // Handle onChange manually in handlers\n      defaultCheckedKeys\n    );\n\n  // Process tree data to handle duplicated keys (only used when allowDuplicatedKeys is true)\n  const { processedTreeData, uniqueToOriginalKeyMap } = useMemo(() => {\n    if (!allowDuplicatedKeys) {\n      // Return a simple passthrough mapping when not handling duplicates\n      return {\n        processedTreeData: originTreeData,\n        uniqueToOriginalKeyMap: new Map<Key, Key>(),\n      };\n    }\n\n    const map = new Map<Key, Key>();\n    const expandedOriginalKeySet = new Set(currentOriginalExpandedKeys);\n    const data = processTreeData(\n      originTreeData,\n      expandedOriginalKeySet,\n      \"\",\n      map\n    );\n    return { processedTreeData: data, uniqueToOriginalKeyMap: map };\n  }, [originTreeData, currentOriginalExpandedKeys, allowDuplicatedKeys]);\n\n  // Create unique keys mappings (only used when allowDuplicatedKeys is true)\n  const currentUniqueExpandedKeys = useMemo(() => {\n    if (!allowDuplicatedKeys) {\n      return currentOriginalExpandedKeys;\n    }\n\n    const originalKeysSet = new Set(currentOriginalExpandedKeys);\n    return getUniqueKeysFromOriginals(\n      processedTreeData as AntTreeDataNode[] | undefined,\n      originalKeysSet,\n      uniqueToOriginalKeyMap\n    );\n  }, [\n    currentOriginalExpandedKeys,\n    processedTreeData,\n    uniqueToOriginalKeyMap,\n    allowDuplicatedKeys,\n  ]);\n\n  const currentUniqueCheckedKeys = useMemo(() => {\n    if (!allowDuplicatedKeys) {\n      return currentOriginalCheckedKeys;\n    }\n\n    const originalKeysSet = new Set(currentOriginalCheckedKeys);\n    return getUniqueKeysFromOriginals(\n      processedTreeData as AntTreeDataNode[] | undefined,\n      originalKeysSet,\n      uniqueToOriginalKeyMap\n    );\n  }, [\n    currentOriginalCheckedKeys,\n    processedTreeData,\n    uniqueToOriginalKeyMap,\n    allowDuplicatedKeys,\n  ]);\n\n  // Simple expand handler for when allowDuplicatedKeys is false\n  const handleOriginalExpand = useCallback(\n    (\n      keys: readonly Key[],\n      info: {\n        node: EventDataNode<T>;\n        expanded: boolean;\n        nativeEvent: MouseEvent;\n      }\n    ) => {\n      const keysArray = Array.from(keys);\n      setCurrentOriginalExpandedKeys(keysArray);\n\n      if (onExpand) {\n        onExpand(keysArray, info);\n      }\n    },\n    [onExpand, setCurrentOriginalExpandedKeys]\n  );\n\n  // Advanced expand handler for when allowDuplicatedKeys is true\n  const handleUniqueExpand = useCallback(\n    (\n      uniqueKeys: readonly Key[],\n      info: {\n        node: EventDataNode<T>;\n        expanded: boolean;\n        nativeEvent: MouseEvent;\n      }\n    ) => {\n      const originalKeys = uniqueKeys\n        .map((uk) => uniqueToOriginalKeyMap.get(uk))\n        .filter((ok): ok is Key => ok !== undefined); // Type guard\n      const triggeredOriginalKey = uniqueToOriginalKeyMap.get(info.node.key);\n\n      setCurrentOriginalExpandedKeys(originalKeys);\n\n      if (onExpand) {\n        onExpand(originalKeys, {\n          ...info,\n          triggeredOriginalKey: triggeredOriginalKey,\n        });\n      }\n    },\n    [uniqueToOriginalKeyMap, setCurrentOriginalExpandedKeys, onExpand]\n  );\n\n  // Simple check handler for when allowDuplicatedKeys is false\n  const handleOriginalCheck = useCallback(\n    (\n      checkedInfoOrKeys:\n        | readonly Key[]\n        | { checked: readonly Key[]; halfChecked: readonly Key[] },\n      info: CheckInfo<T>\n    ) => {\n      let checkedArray: Key[];\n\n      if (Array.isArray(checkedInfoOrKeys)) {\n        checkedArray = Array.from(checkedInfoOrKeys);\n      } else if (\n        checkedInfoOrKeys &&\n        typeof checkedInfoOrKeys === \"object\" &&\n        \"checked\" in checkedInfoOrKeys\n      ) {\n        checkedArray = Array.from(checkedInfoOrKeys.checked);\n      } else {\n        checkedArray = [];\n      }\n\n      setCurrentOriginalCheckedKeys(checkedArray);\n\n      if (onCheck) {\n        onCheck(checkedArray, info);\n      }\n    },\n    [onCheck, setCurrentOriginalCheckedKeys]\n  );\n\n  // Advanced check handler for when allowDuplicatedKeys is true\n  const handleUniqueCheck = useCallback(\n    (\n      checkedInfoOrKeys:\n        | readonly Key[]\n        | { checked: readonly Key[]; halfChecked: readonly Key[] },\n      info: CheckInfo<T> // Contains info about the node that triggered the event\n    ) => {\n      const triggeredUniqueKey = info.node.key;\n      const triggeredOriginalKey =\n        uniqueToOriginalKeyMap.get(triggeredUniqueKey);\n\n      if (triggeredOriginalKey === undefined) {\n        console.error(\n          \"Could not find original key for unique key:\",\n          triggeredUniqueKey\n        );\n        return;\n      }\n\n      // Special handling for unchecking - this is the critical part\n      if (!info.checked) {\n        // When unchecking, we need to completely rebuild the checked keys list\n        // excluding the original key that was unchecked\n\n        // 1. Get the current original checked keys\n        const currentKeys = [...currentOriginalCheckedKeys];\n\n        // 2. Filter out the original key that was unchecked\n        const newCheckedKeys = currentKeys.filter(\n          (key) => key !== triggeredOriginalKey\n        );\n\n        // 3. Update the state with the filtered keys\n        setCurrentOriginalCheckedKeys(newCheckedKeys);\n\n        // 4. Call the user's onCheck callback\n        if (onCheck) {\n          onCheck(newCheckedKeys, {\n            ...info,\n            triggeredOriginalKey: triggeredOriginalKey,\n          });\n        }\n\n        // Return early to prevent further processing\n        return;\n      }\n\n      // Handle checking (normal flow for checking items)\n      // 1. Extract unique checked keys from Ant Design's final state\n      let uniqueCheckedKeys: readonly Key[];\n      if (Array.isArray(checkedInfoOrKeys)) {\n        uniqueCheckedKeys = checkedInfoOrKeys;\n      } else if (\n        checkedInfoOrKeys &&\n        typeof checkedInfoOrKeys === \"object\" &&\n        \"checked\" in checkedInfoOrKeys\n      ) {\n        uniqueCheckedKeys = checkedInfoOrKeys.checked;\n      } else {\n        uniqueCheckedKeys = [];\n      }\n\n      // 2. Map these unique keys to their original keys\n      const derivedOriginalKeys = new Set<Key>();\n      for (const uniqueKey of uniqueCheckedKeys) {\n        const originalKey = uniqueToOriginalKeyMap.get(uniqueKey);\n        if (originalKey !== undefined) {\n          derivedOriginalKeys.add(originalKey);\n        }\n      }\n\n      // 3. Ensure the triggered original key is included when checking\n      derivedOriginalKeys.add(triggeredOriginalKey);\n\n      const originalKeysArray = Array.from(derivedOriginalKeys);\n\n      // 4. Update the controlled state\n      setCurrentOriginalCheckedKeys(originalKeysArray);\n\n      // 5. Call the user's onCheck callback\n      if (onCheck) {\n        onCheck(originalKeysArray, {\n          ...info,\n          triggeredOriginalKey: triggeredOriginalKey,\n        });\n      }\n    },\n    [\n      uniqueToOriginalKeyMap,\n      setCurrentOriginalCheckedKeys,\n      onCheck,\n      currentOriginalCheckedKeys,\n    ]\n  );\n\n  // Choose appropriate handlers and data based on allowDuplicatedKeys\n  const handleAntTreeExpand = allowDuplicatedKeys\n    ? handleUniqueExpand\n    : handleOriginalExpand;\n  const handleAntTreeCheck = allowDuplicatedKeys\n    ? handleUniqueCheck\n    : handleOriginalCheck;\n  const finalProcessedTreeData = allowDuplicatedKeys\n    ? processedTreeData\n    : originTreeData;\n\n  return {\n    processedTreeData: finalProcessedTreeData,\n    currentUniqueExpandedKeys,\n    currentUniqueCheckedKeys,\n    handleAntTreeExpand,\n    handleAntTreeCheck,\n  };\n};\n"],"names":["useUniqueKeysTree","originTreeData","expandedKeys","defaultExpandedKeys","onExpand","checkedKeys","defaultCheckedKeys","onCheck","allowDuplicatedKeys","currentOriginalExpandedKeys","setCurrentOriginalExpandedKeys","useControlledState","controlledCheckedKeysValue","useMemo","currentOriginalCheckedKeys","setCurrentOriginalCheckedKeys","processedTreeData","uniqueToOriginalKeyMap","map","expandedOriginalKeySet","processTreeData","currentUniqueExpandedKeys","originalKeysSet","getUniqueKeysFromOriginals","currentUniqueCheckedKeys","handleOriginalExpand","useCallback","keys","info","keysArray","handleUniqueExpand","uniqueKeys","originalKeys","uk","ok","triggeredOriginalKey","handleOriginalCheck","checkedInfoOrKeys","checkedArray","handleUniqueCheck","triggeredUniqueKey","newCheckedKeys","key","uniqueCheckedKeys","derivedOriginalKeys","uniqueKey","originalKey","originalKeysArray"],"mappings":"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"}

package/dist/components/Truncate/component.js

@@ -0,0 +1,93 @@
+import { jsx as W } from "react/jsx-runtime";
+import { useRef as N, useState as z, useCallback as P, useLayoutEffect as D } from "react";
+import { getMiddleTruncatedString as G } from "./helpers.js";
+import './style.css';/* empty css          */
+import { useCls as J } from "../utils/antdUtils.js";
+import { clsx as K } from "../utils/cn.js";
+const ee = ({
+  children: h,
+  position: a = "end",
+  lines: r = 1,
+  className: E,
+  style: f,
+  ...O
+}) => {
+  const l = J(), y = N(null), [R, p] = z(!1), [g, d] = z(h), n = h, k = P(() => r !== "auto" ? {
+    ...f,
+    ...r > 1 ? { "--ds-line-clamp": r } : {}
+  } : {
+    ...f,
+    // Set a temporary high value to ensure it fits the parent
+    "--ds-line-clamp": 999
+  }, [r, f]);
+  return D(() => {
+    var v, T, H, x, C, S;
+    const e = y.current;
+    if (!e) return;
+    if (r === "auto") {
+      d(n);
+      const i = () => {
+        const t = e.parentElement;
+        if (!t) return;
+        const s = window.getComputedStyle(e), q = parseFloat(s.fontSize), B = s.lineHeight === "normal" ? q * 1.2 : parseFloat(s.lineHeight), m = window.getComputedStyle(t), A = parseFloat(m.paddingTop) || 0, L = parseFloat(m.paddingBottom) || 0, M = parseFloat(m.borderTopWidth) || 0, I = parseFloat(m.borderBottomWidth) || 0, F = t.clientHeight - A - L - M - I, $ = Math.max(1, Math.floor(F / B));
+        e && e.style.setProperty("--ds-line-clamp", String($));
+        const o = document.createElement("span");
+        o.style.visibility = "hidden", o.style.position = "absolute", o.style.width = `${e.clientWidth}px`, o.style.fontSize = s.fontSize, o.style.fontFamily = s.fontFamily, o.style.lineHeight = s.lineHeight, o.textContent = n, document.body.appendChild(o);
+        const j = o.scrollHeight > F;
+        document.body.removeChild(o), p(j);
+      };
+      (T = (v = window.document.fonts) == null ? void 0 : v.ready) == null || T.then(i);
+      const c = new ResizeObserver(() => {
+        window.requestAnimationFrame(i);
+      });
+      return c.observe(e), e.parentElement && c.observe(e.parentElement), () => c.disconnect();
+    }
+    if (typeof r == "number" && r > 1) {
+      d(n);
+      const i = () => {
+        const t = document.createElement("span");
+        t.style.visibility = "hidden", t.style.position = "absolute", t.style.width = `${e.clientWidth}px`, t.textContent = n, document.body.appendChild(t);
+        const s = t.scrollHeight > (e.clientHeight || e.offsetHeight);
+        document.body.removeChild(t), p(s);
+      };
+      (x = (H = window.document.fonts) == null ? void 0 : H.ready) == null || x.then(i);
+      const c = new ResizeObserver(() => {
+        window.requestAnimationFrame(i);
+      });
+      return c.observe(e), () => c.disconnect();
+    }
+    let u = { cancelled: !1 };
+    const b = () => {
+      u && (u.cancelled = !0);
+      const i = { cancelled: !1 };
+      u = i;
+      const c = G(n, "…", e);
+      i.cancelled || d(c);
+    };
+    a == "middle" && ((S = (C = window.document.fonts) == null ? void 0 : C.ready) == null || S.then(b)), a == "end" && d(n);
+    const w = new ResizeObserver(() => {
+      a == "middle" && window.requestAnimationFrame(b), a == "end" && e.scrollWidth > e.clientWidth && p(!0);
+    });
+    return w.observe(e), () => {
+      u.cancelled = !0, w.disconnect();
+    };
+  }, [n, a, r]), /* @__PURE__ */ W(
+    "span",
+    {
+      ref: y,
+      style: k(),
+      className: K(
+        l(r === 1 ? "truncate" : "truncate-multiline"),
+        l(a === "middle" ? "truncate-middle" : "truncate-end"),
+        E
+      ),
+      title: R ? n : void 0,
+      ...O,
+      children: n === g ? n : /* @__PURE__ */ W("span", { children: g })
+    }
+  );
+};
+export {
+  ee as Truncate
+};
+//# sourceMappingURL=component.js.map

package/dist/components/Truncate/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sources":["../../../src/components/Truncate/component.tsx"],"sourcesContent":["\"use client\";\nimport React, { useCallback, useLayoutEffect, useRef, useState } from \"react\";\nimport { clsx, useCls } from \"../utils\";\nimport { getMiddleTruncatedString } from \"./helpers\";\n\nimport \"./style.css\";\n\nexport type TruncatePosition = \"middle\" | \"end\";\n\nexport type Props = {\n  text: string;\n} & React.CSSProperties;\n\nexport interface TruncateProps\n  extends Omit<React.ComponentPropsWithoutRef<\"span\">, \"title\"> {\n  /** Text content to be truncated */\n  children: string;\n  /** Where to truncate the text: start, middle, or end */\n  position?: TruncatePosition;\n  /** Number of lines to display before truncating (default: 1, 'auto' to fit parent height) */\n  lines?: number | \"auto\";\n}\n\nexport const Truncate: React.FC<TruncateProps> = ({\n  children,\n  position = \"end\",\n  lines = 1,\n  className,\n  style,\n  ...rest\n}) => {\n  const cls = useCls();\n  const containerRef = useRef<HTMLElement>(null);\n  const [isTruncated, setIsTruncated] = useState(false);\n  const [truncatedText, setTruncatedText] = useState(children);\n\n  const text = children;\n\n  // Get appropriate container styles based on position and lines\n  const getContainerStyles = useCallback(() => {\n    // For explicit line numbers or single line\n    if (lines !== \"auto\") {\n      return {\n        ...style,\n        ...(lines > 1 ? { \"--ds-line-clamp\": lines } : {}),\n      } as React.CSSProperties;\n    }\n\n    // For auto line calculation, we'll let the useLayoutEffect handle it\n    return {\n      ...style,\n      // Set a temporary high value to ensure it fits the parent\n      \"--ds-line-clamp\": 999,\n    } as React.CSSProperties;\n  }, [lines, style]);\n\n  useLayoutEffect(() => {\n    const container = containerRef.current;\n    if (!container) return;\n\n    // Handle auto-height calculation\n    if (lines === \"auto\") {\n      setTruncatedText(text);\n\n      const calculateLines = () => {\n        // Get the parent element's height\n        const parent = container.parentElement;\n        if (!parent) return;\n\n        // Calculate the font size and line height\n        const styles = window.getComputedStyle(container);\n        const fontSize = parseFloat(styles.fontSize);\n        const lineHeight =\n          styles.lineHeight === \"normal\"\n            ? fontSize * 1.2 // Approximate for \"normal\"\n            : parseFloat(styles.lineHeight);\n\n        // Get parent's padding and border to subtract from available height\n        const parentStyles = window.getComputedStyle(parent);\n        const paddingTop = parseFloat(parentStyles.paddingTop) || 0;\n        const paddingBottom = parseFloat(parentStyles.paddingBottom) || 0;\n        const borderTopWidth = parseFloat(parentStyles.borderTopWidth) || 0;\n        const borderBottomWidth =\n          parseFloat(parentStyles.borderBottomWidth) || 0;\n\n        // Calculate how many lines can fit in the available space\n        const parentHeight = parent.clientHeight;\n        const availableHeight =\n          parentHeight -\n          paddingTop -\n          paddingBottom -\n          borderTopWidth -\n          borderBottomWidth;\n        const maxLines = Math.max(1, Math.floor(availableHeight / lineHeight));\n\n        // Apply the calculated line-clamp\n        if (container) {\n          container.style.setProperty(\"--ds-line-clamp\", String(maxLines));\n        }\n\n        // Check if the text is truncated\n        const clone = document.createElement(\"span\");\n        clone.style.visibility = \"hidden\";\n        clone.style.position = \"absolute\";\n        clone.style.width = `${container.clientWidth}px`;\n        clone.style.fontSize = styles.fontSize;\n        clone.style.fontFamily = styles.fontFamily;\n        clone.style.lineHeight = styles.lineHeight;\n        clone.textContent = text;\n        document.body.appendChild(clone);\n\n        const isTruncated = clone.scrollHeight > availableHeight;\n        document.body.removeChild(clone);\n\n        setIsTruncated(isTruncated);\n      };\n\n      window.document.fonts?.ready?.then(calculateLines);\n      const observer = new ResizeObserver(() => {\n        window.requestAnimationFrame(calculateLines);\n      });\n\n      observer.observe(container);\n      if (container.parentElement) {\n        observer.observe(container.parentElement);\n      }\n\n      return () => observer.disconnect();\n    }\n\n    // Skip custom truncation logic for multi-line mode\n    if (typeof lines === \"number\" && lines > 1) {\n      setTruncatedText(text);\n      // Check if text is truncated by comparing heights\n      const checkIfTruncated = () => {\n        const clone = document.createElement(\"span\");\n        clone.style.visibility = \"hidden\";\n        clone.style.position = \"absolute\";\n        clone.style.width = `${container.clientWidth}px`;\n        clone.textContent = text;\n        document.body.appendChild(clone);\n        const isTruncated =\n          clone.scrollHeight >\n          (container.clientHeight || container.offsetHeight);\n        document.body.removeChild(clone);\n        setIsTruncated(isTruncated);\n      };\n\n      window.document.fonts?.ready?.then(checkIfTruncated);\n      const observer = new ResizeObserver(() => {\n        window.requestAnimationFrame(checkIfTruncated);\n      });\n\n      observer.observe(container);\n      return () => observer.disconnect();\n    }\n\n    // Original single-line truncation logic\n    let cancellationToken = { cancelled: false };\n\n    const calculateTruncatedString = () => {\n      if (cancellationToken) cancellationToken.cancelled = true;\n\n      const requestCancellationToken = { cancelled: false };\n      cancellationToken = requestCancellationToken;\n\n      const truncated = getMiddleTruncatedString(text, \"\\u2026\", container);\n\n      if (requestCancellationToken.cancelled) return;\n\n      setTruncatedText(truncated);\n    };\n\n    if (position == \"middle\") {\n      window.document.fonts?.ready?.then(calculateTruncatedString);\n    }\n\n    if (position == \"end\") {\n      setTruncatedText(text);\n    }\n\n    const observer = new ResizeObserver(() => {\n      if (position == \"middle\")\n        window.requestAnimationFrame(calculateTruncatedString);\n      if (position == \"end\") {\n        const isOverflowing = container.scrollWidth > container.clientWidth;\n        if (isOverflowing) {\n          setIsTruncated(true);\n        }\n      }\n    });\n\n    observer.observe(container);\n\n    return () => {\n      cancellationToken.cancelled = true;\n      observer.disconnect();\n    };\n  }, [text, position, lines]);\n\n  return (\n    <span\n      ref={containerRef}\n      style={getContainerStyles()}\n      className={clsx(\n        lines === 1 ? cls(\"truncate\") : cls(\"truncate-multiline\"),\n        position === \"middle\" ? cls(\"truncate-middle\") : cls(\"truncate-end\"),\n        className\n      )}\n      title={isTruncated ? text : undefined}\n      {...rest}\n    >\n      {text === truncatedText ? text : <span>{truncatedText}</span>}\n    </span>\n  );\n};\n"],"names":["Truncate","children","position","lines","className","style","rest","cls","useCls","containerRef","useRef","isTruncated","setIsTruncated","useState","truncatedText","setTruncatedText","text","getContainerStyles","useCallback","useLayoutEffect","container","calculateLines","parent","styles","fontSize","lineHeight","parentStyles","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","availableHeight","maxLines","clone","_b","_a","observer","checkIfTruncated","_d","_c","cancellationToken","calculateTruncatedString","requestCancellationToken","truncated","getMiddleTruncatedString","_f","_e","jsx","clsx"],"mappings":"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"}

package/dist/components/Truncate/helpers.js

@@ -0,0 +1,36 @@
+const b = (e) => {
+  const t = document.createElement("span");
+  return t.style.opacity = "0", t.style.position = "absolute", t.style.top = "-1000px", t.style.left = "-1000px", t.style.whiteSpace = "nowrap", t.style.pointerEvents = "none", e.appendChild(t), {
+    measure: (o) => (t.innerText = o, t.clientWidth),
+    destroy: () => {
+      e.removeChild(t);
+    }
+  };
+}, g = (e, t, o) => {
+  var h;
+  if (!e) return e;
+  const { measure: i, destroy: l } = b(o), d = i(e), s = o.clientWidth, f = Math.floor(s / d * e.length);
+  if (d <= s)
+    return l(), e;
+  let n = f;
+  const r = {}, p = 20, m = 10;
+  for (; Object.values(r).length <= p && !r[n]; ) {
+    if (n <= 1) {
+      r[0] = [0, t];
+      break;
+    }
+    const a = e.slice(0, Math.ceil((n - t.length) / 2 - 1)).trimEnd(), y = e.slice(Math.floor((n - t.length) / 2) - n).trimStart(), u = a + t + y, c = i(u);
+    if (r[n] = [c, u], c >= s)
+      n = n - 2;
+    else {
+      if (s - c < m) break;
+      n = n + 2;
+    }
+  }
+  return l(), ((h = Object.values(r).reverse().find(([a]) => a < s)) == null ? void 0 : h[1]) ?? Object.values(r)[0][1];
+};
+export {
+  g as getMiddleTruncatedString,
+  b as measureText
+};
+//# sourceMappingURL=helpers.js.map

package/dist/components/Truncate/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":["../../../src/components/Truncate/helpers.ts"],"sourcesContent":["export const measureText = (container: HTMLElement) => {\n  const span = document.createElement(\"span\");\n  span.style.opacity = \"0\";\n  span.style.position = \"absolute\";\n  span.style.top = \"-1000px\";\n  span.style.left = \"-1000px\";\n  span.style.whiteSpace = \"nowrap\";\n  span.style.pointerEvents = \"none\";\n  container.appendChild(span);\n\n  return {\n    measure: (text: string) => {\n      span.innerText = text;\n      return span.clientWidth;\n    },\n    destroy: () => {\n      container.removeChild(span);\n    },\n  };\n};\n\nexport const getMiddleTruncatedString = (\n  text: string,\n  ellipsis: string,\n  container: HTMLElement\n): string => {\n  if (!text) return text;\n\n  const { measure: getTextWidth, destroy: destroyMeasure } =\n    measureText(container);\n\n  const textWidth = getTextWidth(text);\n  const containerWidth = container.clientWidth;\n  const initialOffset = Math.floor((containerWidth / textWidth) * text.length);\n\n  if (textWidth <= containerWidth) {\n    destroyMeasure();\n    return text;\n  }\n\n  let offset = initialOffset;\n  const attempts: Record<number, [number, string]> = {};\n  const maxAttempts = 20;\n  const buffer = 10;\n\n  while (Object.values(attempts).length <= maxAttempts) {\n    // If we have already tried this offset, stop\n    if (attempts[offset]) break;\n\n    // If we are at the beginning of the string, just return the ellipsis\n    if (offset <= 1) {\n      attempts[0] = [0, ellipsis];\n      break;\n    }\n\n    const start = text\n      .slice(0, Math.ceil((offset - ellipsis.length) / 2 - 1))\n      .trimEnd();\n    const end = text\n      .slice(Math.floor((offset - ellipsis.length) / 2) - offset)\n      .trimStart();\n    const truncatedStr = start + ellipsis + end;\n    const width = getTextWidth(truncatedStr);\n\n    attempts[offset] = [width, truncatedStr];\n\n    if (width >= containerWidth) {\n      offset = offset - 2;\n    } else {\n      // If we are close to the container width, stop\n      if (containerWidth - width < buffer) break;\n      offset = offset + 2;\n    }\n  }\n\n  // Remove the span element used for measuring text\n  destroyMeasure();\n\n  // Find the closest attempt that is smaller than the container width\n  return (\n    Object.values(attempts)\n      .reverse()\n      .find(([width]) => width < containerWidth)?.[1] ??\n    Object.values(attempts)[0][1]\n  );\n};\n"],"names":["measureText","container","span","text","getMiddleTruncatedString","ellipsis","_a","getTextWidth","destroyMeasure","textWidth","containerWidth","initialOffset","offset","attempts","maxAttempts","buffer","start","end","truncatedStr","width"],"mappings":"AAAa,MAAAA,IAAc,CAACC,MAA2B;AAC/C,QAAAC,IAAO,SAAS,cAAc,MAAM;AAC1C,SAAAA,EAAK,MAAM,UAAU,KACrBA,EAAK,MAAM,WAAW,YACtBA,EAAK,MAAM,MAAM,WACjBA,EAAK,MAAM,OAAO,WAClBA,EAAK,MAAM,aAAa,UACxBA,EAAK,MAAM,gBAAgB,QAC3BD,EAAU,YAAYC,CAAI,GAEnB;AAAA,IACL,SAAS,CAACC,OACRD,EAAK,YAAYC,GACVD,EAAK;AAAA,IAEd,SAAS,MAAM;AACb,MAAAD,EAAU,YAAYC,CAAI;AAAA,IAAA;AAAA,EAE9B;AACF,GAEaE,IAA2B,CACtCD,GACAE,GACAJ,MACW;AAzBA,MAAAK;AA0BP,MAAA,CAACH,EAAa,QAAAA;AAElB,QAAM,EAAE,SAASI,GAAc,SAASC,EAAe,IACrDR,EAAYC,CAAS,GAEjBQ,IAAYF,EAAaJ,CAAI,GAC7BO,IAAiBT,EAAU,aAC3BU,IAAgB,KAAK,MAAOD,IAAiBD,IAAaN,EAAK,MAAM;AAE3E,MAAIM,KAAaC;AACA,WAAAF,EAAA,GACRL;AAGT,MAAIS,IAASD;AACb,QAAME,IAA6C,CAAC,GAC9CC,IAAc,IACdC,IAAS;AAEf,SAAO,OAAO,OAAOF,CAAQ,EAAE,UAAUC,KAEnC,CAAAD,EAASD,CAAM,KAFiC;AAKpD,QAAIA,KAAU,GAAG;AACf,MAAAC,EAAS,CAAC,IAAI,CAAC,GAAGR,CAAQ;AAC1B;AAAA,IAAA;AAGF,UAAMW,IAAQb,EACX,MAAM,GAAG,KAAK,MAAMS,IAASP,EAAS,UAAU,IAAI,CAAC,CAAC,EACtD,QAAQ,GACLY,IAAMd,EACT,MAAM,KAAK,OAAOS,IAASP,EAAS,UAAU,CAAC,IAAIO,CAAM,EACzD,UAAU,GACPM,IAAeF,IAAQX,IAAWY,GAClCE,IAAQZ,EAAaW,CAAY;AAIvC,QAFAL,EAASD,CAAM,IAAI,CAACO,GAAOD,CAAY,GAEnCC,KAAST;AACX,MAAAE,IAASA,IAAS;AAAA,SACb;AAED,UAAAF,IAAiBS,IAAQJ,EAAQ;AACrC,MAAAH,IAASA,IAAS;AAAA,IAAA;AAAA,EACpB;AAIa,SAAAJ,EAAA,KAIbF,IAAA,OAAO,OAAOO,CAAQ,EACnB,UACA,KAAK,CAAC,CAACM,CAAK,MAAMA,IAAQT,CAAc,MAF3C,gBAAAJ,EAE+C,OAC/C,OAAO,OAAOO,CAAQ,EAAE,CAAC,EAAE,CAAC;AAEhC;"}