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

package/dist/Transfer/ListBody.js

@@ -0,0 +1,130 @@
+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/ListBody.tsx
+var ListBody_exports = {};
+__export(ListBody_exports, {
+  default: () => ListBody_default
+});
+module.exports = __toCommonJS(ListBody_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Pagination = require("../Pagination");
+var import_Scrollbar = require("../Scrollbar");
+var import_hooks = require("../hooks");
+var import_ListItem = __toESM(require("./ListItem"));
+function parsePagination(pagination) {
+  if (!pagination) {
+    return null;
+  }
+  const defaultPagination = {
+    pageSize: 10
+  };
+  if (typeof pagination === "object") {
+    return {
+      ...defaultPagination,
+      ...pagination
+    };
+  }
+  return defaultPagination;
+}
+var ListBody = (props) => {
+  const { classPrefix = "transfer-list", onScroll, filteredRenderItems, selectedKeys, disabled: globalDisabled, pagination, onItemSelect, onItemRemove, fieldNames } = props;
+  const { b } = (0, import_hooks.useClassNames)(classPrefix);
+  const [current, setCurrent] = (0, import_react.useState)(1);
+  (0, import_react.useEffect)(() => {
+    const mergedPagination2 = parsePagination(pagination);
+    if (mergedPagination2) {
+      const maxPageCount = Math.ceil(filteredRenderItems.length / mergedPagination2.pageSize);
+      if (current > maxPageCount) {
+        setCurrent(maxPageCount);
+      }
+    }
+  }, [current, pagination]);
+  const handleItemSelect = (0, import_react.useCallback)(
+    (item) => {
+      const checked = selectedKeys.indexOf(item[fieldNames.key]) >= 0;
+      onItemSelect(item[fieldNames.key], !checked);
+    },
+    [fieldNames.key, onItemSelect, selectedKeys]
+  );
+  const handleItemRemove = (0, import_react.useCallback)(
+    (item) => {
+      onItemRemove == null ? void 0 : onItemRemove([item[fieldNames.key]]);
+    },
+    [fieldNames.key, onItemRemove]
+  );
+  const onPageChange = (0, import_react.useCallback)((cur) => {
+    setCurrent(cur);
+  }, []);
+  const getItems = (0, import_react.useMemo)(() => {
+    const mergedPagination2 = parsePagination(pagination);
+    let displayItems = filteredRenderItems;
+    if (mergedPagination2) {
+      displayItems = filteredRenderItems.slice((current - 1) * mergedPagination2.pageSize, current * mergedPagination2.pageSize);
+    }
+    return displayItems;
+  }, [current, filteredRenderItems, pagination]);
+  const mergedPagination = parsePagination(pagination);
+  const paginationNode = (0, import_react.useMemo)(() => {
+    if (mergedPagination) {
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_Pagination.Pagination,
+        {
+          simple: true,
+          size: "small",
+          disabled: globalDisabled,
+          className: b`pagination`,
+          total: filteredRenderItems.length,
+          pageSize: mergedPagination.pageSize,
+          current,
+          onChange: onPageChange
+        }
+      );
+    }
+  }, [b, current, filteredRenderItems.length, globalDisabled, mergedPagination, onPageChange]);
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement(import_Scrollbar.Scrollbar, null, /* @__PURE__ */ import_react.default.createElement("ul", { className: (0, import_classnames.default)(b`content`, {}), onScroll }, getItems.map(({ renderedEl, renderedText, item }) => {
+    const checked = selectedKeys.indexOf(item.key) >= 0;
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_ListItem.default,
+      {
+        disabled: globalDisabled || item[fieldNames.disabled],
+        key: item.key,
+        item,
+        renderedText,
+        renderedEl,
+        checked,
+        prefixCls: b(),
+        onClick: handleItemSelect,
+        onRemove: handleItemRemove,
+        fieldNames
+      }
+    );
+  }))), paginationNode);
+};
+var ListBody_default = ListBody;

package/dist/Transfer/ListItem.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { FieldNames, KeyWiseTransferItem } from './typings';
+type ListItemProps<RecordType> = {
+    renderedText?: string | number;
+    renderedEl: React.ReactElement;
+    disabled?: boolean;
+    checked?: boolean;
+    prefixCls: string;
+    onClick: (item: RecordType) => void;
+    onRemove?: (item: RecordType) => void;
+    item: RecordType;
+    fieldNames: FieldNames;
+};
+declare const ListItem: <RecordType extends KeyWiseTransferItem>(props: ListItemProps<RecordType>) => React.JSX.Element;
+export default ListItem;

package/dist/Transfer/ListItem.js

@@ -0,0 +1,54 @@
+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/ListItem.tsx
+var ListItem_exports = {};
+__export(ListItem_exports, {
+  default: () => ListItem_default
+});
+module.exports = __toCommonJS(ListItem_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Checkbox = require("../Checkbox");
+var ListItem = (props) => {
+  const { renderedText, renderedEl, item, checked, disabled, prefixCls, onClick, fieldNames } = props;
+  const className = (0, import_classnames.default)({
+    [`${prefixCls}-content-item`]: true,
+    [`${prefixCls}-content-item-disabled`]: disabled || item[fieldNames.disabled],
+    [`${prefixCls}-content-item-checked`]: checked
+  });
+  let title;
+  if (typeof renderedText === "string" || typeof renderedText === "number") {
+    title = String(renderedText);
+  }
+  const liProps = { className, title };
+  const labelNode = /* @__PURE__ */ import_react.default.createElement("span", { className: `${prefixCls}-content-item-text` }, renderedEl);
+  liProps.onClick = disabled || item[fieldNames.disabled] ? void 0 : () => onClick(item);
+  return /* @__PURE__ */ import_react.default.createElement("li", { ...liProps }, /* @__PURE__ */ import_react.default.createElement(import_Checkbox.Checkbox, { className: `${prefixCls}-checkbox`, checked, disabled: disabled || item[fieldNames.disabled], prevent: true }), labelNode);
+};
+var ListItem_default = ListItem;

package/dist/Transfer/Transfer.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { TransferItem, TransferProps } from './typings';
+type RecordType = TransferItem;
+declare const Transfer: FC<TransferProps<RecordType>>;
+export default Transfer;

package/dist/Transfer/Transfer.js

@@ -0,0 +1,303 @@
+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/Transfer.tsx
+var Transfer_exports = {};
+__export(Transfer_exports, {
+  default: () => Transfer_default
+});
+module.exports = __toCommonJS(Transfer_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Empty = require("../Empty");
+var import_hooks = require("../hooks");
+var import_List = __toESM(require("./List"));
+var import_operation = __toESM(require("./operation"));
+var Transfer = (props) => {
+  const {
+    className,
+    disabled,
+    operations = [],
+    filterable,
+    footer,
+    style,
+    listStyle,
+    operationStyle,
+    filterMethod,
+    render,
+    children,
+    showSelectAll,
+    pagination,
+    titles,
+    data = [],
+    selectedKeys,
+    selectAllLabels = [],
+    onChange,
+    onScroll,
+    classPrefix = "transfer"
+  } = props;
+  const { b, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const fieldNames = (0, import_react.useMemo)(() => {
+    return { key: "key", title: "label", disabled: "disabled", ...props.fieldNames };
+  }, [props.fieldNames]);
+  const [value, setValue] = (0, import_hooks.useControlled)(props.value, props.defaultValue ?? []);
+  const [sourceSelectedKeys, setSourceSelectedKeys] = (0, import_react.useState)((selectedKeys == null ? void 0 : selectedKeys.filter((key) => data.some((item) => item[fieldNames.key] === key) && !value.includes(key))) ?? []);
+  const [targetSelectedKeys, setTargetSelectedKeys] = (0, import_react.useState)((selectedKeys == null ? void 0 : selectedKeys.filter((key) => value.includes(key))) ?? []);
+  (0, import_react.useEffect)(() => {
+    if (selectedKeys) {
+      const mergedTargetKeys = value || [];
+      setSourceSelectedKeys(selectedKeys.filter((key) => data.some((item) => item[fieldNames.key] === key) && !mergedTargetKeys.includes(key)));
+      setTargetSelectedKeys(selectedKeys.filter((key) => mergedTargetKeys.includes(key)));
+    }
+  }, [selectedKeys]);
+  const mergedPagination = (0, import_react.useMemo)(() => !children && pagination, [children, pagination]);
+  const separateDataSource = (0, import_react.useMemo)(() => {
+    const leftDataSource = [];
+    const rightDataSource = new Array(value.length);
+    data.forEach((item) => {
+      if (!item.key) {
+        item = {
+          ...item,
+          key: item[fieldNames.key]
+        };
+      }
+      const indexOfKey = value.indexOf(item.key);
+      if (indexOfKey !== -1) {
+        rightDataSource[indexOfKey] = item;
+      } else {
+        leftDataSource.push(item);
+      }
+    });
+    return {
+      leftDataSource,
+      rightDataSource
+    };
+  }, [data, fieldNames.key, value]);
+  const handleListStyle = (0, import_react.useCallback)((_listStyle, direction) => {
+    if (typeof _listStyle === "function") {
+      return _listStyle({ direction });
+    }
+    return _listStyle;
+  }, []);
+  const setStateKeys = (0, import_react.useCallback)(
+    (direction, keys) => {
+      if (direction === "left") {
+        const result = typeof keys === "function" ? keys(sourceSelectedKeys || []) : keys;
+        setSourceSelectedKeys(result);
+        return;
+      } else {
+        setTargetSelectedKeys(typeof keys === "function" ? keys(targetSelectedKeys || []) : keys);
+      }
+    },
+    [sourceSelectedKeys, targetSelectedKeys]
+  );
+  const handleSelectChange = (0, import_react.useCallback)(
+    (direction, holder) => {
+      const { onSelectChange } = props;
+      if (direction === "left") {
+        onSelectChange == null ? void 0 : onSelectChange(holder, targetSelectedKeys);
+      } else {
+        onSelectChange == null ? void 0 : onSelectChange(sourceSelectedKeys, holder);
+      }
+    },
+    [props, sourceSelectedKeys, targetSelectedKeys]
+  );
+  const moveTo = (0, import_react.useCallback)(
+    (direction) => {
+      const moveKeys = direction === "right" ? sourceSelectedKeys : targetSelectedKeys;
+      const newMoveKeys = moveKeys.filter((key) => !data.some((_data) => !!(key === _data[fieldNames.key] && _data[fieldNames.disabled])));
+      const newTargetKeys = direction === "right" ? newMoveKeys.concat(value) : value.filter((targetKey) => newMoveKeys.indexOf(targetKey) === -1);
+      const oppositeDirection = direction === "right" ? "left" : "right";
+      setStateKeys(oppositeDirection, []);
+      handleSelectChange(oppositeDirection, []);
+      setValue(newTargetKeys);
+      onChange == null ? void 0 : onChange(newTargetKeys, direction, newMoveKeys);
+    },
+    [sourceSelectedKeys, targetSelectedKeys, value, setStateKeys, handleSelectChange, setValue, onChange, data, fieldNames.key, fieldNames.disabled]
+  );
+  const moveToLeft = (0, import_react.useCallback)(() => moveTo("left"), [moveTo]);
+  const moveToRight = (0, import_react.useCallback)(() => moveTo("right"), [moveTo]);
+  const onItemSelectAll = (0, import_react.useCallback)(
+    (direction, _selectedKeys, check, overWrite) => {
+      setStateKeys(direction, (prevKeys) => {
+        let mergedCheckedKeys = [];
+        if (overWrite) {
+          mergedCheckedKeys = _selectedKeys;
+        } else {
+          if (check) {
+            mergedCheckedKeys = Array.from(/* @__PURE__ */ new Set([...prevKeys, ..._selectedKeys]));
+          } else {
+            mergedCheckedKeys = prevKeys.filter((key) => _selectedKeys.indexOf(key) === -1);
+          }
+        }
+        handleSelectChange(direction, mergedCheckedKeys);
+        return mergedCheckedKeys;
+      });
+    },
+    [handleSelectChange, setStateKeys]
+  );
+  const onLeftItemSelectAll = (0, import_react.useCallback)(
+    (_selectedKeys, checkAll, overWrite) => onItemSelectAll("left", _selectedKeys, checkAll, overWrite),
+    [onItemSelectAll]
+  );
+  const onRightItemSelectAll = (0, import_react.useCallback)(
+    (_selectedKeys, checkAll, overWrite) => onItemSelectAll("right", _selectedKeys, checkAll, overWrite),
+    [onItemSelectAll]
+  );
+  const handleFilter = (0, import_react.useCallback)(
+    (direction, e) => {
+      const { onSearch } = props;
+      onSearch == null ? void 0 : onSearch(direction, e.target.value);
+    },
+    [props]
+  );
+  const handleLeftFilter = (0, import_react.useCallback)((e) => handleFilter("left", e), [handleFilter]);
+  const handleRightFilter = (0, import_react.useCallback)((e) => handleFilter("right", e), [handleFilter]);
+  const handleClear = (0, import_react.useCallback)(
+    (direction) => {
+      const { onSearch } = props;
+      onSearch == null ? void 0 : onSearch(direction, "");
+    },
+    [props]
+  );
+  const handleLeftClear = (0, import_react.useCallback)(() => handleClear("left"), [handleClear]);
+  const handleRightClear = (0, import_react.useCallback)(() => handleClear("right"), [handleClear]);
+  const onItemSelect = (0, import_react.useCallback)(
+    (direction, selectedKey, checked) => {
+      const holder = direction === "left" ? [...sourceSelectedKeys] : [...targetSelectedKeys];
+      const index = holder.indexOf(selectedKey);
+      if (index > -1) {
+        holder.splice(index, 1);
+      }
+      if (checked) {
+        holder.push(selectedKey);
+      }
+      handleSelectChange(direction, holder);
+      if (!props.selectedKeys) {
+        setStateKeys(direction, holder);
+      }
+    },
+    [handleSelectChange, props.selectedKeys, setStateKeys, sourceSelectedKeys, targetSelectedKeys]
+  );
+  const onLeftItemSelect = (0, import_react.useCallback)((selectedKey, checked) => onItemSelect("left", selectedKey, checked), [onItemSelect]);
+  const onRightItemSelect = (0, import_react.useCallback)((selectedKey, checked) => onItemSelect("right", selectedKey, checked), [onItemSelect]);
+  const onRightItemRemove = (0, import_react.useCallback)(
+    (_selectedKeys) => {
+      setStateKeys("right", []);
+      setValue(value.filter((key) => !_selectedKeys.includes(key)));
+      onChange == null ? void 0 : onChange(
+        value.filter((key) => !_selectedKeys.includes(key)),
+        "left",
+        [..._selectedKeys]
+      );
+    },
+    [onChange, setStateKeys, setValue, value]
+  );
+  const handleScroll = (0, import_react.useCallback)(
+    (direction, e) => {
+      onScroll == null ? void 0 : onScroll(direction, e);
+    },
+    [onScroll]
+  );
+  const handleLeftScroll = (0, import_react.useCallback)((e) => handleScroll("left", e), [handleScroll]);
+  const handleRightScroll = (0, import_react.useCallback)((e) => handleScroll("right", e), [handleScroll]);
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), { [b`customize-list`]: !!children }, is({ disabled }), className), style }, /* @__PURE__ */ import_react.default.createElement(
+    import_List.default,
+    {
+      titleText: titles[0],
+      data: separateDataSource.leftDataSource,
+      filterOption: filterMethod,
+      style: handleListStyle(listStyle, "left"),
+      checkedKeys: sourceSelectedKeys,
+      handleFilter: handleLeftFilter,
+      handleClear: handleLeftClear,
+      onItemSelect: onLeftItemSelect,
+      onItemSelectAll: onLeftItemSelectAll,
+      render,
+      showSearch: filterable,
+      renderList: children,
+      footer,
+      onScroll: handleLeftScroll,
+      disabled,
+      direction: "left",
+      showSelectAll,
+      selectAllLabel: selectAllLabels[0],
+      pagination: mergedPagination,
+      notFoundContent: /* @__PURE__ */ import_react.default.createElement(import_Empty.Empty, { imageSize: 50 }),
+      fieldNames
+    }
+  ), /* @__PURE__ */ import_react.default.createElement(
+    import_operation.default,
+    {
+      className: b`operation`,
+      rightActive: sourceSelectedKeys.length > 0,
+      rightArrowText: operations[0],
+      moveToRight,
+      leftActive: targetSelectedKeys.length > 0,
+      leftArrowText: operations[1],
+      moveToLeft,
+      style: operationStyle,
+      disabled
+    }
+  ), /* @__PURE__ */ import_react.default.createElement(
+    import_List.default,
+    {
+      titleText: titles[1],
+      data: separateDataSource.rightDataSource,
+      filterOption: filterMethod,
+      style: handleListStyle(listStyle, "right"),
+      checkedKeys: targetSelectedKeys,
+      handleFilter: handleRightFilter,
+      handleClear: handleRightClear,
+      onItemSelect: onRightItemSelect,
+      onItemSelectAll: onRightItemSelectAll,
+      onItemRemove: onRightItemRemove,
+      render,
+      showSearch: filterable,
+      renderList: children,
+      footer,
+      onScroll: handleRightScroll,
+      disabled,
+      direction: "right",
+      showSelectAll,
+      selectAllLabel: selectAllLabels[1],
+      pagination: mergedPagination,
+      notFoundContent: /* @__PURE__ */ import_react.default.createElement(import_Empty.Empty, { imageSize: 50 }),
+      fieldNames
+    }
+  ));
+};
+Transfer.defaultProps = {
+  data: [],
+  titles: ["Source", "Target"],
+  locale: {},
+  filterable: false,
+  listStyle: {}
+};
+Transfer.displayName = "Transfer";
+var Transfer_default = Transfer;

package/dist/Transfer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Transfer } from './Transfer';
+export type { ListStyle, SelectAllLabel, TransferDirection, TransferItem, TransferLocale, TransferProps, TransferRender } from './typings';

package/dist/Transfer/index.js

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

package/dist/Transfer/interface.d.ts

@@ -0,0 +1,6 @@
+export type PaginationType = boolean | {
+    pageSize: number;
+    simple: boolean;
+    showSizeChanger?: boolean;
+    showLessItems?: boolean;
+};

package/dist/Transfer/interface.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/Transfer/interface.ts
+var interface_exports = {};
+module.exports = __toCommonJS(interface_exports);

package/dist/Transfer/operation.d.ts

@@ -0,0 +1,15 @@
+import React, { FC } from 'react';
+export interface TransferOperationProps {
+    className?: string;
+    leftArrowText?: string;
+    rightArrowText?: string;
+    moveToLeft?: React.MouseEventHandler<HTMLElement>;
+    moveToRight?: React.MouseEventHandler<HTMLElement>;
+    leftActive?: boolean;
+    rightActive?: boolean;
+    style?: React.CSSProperties;
+    disabled?: boolean;
+    oneWay?: boolean;
+}
+declare const Operation: FC<TransferOperationProps>;
+export default Operation;

package/dist/Transfer/operation.js

@@ -0,0 +1,49 @@
+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/operation.tsx
+var operation_exports = {};
+__export(operation_exports, {
+  default: () => operation_default
+});
+module.exports = __toCommonJS(operation_exports);
+var import_react = __toESM(require("react"));
+var import_Button = require("../Button");
+var Operation = ({
+  disabled,
+  moveToLeft,
+  moveToRight,
+  leftArrowText = "",
+  rightArrowText = "",
+  leftActive,
+  rightActive,
+  className,
+  style,
+  oneWay
+}) => /* @__PURE__ */ import_react.default.createElement("div", { className, style }, /* @__PURE__ */ import_react.default.createElement(import_Button.Button, { type: "primary", size: "small", disabled: disabled || !rightActive, onClick: moveToRight, icon: rightArrowText ? false : "angle-right", style: { marginBottom: 4 } }, rightArrowText), !oneWay && /* @__PURE__ */ import_react.default.createElement(import_Button.Button, { type: "primary", size: "small", disabled: disabled || !leftActive, onClick: moveToLeft, icon: leftArrowText ? false : "angle-left" }, leftArrowText));
+var operation_default = Operation;

package/dist/Transfer/search.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface TransferSearchProps {
+    prefixCls?: string;
+    placeholder?: string;
+    onChange?: (e: any) => void;
+    handleClear?: () => void;
+    value?: string;
+    disabled?: boolean;
+}
+export default function Search(props: TransferSearchProps): React.JSX.Element;