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

package/dist/Tooltip/Tooltip.js

@@ -0,0 +1,214 @@
+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/Tooltip/Tooltip.tsx
+var Tooltip_exports = {};
+__export(Tooltip_exports, {
+  default: () => Tooltip_default
+});
+module.exports = __toCommonJS(Tooltip_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_noop = __toESM(require("lodash/noop"));
+var import_react = __toESM(require("react"));
+var ReactIs = __toESM(require("react-is"));
+var import_hooks = require("../hooks");
+var import_Popper = require("../Popper");
+var import_TooltipContext = require("./TooltipContext");
+var Tooltip = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    classPrefix = "tooltip",
+    effect: theme,
+    trigger,
+    content,
+    disabled,
+    enterable,
+    showAfter,
+    hideAfter,
+    onMouseEnter,
+    onMouseLeave,
+    onEnter,
+    triggerRef,
+    contentSlot,
+    virtualTriggering,
+    virtualRef,
+    ...rest
+  } = props;
+  const [popperProps] = (0, import_hooks.partitionPopperPropsUtils)(rest);
+  const [transitionProps] = (0, import_hooks.partitionAnimationProps)(rest);
+  const { e, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [visible, setVisible] = (0, import_hooks.useControlled)(props.visible, props.defaultVisible);
+  let referenceElement = (0, import_react.useRef)(null);
+  const timeOut = (0, import_react.useRef)(0);
+  const popperInstRef = (0, import_react.useRef)();
+  const handleMouseEnter = (0, import_react.useCallback)(
+    (event) => {
+      if (enterable) {
+        event == null ? void 0 : event.preventDefault();
+        timeOut.current && clearTimeout(timeOut.current);
+        timeOut.current = window.setTimeout(() => {
+          setVisible(true);
+          onMouseEnter == null ? void 0 : onMouseEnter(event);
+        }, showAfter);
+      } else {
+        setVisible(true);
+        onMouseEnter == null ? void 0 : onMouseEnter(event);
+      }
+    },
+    [enterable, showAfter, setVisible, onMouseEnter]
+  );
+  const handleMouseLeave = (0, import_react.useCallback)(
+    (event) => {
+      if (enterable) {
+        event == null ? void 0 : event.preventDefault();
+        timeOut.current && clearTimeout(timeOut.current);
+        timeOut.current = window.setTimeout(() => {
+          setVisible(false);
+          onMouseLeave == null ? void 0 : onMouseLeave(event);
+        }, hideAfter);
+      } else {
+        setVisible(false);
+        onMouseLeave == null ? void 0 : onMouseLeave(event);
+      }
+    },
+    [enterable, hideAfter, onMouseLeave, setVisible]
+  );
+  const filterChildren = import_react.Children.toArray(triggerRef ?? props.children).filter(
+    (child) => import_react.default.isValidElement(child) || typeof child === "string" || typeof child === "number" || !ReactIs.isPortal(child)
+  );
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    popperRef: popperInstRef,
+    updatePopper: () => {
+      var _a;
+      if ((_a = popperInstRef == null ? void 0 : popperInstRef.current) == null ? void 0 : _a.update) {
+        popperInstRef.current.update();
+      }
+    },
+    onOpen: handleMouseEnter,
+    onClose: handleMouseLeave,
+    hide: handleMouseLeave
+  }));
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, import_react.Children.map(filterChildren, (child) => {
+    var _a;
+    if (typeof child === "string" || typeof child === "number") {
+      child = /* @__PURE__ */ import_react.default.createElement("span", null, child);
+    }
+    const _props = (child == null ? void 0 : child.props) ?? {};
+    const newProps = {
+      ..._props,
+      // @ts-ignore
+      ref: referenceElement = child.ref ?? referenceElement,
+      className: (0, import_classnames.default)(_props == null ? void 0 : _props.className, props.className, e("tooltip", "trigger")),
+      // @ts-ignore
+      style: { ...(_a = child == null ? void 0 : child.props) == null ? void 0 : _a.style, ...props.style }
+    };
+    if (disabled) {
+      Object.assign(newProps, {
+        onMouseEnter: import_noop.default,
+        onMouseLeave: import_noop.default
+      });
+    } else {
+      if (trigger === "hover") {
+        Object.assign(newProps, {
+          onMouseEnter: handleMouseEnter,
+          onMouseLeave: handleMouseLeave
+        });
+      } else if (trigger === "click") {
+        Object.assign(newProps, {
+          onClick: (event) => {
+            var _a2, _b;
+            setVisible(true);
+            onMouseEnter == null ? void 0 : onMouseEnter(event);
+            (_b = (_a2 = child == null ? void 0 : child.props) == null ? void 0 : _a2.onClick) == null ? void 0 : _b.call(_a2, event);
+          }
+        });
+      } else if (trigger === "contextmenu") {
+        Object.assign(newProps, {
+          onContextMenu: (event) => {
+            var _a2, _b;
+            event.preventDefault();
+            setVisible(true);
+            onMouseLeave == null ? void 0 : onMouseLeave(event);
+            (_b = (_a2 = child == null ? void 0 : child.props) == null ? void 0 : _a2.onContextMenu) == null ? void 0 : _b.call(_a2, event);
+          }
+        });
+      }
+    }
+    return (0, import_react.cloneElement)(child, newProps);
+  }), /* @__PURE__ */ import_react.default.createElement(
+    import_Popper.Popper,
+    {
+      visible,
+      referenceElement: () => {
+        var _a;
+        return virtualTriggering ? { current: virtualRef } : ((_a = referenceElement == null ? void 0 : referenceElement.current) == null ? void 0 : _a.ref) ?? referenceElement;
+      },
+      popperInstRef,
+      onEnter: (0, import_react.useCallback)(() => {
+        var _a;
+        if ((_a = popperInstRef == null ? void 0 : popperInstRef.current) == null ? void 0 : _a.update) {
+          popperInstRef.current.update();
+        }
+        onEnter == null ? void 0 : onEnter();
+      }, [onEnter]),
+      onDestroy: () => {
+        setVisible(false);
+        onMouseLeave == null ? void 0 : onMouseLeave();
+      },
+      onMouseEnter: enterable && trigger === "hover" ? handleMouseEnter : import_noop.default,
+      onMouseLeave: enterable && trigger === "hover" ? handleMouseLeave : import_noop.default,
+      className: (0, import_classnames.default)(is(theme), props.popperClass, { [e`popper`]: classPrefix === "tooltip" }),
+      unmountOnExit: props.unmountOnExit,
+      ...popperProps,
+      ...transitionProps
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      import_TooltipContext.TooltipContext.Provider,
+      {
+        value: {
+          onMouseEnter: handleMouseEnter,
+          onMouseLeave: handleMouseLeave,
+          trigger,
+          onClose: () => {
+            setVisible(false);
+          }
+        }
+      },
+      contentSlot ?? /* @__PURE__ */ import_react.default.createElement("span", null, content)
+    )
+  ));
+});
+Tooltip.defaultProps = {
+  effect: "dark",
+  showArrow: true,
+  showAfter: 0,
+  hideAfter: 200,
+  trigger: "hover",
+  unmountOnExit: true
+};
+Tooltip.displayName = "Tooltip";
+var Tooltip_default = Tooltip;

package/dist/Tooltip/TooltipContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface TooltipContextProps {
+    onMouseEnter?: (e?: React.MouseEvent<any>) => void;
+    onMouseLeave?: (e?: React.MouseEvent<any>) => void;
+    trigger: 'hover' | 'click' | 'contextmenu';
+    onClose: () => void;
+}
+export declare const TooltipContext: React.Context<TooltipContextProps>;

package/dist/Tooltip/TooltipContext.js

@@ -0,0 +1,46 @@
+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/Tooltip/TooltipContext.ts
+var TooltipContext_exports = {};
+__export(TooltipContext_exports, {
+  TooltipContext: () => TooltipContext
+});
+module.exports = __toCommonJS(TooltipContext_exports);
+var import_noop = __toESM(require("lodash/noop"));
+var import_react = require("react");
+var TooltipContext = (0, import_react.createContext)({
+  onMouseEnter: import_noop.default,
+  onMouseLeave: import_noop.default,
+  trigger: "hover",
+  onClose: import_noop.default
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TooltipContext
+});

package/dist/Tooltip/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Tooltip } from './Tooltip';
+export { TooltipContext } from './TooltipContext';
+export type { TooltipContextProps } from './TooltipContext';
+export type { TooltipProps } from './typings';

package/dist/Tooltip/index.js

@@ -0,0 +1,42 @@
+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/Tooltip/index.ts
+var Tooltip_exports = {};
+__export(Tooltip_exports, {
+  Tooltip: () => import_Tooltip.default,
+  TooltipContext: () => import_TooltipContext.TooltipContext
+});
+module.exports = __toCommonJS(Tooltip_exports);
+var import_Tooltip = __toESM(require("./Tooltip"));
+var import_TooltipContext = require("./TooltipContext");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tooltip,
+  TooltipContext
+});

package/dist/Tooltip/typings.d.ts

@@ -0,0 +1,31 @@
+import { VirtualElement } from '@popperjs/core';
+import React from 'react';
+import { PopperOptionRef, PopperOptions } from '../Popper';
+import { TransitionProps } from '../Transition';
+import { AnimationEventProps, BaseProps, ComponentChildren, NativeProps } from '../types/common';
+export type TooltipRef = {
+    popperRef: React.MutableRefObject<PopperOptionRef>;
+    updatePopper: () => void;
+    onOpen: () => void;
+    onClose: () => void;
+    hide: () => void;
+};
+export interface TooltipProps extends BaseProps<React.ReactNode>, NativeProps, PopperOptions, AnimationEventProps, Omit<TransitionProps, 'children'> {
+    classPrefix?: string;
+    appendTo?: HTMLElement;
+    effect?: 'light' | 'dark';
+    content?: string | React.ReactNode;
+    trigger?: 'hover' | 'click' | 'contextmenu';
+    visible?: boolean;
+    defaultVisible?: boolean;
+    disabled?: boolean;
+    enterable?: boolean;
+    showAfter?: number;
+    hideAfter?: number;
+    onMouseEnter?: (e?: React.MouseEvent<any>) => void;
+    onMouseLeave?: (e?: React.MouseEvent<any>) => void;
+    triggerRef?: React.ReactElement;
+    virtualTriggering?: boolean;
+    virtualRef?: VirtualElement;
+    contentSlot?: ComponentChildren;
+}

package/dist/Tooltip/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/Tooltip/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Transfer/List.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { KeyWiseTransferItem } from './typings';
+import { TransferListProps } from './typings/list';
+type RecordType = KeyWiseTransferItem;
+declare const TransferList: FC<TransferListProps<RecordType>>;
+export default TransferList;

package/dist/Transfer/List.js

@@ -0,0 +1,260 @@
+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/Transfer/List.tsx
+var List_exports = {};
+__export(List_exports, {
+  default: () => List_default
+});
+module.exports = __toCommonJS(List_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_react = __toESM(require("react"));
+var import_Checkbox = require("../Checkbox");
+var import_Dropdown = require("../Dropdown");
+var import_Icon = require("../Icon");
+var import_hooks = require("../hooks");
+var import_ListBody = __toESM(require("./ListBody"));
+var import_search = __toESM(require("./search"));
+var import_listBody = require("./typings/listBody");
+var TransferList = (props) => {
+  const {
+    classPrefix = "transfer-list",
+    data,
+    titleText,
+    checkedKeys,
+    disabled,
+    footer,
+    showSearch,
+    style,
+    searchPlaceholder,
+    notFoundContent,
+    renderList,
+    onItemSelectAll,
+    showSelectAll = true,
+    pagination,
+    direction,
+    itemsUnit,
+    itemUnit,
+    selectAllLabel,
+    filterOption,
+    render,
+    handleFilter,
+    fieldNames
+  } = props;
+  const { b } = (0, import_hooks.useClassNames)(classPrefix);
+  const [filterValue, setFilterValue] = (0, import_react.useState)("");
+  const defaultListBodyRef = (0, import_react.useRef)();
+  const getCheckStatus = (0, import_react.useCallback)(
+    (filteredItems2) => {
+      if (checkedKeys.length === 0) {
+        return "none";
+      }
+      if (filteredItems2.every((item) => checkedKeys.indexOf(item.key) >= 0 || !!item[fieldNames.disabled])) {
+        return "all";
+      }
+      return "part";
+    },
+    [checkedKeys, fieldNames.disabled]
+  );
+  const onFilter = (0, import_react.useCallback)(
+    (e) => {
+      const {
+        // eslint-disable-next-line @typescript-eslint/no-shadow
+        target: { value: filterValue2 }
+      } = e;
+      setFilterValue(filterValue2);
+      handleFilter == null ? void 0 : handleFilter(e);
+    },
+    [handleFilter]
+  );
+  const handleClear = (0, import_react.useCallback)(() => {
+    setFilterValue("");
+    handleClear();
+  }, []);
+  const matchFilter = (0, import_react.useCallback)(
+    (text, item) => {
+      if (filterOption) {
+        return filterOption(filterValue, item);
+      }
+      return text.indexOf(filterValue) >= 0;
+    },
+    [filterOption, filterValue]
+  );
+  const renderListBody = (0, import_react.useCallback)(
+    (options) => {
+      let bodyContent = renderList == null ? void 0 : renderList(options);
+      const customize = !!bodyContent;
+      if (!customize) {
+        bodyContent = /* @__PURE__ */ import_react.default.createElement(import_ListBody.default, { ...options });
+      }
+      return {
+        customize,
+        bodyContent
+      };
+    },
+    [renderList]
+  );
+  const renderItem = (0, import_react.useCallback)(
+    (item) => {
+      return {
+        renderedText: item[fieldNames.title],
+        renderedEl: (render == null ? void 0 : render(item)) ?? item[fieldNames.title],
+        item
+      };
+    },
+    [fieldNames.title, render]
+  );
+  const { filteredItems, filteredRenderItems } = (0, import_react.useMemo)(() => {
+    const _filteredItems = [];
+    const _filteredRenderItems = [];
+    data.forEach((item) => {
+      const renderedItem = renderItem(item);
+      const { renderedText } = renderedItem;
+      if (filterValue && !matchFilter(renderedText, item)) {
+        return null;
+      }
+      _filteredItems.push(item);
+      _filteredRenderItems.push(renderedItem);
+    });
+    return { filteredItems: _filteredItems, filteredRenderItems: _filteredRenderItems };
+  }, [data, filterValue, matchFilter, renderItem]);
+  const getEnabledItemKeys = (0, import_react.useCallback)(
+    (items) => {
+      return items.filter((item) => !item[fieldNames.disabled]).map((item) => item.key);
+    },
+    [fieldNames.disabled]
+  );
+  const onDropdownClick = (0, import_react.useCallback)(
+    (command) => {
+      var _a, _b;
+      let keys, pageItems, availableKeys, checkedKeySet, newCheckedKeys, newUnCheckedKeys;
+      switch (command) {
+        case "selectAll":
+          keys = getEnabledItemKeys(filteredItems);
+          onItemSelectAll(keys, keys.length !== checkedKeys.length);
+          break;
+        case "pagination":
+          pageItems = ((_a = defaultListBodyRef.current) == null ? void 0 : _a.getItems) || [];
+          onItemSelectAll(getEnabledItemKeys(pageItems.map((entity) => entity.item)), true);
+          break;
+        case "selectInvert":
+          if (pagination) {
+            availableKeys = getEnabledItemKeys((((_b = defaultListBodyRef.current) == null ? void 0 : _b.getItems) || []).map((entity) => entity.item));
+          } else {
+            availableKeys = getEnabledItemKeys(filteredItems);
+          }
+          checkedKeySet = new Set(checkedKeys);
+          newCheckedKeys = [];
+          newUnCheckedKeys = [];
+          availableKeys.forEach((item) => {
+            if (checkedKeySet.has(item)) {
+              newUnCheckedKeys.push(item);
+            } else {
+              newCheckedKeys.push(item);
+            }
+          });
+          onItemSelectAll(newCheckedKeys, true, true);
+          break;
+        default:
+          break;
+      }
+    },
+    [checkedKeys, filteredItems, getEnabledItemKeys, onItemSelectAll, pagination]
+  );
+  const getSelectAllLabel = (0, import_react.useMemo)(() => {
+    const selectedCount = checkedKeys.length;
+    const totalCount = filteredItems.length;
+    if (selectAllLabel) {
+      return typeof selectAllLabel === "function" ? selectAllLabel == null ? void 0 : selectAllLabel({ selectedCount, totalCount }) : selectAllLabel;
+    }
+    const unit = totalCount > 1 ? itemsUnit : itemUnit;
+    return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, (selectedCount > 0 ? `${selectedCount}/` : "") + totalCount, " ", unit);
+  }, [checkedKeys.length, filteredItems.length, itemUnit, itemsUnit, selectAllLabel]);
+  const listBody = (0, import_react.useMemo)(() => {
+    const search = showSearch ? /* @__PURE__ */ import_react.default.createElement("div", { className: b`body-search-wrapper` }, /* @__PURE__ */ import_react.default.createElement(import_search.default, { prefixCls: b`search`, onChange: onFilter, handleClear, placeholder: searchPlaceholder, value: filterValue, disabled })) : null;
+    const { bodyContent, customize } = renderListBody({
+      ...(0, import_omit.default)(props, import_listBody.OmitProps),
+      filteredItems,
+      filteredRenderItems,
+      selectedKeys: checkedKeys
+    });
+    const getNotFoundContent = () => {
+      const contentIndex = props.direction === "left" ? 0 : 1;
+      return Array.isArray(notFoundContent) ? notFoundContent[contentIndex] : notFoundContent;
+    };
+    let bodyNode;
+    if (customize) {
+      bodyNode = /* @__PURE__ */ import_react.default.createElement("div", { className: b`body-customize-wrapper` }, bodyContent);
+    } else {
+      bodyNode = filteredItems.length ? bodyContent : /* @__PURE__ */ import_react.default.createElement("div", { className: b`body-not-found` }, getNotFoundContent());
+    }
+    return /* @__PURE__ */ import_react.default.createElement("div", { className: showSearch ? (0, import_classnames.default)(b`body`, b`body-with-search`) : b`body` }, search, bodyNode);
+  }, [b, checkedKeys, disabled, filterValue, filteredItems, filteredRenderItems, handleClear, onFilter, notFoundContent, props, renderListBody, searchPlaceholder, showSearch]);
+  const footerDom = (0, import_react.useMemo)(() => footer && (footer.length < 2 ? footer(props) : footer(props, { direction })), [direction, footer, props]);
+  const listFooter = (0, import_react.useMemo)(() => footerDom ? /* @__PURE__ */ import_react.default.createElement("div", { className: b`footer` }, footerDom) : null, [b, footerDom]);
+  const checkAllCheckbox = (0, import_react.useMemo)(() => {
+    if (pagination) {
+      return null;
+    }
+    const checkStatus = getCheckStatus(filteredItems);
+    const checkedAll = checkStatus === "all";
+    const result = /* @__PURE__ */ import_react.default.createElement(
+      import_Checkbox.Checkbox,
+      {
+        disabled,
+        checked: checkedAll,
+        indeterminate: checkStatus === "part",
+        className: b`checkbox`,
+        onChange: () => {
+          onItemSelectAll(
+            filteredItems.filter((item) => !item[fieldNames.disabled]).map(({ key }) => key),
+            !checkedAll
+          );
+        }
+      },
+      titleText
+    );
+    return result;
+  }, [b, disabled, fieldNames.disabled, filteredItems, getCheckStatus, onItemSelectAll, pagination, titleText]);
+  const menu = (0, import_react.useMemo)(
+    () => /* @__PURE__ */ import_react.default.createElement(import_Dropdown.DropdownMenu, null, /* @__PURE__ */ import_react.default.createElement(import_Dropdown.DropdownItem, { key: "selectAll", command: "selectAll" }, "全选所有"), pagination && /* @__PURE__ */ import_react.default.createElement(import_Dropdown.DropdownItem, { key: "pagination", command: "pagination" }, "全选当页"), /* @__PURE__ */ import_react.default.createElement(import_Dropdown.DropdownItem, { key: "selectInvert", command: "selectInvert" }, "反选当页")),
+    [pagination]
+  );
+  const dropdown = /* @__PURE__ */ import_react.default.createElement(import_Dropdown.Dropdown, { className: b`header-dropdown`, menu, disabled, onClick: onDropdownClick }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-down" }));
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), { [b`with-pagination`]: !!pagination, [b`with-footer`]: !!footerDom }), style }, /* @__PURE__ */ import_react.default.createElement("div", { className: b`header` }, showSelectAll ? /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, checkAllCheckbox, dropdown) : null, /* @__PURE__ */ import_react.default.createElement("span", { className: b`header-title` }, getSelectAllLabel)), listBody, listFooter);
+};
+TransferList.defaultProps = {
+  data: [],
+  titleText: "",
+  showSearch: false,
+  itemsUnit: "项",
+  itemUnit: "项",
+  searchPlaceholder: "请输入搜索内容"
+};
+var List_default = TransferList;

package/dist/Transfer/ListBody.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { KeyWiseTransferItem } from './typings';
+import { TransferListBodyProps } from './typings/listBody';
+type RecordType = KeyWiseTransferItem;
+declare const ListBody: FC<TransferListBodyProps<RecordType>>;
+export default ListBody;