@qsxy/element-plus-react 1.0.0-next.1

package/dist/Tree/utils/conductUtil.js

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/conductUtil.ts
+var conductUtil_exports = {};
+__export(conductUtil_exports, {
+  conductCheck: () => conductCheck,
+  isCheckDisabled: () => isCheckDisabled
+});
+module.exports = __toCommonJS(conductUtil_exports);
+var import_Util = require("../../Util");
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+  const filteredKeys = /* @__PURE__ */ new Set();
+  halfCheckedKeys.forEach((key) => {
+    if (!checkedKeys.has(key)) {
+      filteredKeys.add(key);
+    }
+  });
+  return filteredKeys;
+}
+function isCheckDisabled(node) {
+  const { disabled, disableCheckbox, checkable } = node || {};
+  return !!(disabled || disableCheckbox) || checkable === false;
+}
+function fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
+  const checkedKeys = new Set(keys);
+  const halfCheckedKeys = /* @__PURE__ */ new Set();
+  for (let level = 0; level <= maxLevel; level += 1) {
+    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
+    entities.forEach((entity) => {
+      const { key, node, children = [] } = entity;
+      if (checkedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
+        children.filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach((childEntity) => {
+          checkedKeys.add(childEntity.key);
+        });
+      }
+    });
+  }
+  const visitedKeys = /* @__PURE__ */ new Set();
+  for (let level = maxLevel; level >= 0; level -= 1) {
+    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
+    entities.forEach((entity) => {
+      const { parent, node } = entity;
+      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      let allChecked = true;
+      let partialChecked = false;
+      (parent.children || []).filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach(({ key }) => {
+        const checked = checkedKeys.has(key);
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+      if (allChecked) {
+        checkedKeys.add(parent.key);
+      }
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+      visitedKeys.add(parent.key);
+    });
+  }
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+function cleanConductCheck(keys, halfKeys, levelEntities, maxLevel, syntheticGetCheckDisabled) {
+  const checkedKeys = new Set(keys);
+  let halfCheckedKeys = new Set(halfKeys);
+  for (let level = 0; level <= maxLevel; level += 1) {
+    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
+    entities.forEach((entity) => {
+      const { key, node, children = [] } = entity;
+      if (!checkedKeys.has(key) && !halfCheckedKeys.has(key) && !syntheticGetCheckDisabled(node)) {
+        children.filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach((childEntity) => {
+          checkedKeys.delete(childEntity.key);
+        });
+      }
+    });
+  }
+  halfCheckedKeys = /* @__PURE__ */ new Set();
+  const visitedKeys = /* @__PURE__ */ new Set();
+  for (let level = maxLevel; level >= 0; level -= 1) {
+    const entities = levelEntities.get(level) || /* @__PURE__ */ new Set();
+    entities.forEach((entity) => {
+      const { parent, node } = entity;
+      if (syntheticGetCheckDisabled(node) || !entity.parent || visitedKeys.has(entity.parent.key)) {
+        return;
+      }
+      if (syntheticGetCheckDisabled(entity.parent.node)) {
+        visitedKeys.add(parent.key);
+        return;
+      }
+      let allChecked = true;
+      let partialChecked = false;
+      (parent.children || []).filter((childEntity) => !syntheticGetCheckDisabled(childEntity.node)).forEach(({ key }) => {
+        const checked = checkedKeys.has(key);
+        if (allChecked && !checked) {
+          allChecked = false;
+        }
+        if (!partialChecked && (checked || halfCheckedKeys.has(key))) {
+          partialChecked = true;
+        }
+      });
+      if (!allChecked) {
+        checkedKeys.delete(parent.key);
+      }
+      if (partialChecked) {
+        halfCheckedKeys.add(parent.key);
+      }
+      visitedKeys.add(parent.key);
+    });
+  }
+  return {
+    checkedKeys: Array.from(checkedKeys),
+    halfCheckedKeys: Array.from(removeFromCheckedKeys(halfCheckedKeys, checkedKeys))
+  };
+}
+function conductCheck(keyList, checked, keyEntities, getCheckDisabled) {
+  const warningMissKeys = [];
+  let syntheticGetCheckDisabled;
+  if (getCheckDisabled) {
+    syntheticGetCheckDisabled = getCheckDisabled;
+  } else {
+    syntheticGetCheckDisabled = isCheckDisabled;
+  }
+  const keys = new Set(
+    keyList.filter((key) => {
+      const hasEntity = !!keyEntities[key];
+      if (!hasEntity) {
+        warningMissKeys.push(key);
+      }
+      return hasEntity;
+    })
+  );
+  const levelEntities = /* @__PURE__ */ new Map();
+  let maxLevel = 0;
+  Object.keys(keyEntities).forEach((key) => {
+    const entity = keyEntities[key];
+    const { level } = entity;
+    let levelSet = levelEntities.get(level);
+    if (!levelSet) {
+      levelSet = /* @__PURE__ */ new Set();
+      levelEntities.set(level, levelSet);
+    }
+    levelSet.add(entity);
+    maxLevel = Math.max(maxLevel, level);
+  });
+  (0, import_Util.warning)(
+    !warningMissKeys.length,
+    `Tree missing follow keys: ${warningMissKeys.slice(0, 100).map((key) => `'${key}'`).join(", ")}`
+  );
+  let result;
+  if (checked === true) {
+    result = fillConductCheck(keys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  } else {
+    result = cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, maxLevel, syntheticGetCheckDisabled);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  conductCheck,
+  isCheckDisabled
+});

package/dist/Tree/utils/dictUtil.d.ts

@@ -0,0 +1,8 @@
+import { DataNode, Key } from '../typings';
+export declare function calcRangeKeys<T = DataNode>({ treeData, expandedKeys, startKey, endKey }: {
+    treeData: T[];
+    expandedKeys: Key[];
+    startKey?: Key;
+    endKey?: Key;
+}): Key[];
+export declare function convertDirectoryKeysToNodes<T = DataNode>(treeData: T[], keys: Key[]): T[];

package/dist/Tree/utils/dictUtil.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/dictUtil.ts
+var dictUtil_exports = {};
+__export(dictUtil_exports, {
+  calcRangeKeys: () => calcRangeKeys,
+  convertDirectoryKeysToNodes: () => convertDirectoryKeysToNodes
+});
+module.exports = __toCommonJS(dictUtil_exports);
+function traverseNodesKey(treeData, callback) {
+  function processNode(dataNode) {
+    const { key, children } = dataNode;
+    if (callback(key, dataNode) !== false) {
+      traverseNodesKey(children || [], callback);
+    }
+  }
+  treeData.forEach(processNode);
+}
+function calcRangeKeys({ treeData, expandedKeys, startKey, endKey }) {
+  const keys = [];
+  let record = 0 /* None */;
+  if (startKey && startKey === endKey) {
+    return [startKey];
+  }
+  if (!startKey || !endKey) {
+    return [];
+  }
+  function matchKey(key) {
+    return key === startKey || key === endKey;
+  }
+  traverseNodesKey(treeData, (key) => {
+    if (record === 2 /* End */) {
+      return false;
+    }
+    if (matchKey(key)) {
+      keys.push(key);
+      if (record === 0 /* None */) {
+        record = 1 /* Start */;
+      } else if (record === 1 /* Start */) {
+        record = 2 /* End */;
+        return false;
+      }
+    } else if (record === 1 /* Start */) {
+      keys.push(key);
+    }
+    if (expandedKeys.indexOf(key) === -1) {
+      return false;
+    }
+    return true;
+  });
+  return keys;
+}
+function convertDirectoryKeysToNodes(treeData, keys) {
+  const restKeys = [...keys];
+  const nodes = [];
+  traverseNodesKey(treeData, (key, node) => {
+    const index = restKeys.indexOf(key);
+    if (index !== -1) {
+      nodes.push(node);
+      restKeys.splice(index, 1);
+    }
+    return !!restKeys.length;
+  });
+  return nodes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calcRangeKeys,
+  convertDirectoryKeysToNodes
+});

package/dist/Tree/utils/diffUtil.d.ts

@@ -0,0 +1,6 @@
+import { FlattenNode, Key } from '../typings';
+export declare function findExpandedKeys(prev?: Key[], next?: Key[]): {
+    add: boolean;
+    key: Key;
+};
+export declare function getExpandRange(shorter: FlattenNode[], longer: FlattenNode[], key: Key): FlattenNode[];

package/dist/Tree/utils/diffUtil.js

@@ -0,0 +1,65 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/diffUtil.ts
+var diffUtil_exports = {};
+__export(diffUtil_exports, {
+  findExpandedKeys: () => findExpandedKeys,
+  getExpandRange: () => getExpandRange
+});
+module.exports = __toCommonJS(diffUtil_exports);
+function findExpandedKeys(prev = [], next = []) {
+  const prevLen = prev.length;
+  const nextLen = next.length;
+  if (Math.abs(prevLen - nextLen) !== 1) {
+    return { add: false, key: null };
+  }
+  function find(shorter, longer) {
+    const cache = /* @__PURE__ */ new Map();
+    shorter.forEach((key) => {
+      cache.set(key, true);
+    });
+    const keys = longer.filter((key) => !cache.has(key));
+    return keys.length === 1 ? keys[0] : null;
+  }
+  if (prevLen < nextLen) {
+    return {
+      add: true,
+      key: find(prev, next)
+    };
+  }
+  return {
+    add: false,
+    key: find(next, prev)
+  };
+}
+function getExpandRange(shorter, longer, key) {
+  const shorterStartIndex = shorter.findIndex((data) => data.key === key);
+  const shorterEndNode = shorter[shorterStartIndex + 1];
+  const longerStartIndex = longer.findIndex((data) => data.key === key);
+  if (shorterEndNode) {
+    const longerEndIndex = longer.findIndex((data) => data.key === shorterEndNode.key);
+    return longer.slice(longerStartIndex + 1, longerEndIndex);
+  }
+  return longer.slice(longerStartIndex + 1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findExpandedKeys,
+  getExpandRange
+});

package/dist/Tree/utils/dropIndicator.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export declare const offset = 4;
+interface Props {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+    prefixCls: string;
+    direction: 'ltr' | 'rtl';
+}
+declare const DropIndicatorRender: (props: Props) => React.JSX.Element;
+export default DropIndicatorRender;

package/dist/Tree/utils/dropIndicator.js

@@ -0,0 +1,64 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/dropIndicator.tsx
+var dropIndicator_exports = {};
+__export(dropIndicator_exports, {
+  default: () => dropIndicator_default,
+  offset: () => offset
+});
+module.exports = __toCommonJS(dropIndicator_exports);
+var import_react = __toESM(require("react"));
+var offset = 4;
+var DropIndicatorRender = (props) => {
+  const { dropPosition, dropLevelOffset, prefixCls, indent, direction = "ltr" } = props;
+  const startPosition = direction === "ltr" ? "left" : "right";
+  const endPosition = direction === "ltr" ? "right" : "left";
+  const style = {
+    [startPosition]: -dropLevelOffset * indent + offset,
+    [endPosition]: 0
+  };
+  switch (dropPosition) {
+    case -1:
+      style.top = -3;
+      break;
+    case 1:
+      style.bottom = -3;
+      break;
+    default:
+      style.bottom = -3;
+      style[startPosition] = indent + offset;
+      break;
+  }
+  return /* @__PURE__ */ import_react.default.createElement("div", { style, className: `${prefixCls}-drop-indicator` });
+};
+var dropIndicator_default = DropIndicatorRender;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  offset
+});

package/dist/Tree/utils/iconUtil.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { AntTreeNodeProps } from '../Tree';
+export default function renderSwitcherIcon(prefixCls: string, switcherIcon: React.ReactElement | null | undefined, showLine: boolean | {
+    showLeafIcon: boolean;
+} | undefined, { isLeaf, expanded, loading }: AntTreeNodeProps): React.JSX.Element;

package/dist/Tree/utils/iconUtil.js

@@ -0,0 +1,69 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/iconUtil.tsx
+var iconUtil_exports = {};
+__export(iconUtil_exports, {
+  default: () => renderSwitcherIcon
+});
+module.exports = __toCommonJS(iconUtil_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../../Icon");
+function renderSwitcherIcon(prefixCls, switcherIcon, showLine, { isLeaf, expanded, loading }) {
+  if (loading) {
+    return /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: "fal", name: "loader", spin: true, className: `${prefixCls}-switcher-loading-icon` });
+  }
+  let showLeafIcon;
+  if (showLine && typeof showLine === "object") {
+    showLeafIcon = showLine.showLeafIcon;
+  }
+  if (isLeaf) {
+    if (showLine) {
+      if (typeof showLine === "object" && !showLeafIcon) {
+        return /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-switcher-leaf-line` });
+      }
+      return /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "file", prefix: "fal", className: `${prefixCls}-switcher-line-icon` });
+    }
+    return null;
+  }
+  const switcherCls = `${prefixCls}-switcher-icon`;
+  if ((0, import_react.isValidElement)(switcherIcon)) {
+    return (0, import_react.cloneElement)(switcherIcon, {
+      // @ts-ignore
+      className: (0, import_classnames.default)(switcherIcon.props.className || "", switcherCls)
+    });
+  }
+  if (switcherIcon) {
+    return switcherIcon;
+  }
+  if (showLine) {
+    return expanded ? /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "square-minus", prefix: "far", className: `${prefixCls}-switcher-line-icon` }) : /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "square-plus", prefix: "far", className: `${prefixCls}-switcher-line-icon` });
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-right", prefix: "far", className: switcherCls });
+}

package/dist/Tree/utils/motion.d.ts

@@ -0,0 +1,10 @@
+import { TransitionProps } from '../../Transition';
+export declare const beforeEnter: (el: any) => void;
+export declare const onEnter: (el: HTMLElement) => void;
+export declare const afterEnter: (el: HTMLElement) => void;
+export declare const beforeLeave: (el: any) => void;
+export declare const afterLeave: (el: any) => void;
+declare const collapseMotion: TransitionProps;
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionName };
+export default collapseMotion;

package/dist/Tree/utils/motion.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tree/utils/motion.tsx
+var motion_exports = {};
+__export(motion_exports, {
+  afterEnter: () => afterEnter,
+  afterLeave: () => afterLeave,
+  beforeEnter: () => beforeEnter,
+  beforeLeave: () => beforeLeave,
+  default: () => motion_default,
+  getTransitionName: () => getTransitionName,
+  onEnter: () => onEnter
+});
+module.exports = __toCommonJS(motion_exports);
+var import_dom_lib = require("dom-lib");
+var beforeEnter = (el) => {
+  el.style.height = "0";
+  el.style.opacity = "0";
+};
+var onEnter = (el) => {
+  (0, import_dom_lib.addClass)(el, "r-motion-collapse");
+  el.dataset.oldOverflow = el.style.overflow;
+  if (el.scrollHeight !== 0) {
+    el.style.height = `${el.scrollHeight}px`;
+    el.style.opacity = "1";
+  } else {
+    el.style.height = "";
+  }
+  el.style.overflow = "hidden";
+};
+var afterEnter = (el) => {
+  (0, import_dom_lib.removeClass)(el, "r-motion-collapse");
+  el.style.height = "";
+  el.style.overflow = el.dataset.oldOverflow;
+};
+var beforeLeave = (el) => {
+  (0, import_dom_lib.addClass)(el, "r-motion-collapse");
+  if (!el.dataset) {
+    el.dataset = {};
+  }
+  el.dataset.oldOverflow = el.style.overflow;
+  el.style.height = `${el.scrollHeight}px`;
+  el.style.overflow = "hidden";
+};
+var afterLeave = (el) => {
+  (0, import_dom_lib.removeClass)(el, "r-motion-collapse");
+  el.style.height = "";
+  el.style.overflow = el.dataset.oldOverflow;
+  el.style.display = "";
+};
+var collapseMotion = {
+  name: "r-treenode-collapse",
+  beforeEnter,
+  onEnter,
+  afterEnter,
+  beforeLeave,
+  afterLeave,
+  duration: 300
+};
+var getTransitionName = (rootPrefixCls, motion, transitionName) => {
+  if (transitionName !== void 0) {
+    return transitionName;
+  }
+  return `${rootPrefixCls}-${motion}`;
+};
+var motion_default = collapseMotion;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterEnter,
+  afterLeave,
+  beforeEnter,
+  beforeLeave,
+  getTransitionName,
+  onEnter
+});

package/dist/Tree/utils/pickAttrs.d.ts

@@ -0,0 +1,6 @@
+export interface PickConfig {
+    aria?: boolean;
+    data?: boolean;
+    attr?: boolean;
+}
+export default function pickAttrs(props: object, ariaOnly?: boolean | PickConfig): {};