@nickeylin/antd-mobile-pro 2.0.0

package/dist/cjs/components/tree/tree.js

@@ -0,0 +1,198 @@
+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/components/tree/tree.tsx
+var tree_exports = {};
+__export(tree_exports, {
+  default: () => tree_default
+});
+module.exports = __toCommonJS(tree_exports);
+var import_icons = require("@ant-design/icons");
+var import_antd_mobile = require("antd-mobile");
+var import_classnames = __toESM(require("classnames"));
+var import_lodash = require("lodash");
+var import_rc_tree = __toESM(require("rc-tree"));
+var import_react = require("react");
+var import_bem = require("../../utils/bem");
+var import_remote_data_props = require("../../utils/remote-data-props");
+var import_config_provider = require("../config-provider");
+var import_helper = require("../pro-list/helper");
+var import_DirectoryTree = __toESM(require("./DirectoryTree"));
+var import_iconUtil = __toESM(require("./utils/iconUtil"));
+var import_motion = __toESM(require("./utils/motion"));
+var bem = (0, import_bem.cn)("tree");
+function transformTreeData(treeData, rowKey, titleKey) {
+  return treeData.map((node, nIndex) => {
+    const key = (0, import_helper.getRowKey)(rowKey, node, nIndex);
+    const newObj = { ...node, key };
+    if (newObj.children) {
+      newObj.children = transformTreeData(
+        newObj.children,
+        rowKey,
+        titleKey
+      );
+    }
+    return newObj;
+  });
+}
+function filterNodes(searchValue, treeData) {
+  const newArr = [];
+  treeData.forEach((treeNode) => {
+    const filterName = "name";
+    const fieldValue = (0, import_lodash.get)(treeNode, filterName, "") || "";
+    if (fieldValue !== "" && fieldValue !== null && fieldValue !== void 0 && fieldValue.toLowerCase().indexOf(searchValue) > -1) {
+      newArr.push(treeNode);
+    } else if (treeNode.children && treeNode.children.length > 0) {
+      const ab = filterNodes(searchValue, treeNode.children);
+      const obj = {
+        ...treeNode,
+        children: ab
+      };
+      if (ab && ab.length > 0) {
+        newArr.push(obj);
+      }
+    }
+  });
+  return newArr;
+}
+function Tree(props) {
+  var _a;
+  const {
+    rowKey = "key",
+    // titleKey = 'title',
+    titleRender,
+    prefixCls = "suid-tree",
+    treeRef,
+    search,
+    defaultExpandAll = true,
+    className,
+    style,
+    bodyClassName,
+    bodyStyle,
+    checkable,
+    draggable,
+    showLine,
+    ...restProps
+  } = props;
+  const { locale } = (0, import_config_provider.useConfig)();
+  const [searchValue, setSearchValue] = (0, import_react.useState)("");
+  const titleKey = ((_a = props.fieldNames) == null ? void 0 : _a.title) ?? "title";
+  const { data, loading } = (0, import_remote_data_props.useFetchRemoteData)(props, {
+    componentName: "Tree",
+    postData(d) {
+      return d ? transformTreeData(d, rowKey, titleKey) : d;
+    }
+  });
+  const dataList = (0, import_react.useMemo)(() => {
+    if (!data)
+      return [];
+    return searchValue ? filterNodes(searchValue, data) : data;
+  }, [data, searchValue]);
+  const draggableConfig = (0, import_react.useMemo)(() => {
+    if (!draggable) {
+      return false;
+    }
+    let mergedDraggable = {};
+    switch (typeof draggable) {
+      case "function":
+        mergedDraggable.nodeDraggable = draggable;
+        break;
+      case "object":
+        mergedDraggable = { ...draggable };
+        break;
+      default:
+    }
+    if (mergedDraggable.icon !== false) {
+      mergedDraggable.icon = mergedDraggable.icon || /* @__PURE__ */ React.createElement(import_icons.MenuOutlined, null);
+    }
+    return mergedDraggable;
+  }, [draggable]);
+  return /* @__PURE__ */ React.createElement("div", { className: (0, import_classnames.default)(bem("wrap"), className), style }, search !== false && /* @__PURE__ */ React.createElement(
+    import_antd_mobile.SearchBar,
+    {
+      className: bem("search"),
+      onSearch: (val) => {
+        setSearchValue(val);
+      },
+      onClear: async () => {
+        setSearchValue("");
+      },
+      onCancel: async () => {
+      },
+      placeholder: locale.ProList.keywordsPlaceholder,
+      ...search
+    }
+  ), /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: (0, import_classnames.default)(bem("body", { loading }), bodyClassName),
+      style: bodyStyle
+    },
+    loading && !data ? /* @__PURE__ */ React.createElement(import_antd_mobile.Skeleton.Paragraph, { animated: true, lineCount: 10 }) : dataList.length == 0 ? /* @__PURE__ */ React.createElement(import_antd_mobile.Empty, { description: locale.common.noData }) : /* @__PURE__ */ React.createElement(
+      import_rc_tree.default,
+      {
+        itemHeight: 20,
+        ref: treeRef,
+        className: (0, import_classnames.default)(
+          bem({
+            "icon-hide": !restProps.showIcon,
+            "block-node": restProps.blockNode,
+            unselectable: !restProps.selectable
+          })
+        ),
+        checkable: checkable ? /* @__PURE__ */ React.createElement("span", { className: "suid-tree-checkbox-inner" }) : checkable,
+        switcherIcon: (nodeProps) => (0, import_iconUtil.default)(
+          prefixCls,
+          restProps.switcherIcon,
+          showLine,
+          nodeProps
+        ),
+        draggable: draggableConfig,
+        treeData: dataList,
+        defaultExpandAll,
+        prefixCls,
+        showLine: typeof showLine === "undefined" || typeof showLine === "boolean" ? showLine : true,
+        titleRender: titleRender ?? ((node) => node[titleKey]),
+        ...restProps
+      }
+    )
+  ));
+}
+Tree.TreeNode = import_rc_tree.TreeNode;
+Tree.DirectoryTree = import_DirectoryTree.default;
+Tree.defaultProps = {
+  checkable: false,
+  selectable: true,
+  showIcon: false,
+  motion: {
+    ...import_motion.default,
+    motionAppear: false
+  },
+  blockNode: false
+};
+var tree_default = Tree;

package/dist/cjs/components/tree/utils/dictUtil.d.ts

@@ -0,0 +1,9 @@
+import type { DataNode, Key } from 'rc-tree/lib/interface';
+/** 计算选中范围，只考虑expanded情况以优化性能 */
+export declare function calcRangeKeys({ treeData, expandedKeys, startKey, endKey, }: {
+    treeData: DataNode[];
+    expandedKeys: Key[];
+    startKey?: Key;
+    endKey?: Key;
+}): Key[];
+export declare function convertDirectoryKeysToNodes(treeData: DataNode[], keys: Key[]): DataNode[];

package/dist/cjs/components/tree/utils/dictUtil.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/components/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/cjs/components/tree/utils/dropIndicator.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export declare const offset = 4;
+export default function dropIndicatorRender(props: {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    indent: number;
+    prefixCls: string;
+    direction: 'ltr' | 'rtl';
+}): JSX.Element;

package/dist/cjs/components/tree/utils/dropIndicator.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/components/tree/utils/dropIndicator.tsx
+var dropIndicator_exports = {};
+__export(dropIndicator_exports, {
+  default: () => dropIndicatorRender,
+  offset: () => offset
+});
+module.exports = __toCommonJS(dropIndicator_exports);
+var import_react = __toESM(require("react"));
+var offset = 4;
+function 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` });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  offset
+});

package/dist/cjs/components/tree/utils/iconUtil.d.ts

@@ -0,0 +1,6 @@
+import { FieldDataNode, TreeNodeProps } from 'rc-tree';
+import { IconType } from 'rc-tree/lib/interface';
+import * as React from 'react';
+export default function renderSwitcherIcon<T extends FieldDataNode<object>>(prefixCls: string, switcherIcon: IconType, showLine: boolean | {
+    showLeafIcon: boolean;
+} | undefined, treeNodeProps: TreeNodeProps<T>): React.ReactNode;

package/dist/cjs/components/tree/utils/iconUtil.js

@@ -0,0 +1,75 @@
+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/components/tree/utils/iconUtil.tsx
+var iconUtil_exports = {};
+__export(iconUtil_exports, {
+  default: () => renderSwitcherIcon
+});
+module.exports = __toCommonJS(iconUtil_exports);
+var import_icons = require("@ant-design/icons");
+var import_classnames = __toESM(require("classnames"));
+var React = __toESM(require("react"));
+var import_reactNode = require("./reactNode");
+function renderSwitcherIcon(prefixCls, switcherIcon, showLine, treeNodeProps) {
+  const { isLeaf, expanded, loading } = treeNodeProps;
+  if (loading) {
+    return /* @__PURE__ */ React.createElement(import_icons.LoadingOutlined, { className: `${prefixCls}-switcher-loading-icon` });
+  }
+  let showLeafIcon = false;
+  if (showLine && typeof showLine === "object") {
+    showLeafIcon = showLine.showLeafIcon;
+  }
+  if (isLeaf) {
+    if (showLine) {
+      if (typeof showLine === "object" && !showLeafIcon) {
+        return /* @__PURE__ */ React.createElement("span", { className: `${prefixCls}-switcher-leaf-line` });
+      }
+      return /* @__PURE__ */ React.createElement(import_icons.FileOutlined, { className: `${prefixCls}-switcher-line-icon` });
+    }
+    return null;
+  }
+  const switcherCls = `${prefixCls}-switcher-icon`;
+  const switcher = typeof switcherIcon === "function" ? (
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    switcherIcon(treeNodeProps)
+  ) : switcherIcon;
+  if ((0, import_reactNode.isValidElement)(switcher)) {
+    return (0, import_reactNode.cloneElement)(switcher, {
+      className: (0, import_classnames.default)(switcher.props.className || "", switcherCls)
+    });
+  }
+  if (switcher) {
+    return switcher;
+  }
+  if (showLine) {
+    return expanded ? /* @__PURE__ */ React.createElement(import_icons.MinusSquareOutlined, { className: `${prefixCls}-switcher-line-icon` }) : /* @__PURE__ */ React.createElement(import_icons.PlusSquareOutlined, { className: `${prefixCls}-switcher-line-icon` });
+  }
+  return /* @__PURE__ */ React.createElement(import_icons.CaretDownFilled, { className: switcherCls });
+}

package/dist/cjs/components/tree/utils/motion.d.ts

@@ -0,0 +1,8 @@
+import type { CSSMotionProps } from 'rc-motion';
+declare const collapseMotion: CSSMotionProps;
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof SelectPlacements)[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-down" | "slide-up";
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { getTransitionDirection, getTransitionName };
+export default collapseMotion;

package/dist/cjs/components/tree/utils/motion.js

@@ -0,0 +1,76 @@
+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/components/tree/utils/motion.tsx
+var motion_exports = {};
+__export(motion_exports, {
+  default: () => motion_default,
+  getTransitionDirection: () => getTransitionDirection,
+  getTransitionName: () => getTransitionName
+});
+module.exports = __toCommonJS(motion_exports);
+var import_type = require("./type");
+var getCollapsedHeight = () => ({
+  height: 0,
+  opacity: 0
+});
+var getRealHeight = (node) => {
+  const { scrollHeight } = node;
+  return { height: scrollHeight, opacity: 1 };
+};
+var getCurrentHeight = (node) => ({
+  height: node ? node.offsetHeight : 0
+});
+var skipOpacityTransition = (_, event) => (event == null ? void 0 : event.deadline) === true || event.propertyName === "height";
+var collapseMotion = {
+  motionName: "ant-motion-collapse",
+  onAppearStart: getCollapsedHeight,
+  onEnterStart: getCollapsedHeight,
+  onAppearActive: getRealHeight,
+  onEnterActive: getRealHeight,
+  onLeaveStart: getCurrentHeight,
+  onLeaveActive: getCollapsedHeight,
+  onAppearEnd: skipOpacityTransition,
+  onEnterEnd: skipOpacityTransition,
+  onLeaveEnd: skipOpacityTransition,
+  motionDeadline: 500
+};
+var SelectPlacements = (0, import_type.tuple)(
+  "bottomLeft",
+  "bottomRight",
+  "topLeft",
+  "topRight"
+);
+var getTransitionDirection = (placement) => {
+  if (placement !== void 0 && (placement === "topLeft" || placement === "topRight")) {
+    return `slide-down`;
+  }
+  return `slide-up`;
+};
+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 = {
+  getTransitionDirection,
+  getTransitionName
+});

package/dist/cjs/components/tree/utils/reactNode.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+export declare function isFragment(child: React.ReactElement): boolean;
+type AnyObject = Record<PropertyKey, any>;
+type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | void);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props?: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/dist/cjs/components/tree/utils/reactNode.js

@@ -0,0 +1,61 @@
+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/components/tree/utils/reactNode.ts
+var reactNode_exports = {};
+__export(reactNode_exports, {
+  cloneElement: () => cloneElement2,
+  isFragment: () => isFragment,
+  isValidElement: () => isValidElement,
+  replaceElement: () => replaceElement
+});
+module.exports = __toCommonJS(reactNode_exports);
+var React = __toESM(require("react"));
+var { isValidElement } = React;
+function isFragment(child) {
+  return child && child.type === React.Fragment;
+}
+function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) {
+    return replacement;
+  }
+  return React.cloneElement(
+    element,
+    typeof props === "function" ? props(element.props || {}) : props
+  );
+}
+function cloneElement2(element, props) {
+  return replaceElement(element, element, props);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloneElement,
+  isFragment,
+  isValidElement,
+  replaceElement
+});

package/dist/cjs/components/tree/utils/type.d.ts

@@ -0,0 +1,9 @@
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769 Extract the type of an element of an array/tuple without
+ * performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T extends U, U> = T | (U & object);

package/dist/cjs/components/tree/utils/type.js

@@ -0,0 +1,32 @@
+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/components/tree/utils/type.ts
+var type_exports = {};
+__export(type_exports, {
+  tuple: () => tuple,
+  tupleNum: () => tupleNum
+});
+module.exports = __toCommonJS(type_exports);
+var tuple = (...args) => args;
+var tupleNum = (...args) => args;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tuple,
+  tupleNum
+});

package/dist/cjs/components/tree-picker/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import prompt from './prompt';
+import './tree-picker.less';
+declare const TreePicker: (<T extends import("..").TreeDataNode<object> = import("..").TreeDataNode<object>>(props: Omit<import("..").PopupPickerMixinProps<T | T[]>, "fieldNames"> & Pick<import("..").TreeProps<T>, "search" | "params" | "request" | "rowKey" | "dataSource" | "fieldNames"> & {
+    treeProps?: Omit<import("..").TreeProps<T>, "rowKey"> | undefined;
+    multiple?: boolean | undefined;
+} & {
+    className?: string | undefined;
+    style?: (import("react").CSSProperties & Partial<Record<never, string>>) | undefined;
+    tabIndex?: number | undefined;
+} & import("react").AriaAttributes & import("react").RefAttributes<import("..").PopupPickerActions>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | null) & {
+    prompt: typeof prompt;
+};
+export default TreePicker;
+export type { TreePickerProps } from './tree-picker';