add all frontend files

node_modules/antd/lib/transfer/ListBody.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { KeyWiseTransferItem } from '.';
+import type { TransferKey } from './interface';
+import type { RenderedItem, TransferListProps } from './list';
+export declare const OmitProps: readonly ["handleFilter", "handleClear", "checkedKeys"];
+export type OmitProp = (typeof OmitProps)[number];
+type PartialTransferListProps<RecordType> = Omit<TransferListProps<RecordType>, OmitProp>;
+export interface TransferListBodyProps<RecordType> extends PartialTransferListProps<RecordType> {
+    filteredItems: RecordType[];
+    filteredRenderItems: RenderedItem<RecordType>[];
+    selectedKeys: TransferKey[];
+}
+export interface ListBodyRef<RecordType extends KeyWiseTransferItem> {
+    items?: RenderedItem<RecordType>[];
+}
+declare const _default: React.ForwardRefExoticComponent<TransferListBodyProps<KeyWiseTransferItem> & React.RefAttributes<ListBodyRef<KeyWiseTransferItem>>>;
+export default _default;

node_modules/antd/lib/transfer/ListBody.js

@@ -0,0 +1,112 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.OmitProps = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _useMergedState = _interopRequireDefault(require("rc-util/lib/hooks/useMergedState"));
+var _pagination = _interopRequireDefault(require("../pagination"));
+var _ListItem = _interopRequireDefault(require("./ListItem"));
+const OmitProps = exports.OmitProps = ['handleFilter', 'handleClear', 'checkedKeys'];
+const parsePagination = pagination => {
+  const defaultPagination = {
+    simple: true,
+    showSizeChanger: false,
+    showLessItems: false
+  };
+  return Object.assign(Object.assign({}, defaultPagination), pagination);
+};
+const TransferListBody = (props, ref) => {
+  const {
+    prefixCls,
+    filteredRenderItems,
+    selectedKeys,
+    disabled: globalDisabled,
+    showRemove,
+    pagination,
+    onScroll,
+    onItemSelect,
+    onItemRemove
+  } = props;
+  const [current, setCurrent] = React.useState(1);
+  const mergedPagination = React.useMemo(() => {
+    if (!pagination) {
+      return null;
+    }
+    const convertPagination = typeof pagination === 'object' ? pagination : {};
+    return parsePagination(convertPagination);
+  }, [pagination]);
+  const [pageSize, setPageSize] = (0, _useMergedState.default)(10, {
+    value: mergedPagination === null || mergedPagination === void 0 ? void 0 : mergedPagination.pageSize
+  });
+  React.useEffect(() => {
+    if (mergedPagination) {
+      const maxPageCount = Math.ceil(filteredRenderItems.length / pageSize);
+      setCurrent(Math.min(current, maxPageCount));
+    }
+  }, [filteredRenderItems, mergedPagination, pageSize]);
+  const onInternalClick = (item, e) => {
+    onItemSelect(item.key, !selectedKeys.includes(item.key), e);
+  };
+  const onRemove = item => {
+    onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove([item.key]);
+  };
+  const onPageChange = cur => {
+    setCurrent(cur);
+  };
+  const onSizeChange = (cur, size) => {
+    setCurrent(cur);
+    setPageSize(size);
+  };
+  const memoizedItems = React.useMemo(() => {
+    const displayItems = mergedPagination ? filteredRenderItems.slice((current - 1) * pageSize, current * pageSize) : filteredRenderItems;
+    return displayItems;
+  }, [current, filteredRenderItems, mergedPagination, pageSize]);
+  React.useImperativeHandle(ref, () => ({
+    items: memoizedItems
+  }));
+  const paginationNode = mergedPagination ? (/*#__PURE__*/React.createElement(_pagination.default, {
+    size: "small",
+    disabled: globalDisabled,
+    simple: mergedPagination.simple,
+    pageSize: pageSize,
+    showLessItems: mergedPagination.showLessItems,
+    showSizeChanger: mergedPagination.showSizeChanger,
+    className: `${prefixCls}-pagination`,
+    total: filteredRenderItems.length,
+    current: current,
+    onChange: onPageChange,
+    onShowSizeChange: onSizeChange
+  })) : null;
+  const cls = (0, _classnames.default)(`${prefixCls}-content`, {
+    [`${prefixCls}-content-show-remove`]: showRemove
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("ul", {
+    className: cls,
+    onScroll: onScroll
+  }, (memoizedItems || []).map(({
+    renderedEl,
+    renderedText,
+    item
+  }) => (/*#__PURE__*/React.createElement(_ListItem.default, {
+    key: item.key,
+    item: item,
+    renderedText: renderedText,
+    renderedEl: renderedEl,
+    prefixCls: prefixCls,
+    showRemove: showRemove,
+    onClick: onInternalClick,
+    onRemove: onRemove,
+    checked: selectedKeys.includes(item.key),
+    disabled: globalDisabled || item.disabled
+  })))), paginationNode);
+};
+if (process.env.NODE_ENV !== 'production') {
+  TransferListBody.displayName = 'TransferListBody';
+}
+var _default = exports.default = /*#__PURE__*/React.forwardRef(TransferListBody);

node_modules/antd/lib/transfer/ListItem.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { KeyWiseTransferItem } from '.';
+type ListItemProps<RecordType> = {
+    renderedText?: string | number;
+    renderedEl: React.ReactNode;
+    disabled?: boolean;
+    checked?: boolean;
+    prefixCls: string;
+    onClick: (item: RecordType, e: React.MouseEvent<HTMLLIElement, MouseEvent>) => void;
+    onRemove?: (item: RecordType) => void;
+    item: RecordType;
+    showRemove?: boolean;
+};
+declare const _default: React.MemoExoticComponent<(<RecordType extends KeyWiseTransferItem>(props: ListItemProps<RecordType>) => React.JSX.Element)>;
+export default _default;

node_modules/antd/lib/transfer/ListItem.js

@@ -0,0 +1,61 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _DeleteOutlined = _interopRequireDefault(require("@ant-design/icons/DeleteOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _checkbox = _interopRequireDefault(require("../checkbox"));
+var _locale = require("../locale");
+var _en_US = _interopRequireDefault(require("../locale/en_US"));
+const ListItem = props => {
+  const {
+    renderedText,
+    renderedEl,
+    item,
+    checked,
+    disabled,
+    prefixCls,
+    onClick,
+    onRemove,
+    showRemove
+  } = props;
+  const className = (0, _classnames.default)(`${prefixCls}-content-item`, {
+    [`${prefixCls}-content-item-disabled`]: disabled || item.disabled,
+    [`${prefixCls}-content-item-checked`]: checked && !item.disabled
+  });
+  let title;
+  if (typeof renderedText === 'string' || typeof renderedText === 'number') {
+    title = String(renderedText);
+  }
+  const [contextLocale] = (0, _locale.useLocale)('Transfer', _en_US.default.Transfer);
+  const liProps = {
+    className,
+    title
+  };
+  const labelNode = /*#__PURE__*/React.createElement("span", {
+    className: `${prefixCls}-content-item-text`
+  }, renderedEl);
+  if (showRemove) {
+    return /*#__PURE__*/React.createElement("li", Object.assign({}, liProps), labelNode, /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      disabled: disabled || item.disabled,
+      className: `${prefixCls}-content-item-remove`,
+      "aria-label": contextLocale === null || contextLocale === void 0 ? void 0 : contextLocale.remove,
+      onClick: () => onRemove === null || onRemove === void 0 ? void 0 : onRemove(item)
+    }, /*#__PURE__*/React.createElement(_DeleteOutlined.default, null)));
+  }
+  // Default click to select
+  liProps.onClick = disabled || item.disabled ? undefined : event => onClick(item, event);
+  return /*#__PURE__*/React.createElement("li", Object.assign({}, liProps), /*#__PURE__*/React.createElement(_checkbox.default, {
+    className: `${prefixCls}-checkbox`,
+    checked: checked,
+    disabled: disabled || item.disabled
+  }), labelNode);
+};
+var _default = exports.default = /*#__PURE__*/React.memo(ListItem);

node_modules/antd/lib/transfer/hooks/useData.d.ts

@@ -0,0 +1,5 @@
+import type { TransferProps } from '..';
+import type { AnyObject } from '../../_util/type';
+import type { TransferKey } from '../interface';
+declare const useData: <RecordType extends AnyObject>(dataSource?: RecordType[], rowKey?: TransferProps<RecordType>["rowKey"], targetKeys?: TransferKey[]) => RecordType[][];
+export default useData;

node_modules/antd/lib/transfer/hooks/useData.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _transKeys = require("../../_util/transKeys");
+const useData = (dataSource, rowKey, targetKeys) => {
+  const mergedDataSource = React.useMemo(() => (dataSource || []).map(record => {
+    if (rowKey) {
+      return Object.assign(Object.assign({}, record), {
+        key: rowKey(record)
+      });
+    }
+    return record;
+  }), [dataSource, rowKey]);
+  const [leftDataSource, rightDataSource] = React.useMemo(() => {
+    var _a;
+    const leftData = [];
+    const rightData = Array.from({
+      length: (_a = targetKeys === null || targetKeys === void 0 ? void 0 : targetKeys.length) !== null && _a !== void 0 ? _a : 0
+    });
+    const targetKeysMap = (0, _transKeys.groupKeysMap)(targetKeys || []);
+    mergedDataSource.forEach(record => {
+      // rightData should be ordered by targetKeys
+      // leftData should be ordered by dataSource
+      if (targetKeysMap.has(record.key)) {
+        const idx = targetKeysMap.get(record.key);
+        rightData[idx] = record;
+      } else {
+        leftData.push(record);
+      }
+    });
+    return [leftData, rightData];
+  }, [mergedDataSource, targetKeys]);
+  return [mergedDataSource, leftDataSource.filter(Boolean), rightDataSource.filter(Boolean)];
+};
+var _default = exports.default = useData;

node_modules/antd/lib/transfer/hooks/useSelection.d.ts

@@ -0,0 +1,10 @@
+import type { TransferKey } from '../interface';
+declare function useSelection<T extends {
+    key: TransferKey;
+}>(leftDataSource: T[], rightDataSource: T[], selectedKeys?: TransferKey[]): [
+    sourceSelectedKeys: TransferKey[],
+    targetSelectedKeys: TransferKey[],
+    setSourceSelectedKeys: (srcKeys: TransferKey[]) => void,
+    setTargetSelectedKeys: (srcKeys: TransferKey[]) => void
+];
+export default useSelection;

node_modules/antd/lib/transfer/hooks/useSelection.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var React = _interopRequireWildcard(require("react"));
+var _rcUtil = require("rc-util");
+const EMPTY_KEYS = [];
+function filterKeys(keys, dataKeys) {
+  const filteredKeys = keys.filter(key => dataKeys.has(key));
+  return keys.length === filteredKeys.length ? keys : filteredKeys;
+}
+function flattenKeys(keys) {
+  return Array.from(keys).join(';');
+}
+function useSelection(leftDataSource, rightDataSource, selectedKeys) {
+  // Prepare `dataSource` keys
+  const [leftKeys, rightKeys] = React.useMemo(() => [new Set(leftDataSource.map(src => src === null || src === void 0 ? void 0 : src.key)), new Set(rightDataSource.map(src => src === null || src === void 0 ? void 0 : src.key))], [leftDataSource, rightDataSource]);
+  // Selected Keys
+  const [mergedSelectedKeys, setMergedSelectedKeys] = (0, _rcUtil.useMergedState)(EMPTY_KEYS, {
+    value: selectedKeys
+  });
+  const sourceSelectedKeys = React.useMemo(() => filterKeys(mergedSelectedKeys, leftKeys), [mergedSelectedKeys, leftKeys]);
+  const targetSelectedKeys = React.useMemo(() => filterKeys(mergedSelectedKeys, rightKeys), [mergedSelectedKeys, rightKeys]);
+  // // Reset when data changed
+  React.useEffect(() => {
+    setMergedSelectedKeys([].concat((0, _toConsumableArray2.default)(filterKeys(mergedSelectedKeys, leftKeys)), (0, _toConsumableArray2.default)(filterKeys(mergedSelectedKeys, rightKeys))));
+  }, [flattenKeys(leftKeys), flattenKeys(rightKeys)]);
+  // Update keys
+  const setSourceSelectedKeys = (0, _rcUtil.useEvent)(nextSrcKeys => {
+    setMergedSelectedKeys([].concat((0, _toConsumableArray2.default)(nextSrcKeys), (0, _toConsumableArray2.default)(targetSelectedKeys)));
+  });
+  const setTargetSelectedKeys = (0, _rcUtil.useEvent)(nextTargetKeys => {
+    setMergedSelectedKeys([].concat((0, _toConsumableArray2.default)(sourceSelectedKeys), (0, _toConsumableArray2.default)(nextTargetKeys)));
+  });
+  return [
+  // Keys
+  sourceSelectedKeys, targetSelectedKeys,
+  // Updater
+  setSourceSelectedKeys, setTargetSelectedKeys];
+}
+var _default = exports.default = useSelection;

node_modules/antd/lib/transfer/index.d.ts

@@ -0,0 +1,95 @@
+import type { CSSProperties } from 'react';
+import React from 'react';
+import type { InputStatus } from '../_util/statusUtils';
+import type { PaginationType, TransferKey } from './interface';
+import type { TransferCustomListBodyProps, TransferListProps } from './list';
+export type { TransferListProps } from './list';
+export type { TransferOperationProps } from './operation';
+export type { TransferSearchProps } from './search';
+export type TransferDirection = 'left' | 'right';
+export interface RenderResultObject {
+    label: React.ReactElement;
+    value: string;
+}
+export type RenderResult = React.ReactElement | RenderResultObject | string | null;
+export interface TransferItem {
+    key?: TransferKey;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+    [name: string]: any;
+}
+export type KeyWise<T> = T & {
+    key: TransferKey;
+};
+export type KeyWiseTransferItem = KeyWise<TransferItem>;
+type TransferRender<RecordType> = (item: RecordType) => RenderResult;
+export interface ListStyle {
+    direction: TransferDirection;
+}
+export type SelectAllLabel = React.ReactNode | ((info: {
+    selectedCount: number;
+    totalCount: number;
+}) => React.ReactNode);
+export interface TransferLocale {
+    titles?: React.ReactNode[];
+    notFoundContent?: React.ReactNode | React.ReactNode[];
+    searchPlaceholder: string;
+    itemUnit: string;
+    itemsUnit: string;
+    remove?: string;
+    selectAll?: string;
+    deselectAll?: string;
+    selectCurrent?: string;
+    selectInvert?: string;
+    removeAll?: string;
+    removeCurrent?: string;
+}
+export interface TransferSearchOption {
+    placeholder?: string;
+    defaultValue?: string;
+}
+export interface TransferProps<RecordType = any> {
+    prefixCls?: string;
+    className?: string;
+    rootClassName?: string;
+    disabled?: boolean;
+    dataSource?: RecordType[];
+    targetKeys?: TransferKey[];
+    selectedKeys?: TransferKey[];
+    render?: TransferRender<RecordType>;
+    onChange?: (targetKeys: TransferKey[], direction: TransferDirection, moveKeys: TransferKey[]) => void;
+    onSelectChange?: (sourceSelectedKeys: TransferKey[], targetSelectedKeys: TransferKey[]) => void;
+    style?: React.CSSProperties;
+    listStyle?: ((style: ListStyle) => CSSProperties) | CSSProperties;
+    operationStyle?: CSSProperties;
+    titles?: React.ReactNode[];
+    operations?: string[];
+    showSearch?: boolean | TransferSearchOption;
+    filterOption?: (inputValue: string, item: RecordType, direction: TransferDirection) => boolean;
+    locale?: Partial<TransferLocale>;
+    footer?: (props: TransferListProps<RecordType>, info?: {
+        direction: TransferDirection;
+    }) => React.ReactNode;
+    rowKey?: (record: RecordType) => TransferKey;
+    onSearch?: (direction: TransferDirection, value: string) => void;
+    onScroll?: (direction: TransferDirection, e: React.SyntheticEvent<HTMLUListElement>) => void;
+    children?: (props: TransferCustomListBodyProps<RecordType>) => React.ReactNode;
+    showSelectAll?: boolean;
+    selectAllLabels?: SelectAllLabel[];
+    oneWay?: boolean;
+    pagination?: PaginationType;
+    status?: InputStatus;
+    selectionsIcon?: React.ReactNode;
+}
+declare const Transfer: {
+    <RecordType extends TransferItem = TransferItem>(props: TransferProps<RecordType>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    displayName: string;
+    List: {
+        <RecordType extends KeyWiseTransferItem>(props: TransferListProps<RecordType>): React.JSX.Element;
+        displayName: string;
+    };
+    Search: React.FC<import("./search").TransferSearchProps>;
+    Operation: React.FC<import("./operation").TransferOperationProps>;
+};
+export default Transfer;

node_modules/antd/lib/transfer/index.js

@@ -0,0 +1,310 @@
+"use strict";
+"use client";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _hooks = require("../_util/hooks");
+var _statusUtils = require("../_util/statusUtils");
+var _transKeys = require("../_util/transKeys");
+var _warning = require("../_util/warning");
+var _configProvider = require("../config-provider");
+var _defaultRenderEmpty = _interopRequireDefault(require("../config-provider/defaultRenderEmpty"));
+var _DisabledContext = _interopRequireDefault(require("../config-provider/DisabledContext"));
+var _context = require("../form/context");
+var _locale = require("../locale");
+var _en_US = _interopRequireDefault(require("../locale/en_US"));
+var _useData = _interopRequireDefault(require("./hooks/useData"));
+var _useSelection = _interopRequireDefault(require("./hooks/useSelection"));
+var _list = _interopRequireDefault(require("./list"));
+var _operation = _interopRequireDefault(require("./operation"));
+var _search = _interopRequireDefault(require("./search"));
+var _style = _interopRequireDefault(require("./style"));
+const Transfer = props => {
+  const {
+    dataSource,
+    targetKeys = [],
+    selectedKeys,
+    selectAllLabels = [],
+    operations = [],
+    style = {},
+    listStyle = {},
+    locale = {},
+    titles,
+    disabled,
+    showSearch = false,
+    operationStyle,
+    showSelectAll,
+    oneWay,
+    pagination,
+    status: customStatus,
+    prefixCls: customizePrefixCls,
+    className,
+    rootClassName,
+    selectionsIcon,
+    filterOption,
+    render,
+    footer,
+    children,
+    rowKey,
+    onScroll,
+    onChange,
+    onSearch,
+    onSelectChange
+  } = props;
+  const {
+    getPrefixCls,
+    renderEmpty,
+    direction: dir,
+    transfer
+  } = (0, _react.useContext)(_configProvider.ConfigContext);
+  const contextDisabled = (0, _react.useContext)(_DisabledContext.default);
+  const mergedDisabled = disabled !== null && disabled !== void 0 ? disabled : contextDisabled;
+  const prefixCls = getPrefixCls('transfer', customizePrefixCls);
+  const [wrapCSSVar, hashId, cssVarCls] = (0, _style.default)(prefixCls);
+  // Fill record with `key`
+  const [mergedDataSource, leftDataSource, rightDataSource] = (0, _useData.default)(dataSource, rowKey, targetKeys);
+  // Get direction selected keys
+  const [
+  // Keys
+  sourceSelectedKeys, targetSelectedKeys,
+  // Setters
+  setSourceSelectedKeys, setTargetSelectedKeys] = (0, _useSelection.default)(leftDataSource, rightDataSource, selectedKeys);
+  const [leftMultipleSelect, updateLeftPrevSelectedIndex] = (0, _hooks.useMultipleSelect)(item => item.key);
+  const [rightMultipleSelect, updateRightPrevSelectedIndex] = (0, _hooks.useMultipleSelect)(item => item.key);
+  if (process.env.NODE_ENV !== 'production') {
+    const warning = (0, _warning.devUseWarning)('Transfer');
+    process.env.NODE_ENV !== "production" ? warning(!pagination || !children, 'usage', '`pagination` not support customize render list.') : void 0;
+  }
+  const setStateKeys = (0, _react.useCallback)((direction, keys) => {
+    if (direction === 'left') {
+      const nextKeys = typeof keys === 'function' ? keys(sourceSelectedKeys || []) : keys;
+      setSourceSelectedKeys(nextKeys);
+    } else {
+      const nextKeys = typeof keys === 'function' ? keys(targetSelectedKeys || []) : keys;
+      setTargetSelectedKeys(nextKeys);
+    }
+  }, [sourceSelectedKeys, targetSelectedKeys]);
+  const setPrevSelectedIndex = (direction, value) => {
+    const isLeftDirection = direction === 'left';
+    const updatePrevSelectedIndex = isLeftDirection ? updateLeftPrevSelectedIndex : updateRightPrevSelectedIndex;
+    updatePrevSelectedIndex(value);
+  };
+  const handleSelectChange = (0, _react.useCallback)((direction, holder) => {
+    if (direction === 'left') {
+      onSelectChange === null || onSelectChange === void 0 ? void 0 : onSelectChange(holder, targetSelectedKeys);
+    } else {
+      onSelectChange === null || onSelectChange === void 0 ? void 0 : onSelectChange(sourceSelectedKeys, holder);
+    }
+  }, [sourceSelectedKeys, targetSelectedKeys]);
+  const getTitles = transferLocale => {
+    var _a;
+    return (_a = titles !== null && titles !== void 0 ? titles : transferLocale.titles) !== null && _a !== void 0 ? _a : [];
+  };
+  const handleLeftScroll = e => {
+    onScroll === null || onScroll === void 0 ? void 0 : onScroll('left', e);
+  };
+  const handleRightScroll = e => {
+    onScroll === null || onScroll === void 0 ? void 0 : onScroll('right', e);
+  };
+  const moveTo = direction => {
+    const moveKeys = direction === 'right' ? sourceSelectedKeys : targetSelectedKeys;
+    const dataSourceDisabledKeysMap = (0, _transKeys.groupDisabledKeysMap)(mergedDataSource);
+    // filter the disabled options
+    const newMoveKeys = moveKeys.filter(key => !dataSourceDisabledKeysMap.has(key));
+    const newMoveKeysMap = (0, _transKeys.groupKeysMap)(newMoveKeys);
+    // move items to target box
+    const newTargetKeys = direction === 'right' ? newMoveKeys.concat(targetKeys) : targetKeys.filter(targetKey => !newMoveKeysMap.has(targetKey));
+    // empty checked keys
+    const oppositeDirection = direction === 'right' ? 'left' : 'right';
+    setStateKeys(oppositeDirection, []);
+    handleSelectChange(oppositeDirection, []);
+    onChange === null || onChange === void 0 ? void 0 : onChange(newTargetKeys, direction, newMoveKeys);
+  };
+  const moveToLeft = () => {
+    moveTo('left');
+    setPrevSelectedIndex('left', null);
+  };
+  const moveToRight = () => {
+    moveTo('right');
+    setPrevSelectedIndex('right', null);
+  };
+  const onItemSelectAll = (direction, keys, checkAll) => {
+    setStateKeys(direction, prevKeys => {
+      let mergedCheckedKeys = [];
+      if (checkAll === 'replace') {
+        mergedCheckedKeys = keys;
+      } else if (checkAll) {
+        // Merge current keys with origin key
+        mergedCheckedKeys = Array.from(new Set([].concat((0, _toConsumableArray2.default)(prevKeys), (0, _toConsumableArray2.default)(keys))));
+      } else {
+        const selectedKeysMap = (0, _transKeys.groupKeysMap)(keys);
+        // Remove current keys from origin keys
+        mergedCheckedKeys = prevKeys.filter(key => !selectedKeysMap.has(key));
+      }
+      handleSelectChange(direction, mergedCheckedKeys);
+      return mergedCheckedKeys;
+    });
+    setPrevSelectedIndex(direction, null);
+  };
+  const onLeftItemSelectAll = (keys, checkAll) => {
+    onItemSelectAll('left', keys, checkAll);
+  };
+  const onRightItemSelectAll = (keys, checkAll) => {
+    onItemSelectAll('right', keys, checkAll);
+  };
+  const leftFilter = e => onSearch === null || onSearch === void 0 ? void 0 : onSearch('left', e.target.value);
+  const rightFilter = e => onSearch === null || onSearch === void 0 ? void 0 : onSearch('right', e.target.value);
+  const handleLeftClear = () => onSearch === null || onSearch === void 0 ? void 0 : onSearch('left', '');
+  const handleRightClear = () => onSearch === null || onSearch === void 0 ? void 0 : onSearch('right', '');
+  const handleSingleSelect = (direction, holder, selectedKey, checked, currentSelectedIndex) => {
+    const isSelected = holder.has(selectedKey);
+    if (isSelected) {
+      holder.delete(selectedKey);
+      setPrevSelectedIndex(direction, null);
+    }
+    if (checked) {
+      holder.add(selectedKey);
+      setPrevSelectedIndex(direction, currentSelectedIndex);
+    }
+  };
+  const handleMultipleSelect = (direction, data, holder, currentSelectedIndex) => {
+    const isLeftDirection = direction === 'left';
+    const multipleSelect = isLeftDirection ? leftMultipleSelect : rightMultipleSelect;
+    multipleSelect(currentSelectedIndex, data, holder);
+  };
+  const onItemSelect = (direction, selectedKey, checked, multiple) => {
+    const isLeftDirection = direction === 'left';
+    const holder = (0, _toConsumableArray2.default)(isLeftDirection ? sourceSelectedKeys : targetSelectedKeys);
+    const holderSet = new Set(holder);
+    const data = (0, _toConsumableArray2.default)(isLeftDirection ? leftDataSource : rightDataSource).filter(item => !(item === null || item === void 0 ? void 0 : item.disabled));
+    const currentSelectedIndex = data.findIndex(item => item.key === selectedKey);
+    // multiple select by hold down the shift key
+    if (multiple && holder.length > 0) {
+      handleMultipleSelect(direction, data, holderSet, currentSelectedIndex);
+    } else {
+      handleSingleSelect(direction, holderSet, selectedKey, checked, currentSelectedIndex);
+    }
+    const holderArr = Array.from(holderSet);
+    handleSelectChange(direction, holderArr);
+    if (!props.selectedKeys) {
+      setStateKeys(direction, holderArr);
+    }
+  };
+  const onLeftItemSelect = (selectedKey, checked, e) => {
+    onItemSelect('left', selectedKey, checked, e === null || e === void 0 ? void 0 : e.shiftKey);
+  };
+  const onRightItemSelect = (selectedKey, checked, e) => {
+    onItemSelect('right', selectedKey, checked, e === null || e === void 0 ? void 0 : e.shiftKey);
+  };
+  const onRightItemRemove = keys => {
+    setStateKeys('right', []);
+    onChange === null || onChange === void 0 ? void 0 : onChange(targetKeys.filter(key => !keys.includes(key)), 'left', (0, _toConsumableArray2.default)(keys));
+  };
+  const handleListStyle = direction => {
+    if (typeof listStyle === 'function') {
+      return listStyle({
+        direction
+      });
+    }
+    return listStyle || {};
+  };
+  const formItemContext = (0, _react.useContext)(_context.FormItemInputContext);
+  const {
+    hasFeedback,
+    status
+  } = formItemContext;
+  const getLocale = transferLocale => Object.assign(Object.assign(Object.assign({}, transferLocale), {
+    notFoundContent: (renderEmpty === null || renderEmpty === void 0 ? void 0 : renderEmpty('Transfer')) || /*#__PURE__*/_react.default.createElement(_defaultRenderEmpty.default, {
+      componentName: "Transfer"
+    })
+  }), locale);
+  const mergedStatus = (0, _statusUtils.getMergedStatus)(status, customStatus);
+  const mergedPagination = !children && pagination;
+  const leftActive = rightDataSource.filter(d => targetSelectedKeys.includes(d.key) && !d.disabled).length > 0;
+  const rightActive = leftDataSource.filter(d => sourceSelectedKeys.includes(d.key) && !d.disabled).length > 0;
+  const cls = (0, _classnames.default)(prefixCls, {
+    [`${prefixCls}-disabled`]: mergedDisabled,
+    [`${prefixCls}-customize-list`]: !!children,
+    [`${prefixCls}-rtl`]: dir === 'rtl'
+  }, (0, _statusUtils.getStatusClassNames)(prefixCls, mergedStatus, hasFeedback), transfer === null || transfer === void 0 ? void 0 : transfer.className, className, rootClassName, hashId, cssVarCls);
+  const [contextLocale] = (0, _locale.useLocale)('Transfer', _en_US.default.Transfer);
+  const listLocale = getLocale(contextLocale);
+  const [leftTitle, rightTitle] = getTitles(listLocale);
+  const mergedSelectionsIcon = selectionsIcon !== null && selectionsIcon !== void 0 ? selectionsIcon : transfer === null || transfer === void 0 ? void 0 : transfer.selectionsIcon;
+  return wrapCSSVar(/*#__PURE__*/_react.default.createElement("div", {
+    className: cls,
+    style: Object.assign(Object.assign({}, transfer === null || transfer === void 0 ? void 0 : transfer.style), style)
+  }, /*#__PURE__*/_react.default.createElement(_list.default, Object.assign({
+    prefixCls: `${prefixCls}-list`,
+    titleText: leftTitle,
+    dataSource: leftDataSource,
+    filterOption: filterOption,
+    style: handleListStyle('left'),
+    checkedKeys: sourceSelectedKeys,
+    handleFilter: leftFilter,
+    handleClear: handleLeftClear,
+    onItemSelect: onLeftItemSelect,
+    onItemSelectAll: onLeftItemSelectAll,
+    render: render,
+    showSearch: showSearch,
+    renderList: children,
+    footer: footer,
+    onScroll: handleLeftScroll,
+    disabled: mergedDisabled,
+    direction: dir === 'rtl' ? 'right' : 'left',
+    showSelectAll: showSelectAll,
+    selectAllLabel: selectAllLabels[0],
+    pagination: mergedPagination,
+    selectionsIcon: mergedSelectionsIcon
+  }, listLocale)), /*#__PURE__*/_react.default.createElement(_operation.default, {
+    className: `${prefixCls}-operation`,
+    rightActive: rightActive,
+    rightArrowText: operations[0],
+    moveToRight: moveToRight,
+    leftActive: leftActive,
+    leftArrowText: operations[1],
+    moveToLeft: moveToLeft,
+    style: operationStyle,
+    disabled: mergedDisabled,
+    direction: dir,
+    oneWay: oneWay
+  }), /*#__PURE__*/_react.default.createElement(_list.default, Object.assign({
+    prefixCls: `${prefixCls}-list`,
+    titleText: rightTitle,
+    dataSource: rightDataSource,
+    filterOption: filterOption,
+    style: handleListStyle('right'),
+    checkedKeys: targetSelectedKeys,
+    handleFilter: rightFilter,
+    handleClear: handleRightClear,
+    onItemSelect: onRightItemSelect,
+    onItemSelectAll: onRightItemSelectAll,
+    onItemRemove: onRightItemRemove,
+    render: render,
+    showSearch: showSearch,
+    renderList: children,
+    footer: footer,
+    onScroll: handleRightScroll,
+    disabled: mergedDisabled,
+    direction: dir === 'rtl' ? 'left' : 'right',
+    showSelectAll: showSelectAll,
+    selectAllLabel: selectAllLabels[1],
+    showRemove: oneWay,
+    pagination: mergedPagination,
+    selectionsIcon: mergedSelectionsIcon
+  }, listLocale))));
+};
+if (process.env.NODE_ENV !== 'production') {
+  Transfer.displayName = 'Transfer';
+}
+Transfer.List = _list.default;
+Transfer.Search = _search.default;
+Transfer.Operation = _operation.default;
+var _default = exports.default = Transfer;

node_modules/antd/lib/transfer/interface.d.ts

@@ -0,0 +1,7 @@
+export type TransferKey = React.Key;
+export type PaginationType = boolean | {
+    pageSize?: number;
+    simple?: boolean;
+    showSizeChanger?: boolean;
+    showLessItems?: boolean;
+};

node_modules/antd/lib/transfer/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

node_modules/antd/lib/transfer/list.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { KeyWiseTransferItem, RenderResult, SelectAllLabel, TransferDirection, TransferLocale, TransferSearchOption } from './index';
+import type { PaginationType, TransferKey } from './interface';
+import type { TransferListBodyProps } from './ListBody';
+export interface RenderedItem<RecordType> {
+    renderedText: string;
+    renderedEl: React.ReactNode;
+    item: RecordType;
+}
+type RenderListFunction<T> = (props: TransferListBodyProps<T>) => React.ReactNode;
+export interface TransferListProps<RecordType> extends TransferLocale {
+    prefixCls: string;
+    titleText: React.ReactNode;
+    dataSource: RecordType[];
+    filterOption?: (filterText: string, item: RecordType, direction: TransferDirection) => boolean;
+    style?: React.CSSProperties;
+    checkedKeys: TransferKey[];
+    handleFilter: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onItemSelect: (key: TransferKey, check: boolean, e?: React.MouseEvent<Element, MouseEvent>) => void;
+    onItemSelectAll: (dataSource: TransferKey[], checkAll: boolean | 'replace') => void;
+    onItemRemove?: (keys: TransferKey[]) => void;
+    handleClear: () => void;
+    /** Render item */
+    render?: (item: RecordType) => RenderResult;
+    showSearch?: boolean | TransferSearchOption;
+    searchPlaceholder: string;
+    itemUnit: string;
+    itemsUnit: string;
+    renderList?: RenderListFunction<RecordType>;
+    footer?: (props: TransferListProps<RecordType>, info?: {
+        direction: TransferDirection;
+    }) => React.ReactNode;
+    onScroll: (e: React.UIEvent<HTMLUListElement, UIEvent>) => void;
+    disabled?: boolean;
+    direction: TransferDirection;
+    showSelectAll?: boolean;
+    selectAllLabel?: SelectAllLabel;
+    showRemove?: boolean;
+    pagination?: PaginationType;
+    selectionsIcon?: React.ReactNode;
+}
+export interface TransferCustomListBodyProps<T> extends TransferListBodyProps<T> {
+}
+declare const TransferList: {
+    <RecordType extends KeyWiseTransferItem>(props: TransferListProps<RecordType>): React.JSX.Element;
+    displayName: string;
+};
+export default TransferList;

node_modules/antd/lib/transfer/list.js

@@ -0,0 +1,287 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _DownOutlined = _interopRequireDefault(require("@ant-design/icons/DownOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _omit = _interopRequireDefault(require("rc-util/lib/omit"));
+var _transKeys = require("../_util/transKeys");
+var _checkbox = _interopRequireDefault(require("../checkbox"));
+var _dropdown = _interopRequireDefault(require("../dropdown"));
+var _ListBody = _interopRequireWildcard(require("./ListBody"));
+var _search = _interopRequireDefault(require("./search"));
+const defaultRender = () => null;
+function isRenderResultPlainObject(result) {
+  return !!(result && ! /*#__PURE__*/_react.default.isValidElement(result) && Object.prototype.toString.call(result) === '[object Object]');
+}
+function getEnabledItemKeys(items) {
+  return items.filter(data => !data.disabled).map(data => data.key);
+}
+const isValidIcon = icon => icon !== undefined;
+const getShowSearchOption = showSearch => {
+  if (showSearch && typeof showSearch === 'object') {
+    return Object.assign(Object.assign({}, showSearch), {
+      defaultValue: showSearch.defaultValue || ''
+    });
+  }
+  return {
+    defaultValue: '',
+    placeholder: ''
+  };
+};
+const TransferList = props => {
+  const {
+    prefixCls,
+    dataSource = [],
+    titleText = '',
+    checkedKeys,
+    disabled,
+    showSearch = false,
+    style,
+    searchPlaceholder,
+    notFoundContent,
+    selectAll,
+    deselectAll,
+    selectCurrent,
+    selectInvert,
+    removeAll,
+    removeCurrent,
+    showSelectAll = true,
+    showRemove,
+    pagination,
+    direction,
+    itemsUnit,
+    itemUnit,
+    selectAllLabel,
+    selectionsIcon,
+    footer,
+    renderList,
+    onItemSelectAll,
+    onItemRemove,
+    handleFilter,
+    handleClear,
+    filterOption,
+    render = defaultRender
+  } = props;
+  const searchOptions = getShowSearchOption(showSearch);
+  const [filterValue, setFilterValue] = (0, _react.useState)(searchOptions.defaultValue);
+  const listBodyRef = (0, _react.useRef)({});
+  const internalHandleFilter = e => {
+    setFilterValue(e.target.value);
+    handleFilter(e);
+  };
+  const internalHandleClear = () => {
+    setFilterValue('');
+    handleClear();
+  };
+  const matchFilter = (text, item) => {
+    if (typeof filterOption === 'function') {
+      return filterOption(filterValue, item, direction);
+    }
+    return text.includes(filterValue);
+  };
+  const customRenderListBody = listProps => {
+    let bodyContent = renderList ? renderList(Object.assign(Object.assign({}, listProps), {
+      onItemSelect: (key, check) => listProps.onItemSelect(key, check)
+    })) : null;
+    const customize = !!bodyContent;
+    if (!customize) {
+      // @ts-ignore
+      bodyContent = /*#__PURE__*/_react.default.createElement(_ListBody.default, Object.assign({
+        ref: listBodyRef
+      }, listProps));
+    }
+    return {
+      customize,
+      bodyContent
+    };
+  };
+  const renderItem = item => {
+    const renderResult = render(item);
+    const isRenderResultPlain = isRenderResultPlainObject(renderResult);
+    return {
+      item,
+      renderedEl: isRenderResultPlain ? renderResult.label : renderResult,
+      renderedText: isRenderResultPlain ? renderResult.value : renderResult
+    };
+  };
+  const notFoundContentEle = (0, _react.useMemo)(() => Array.isArray(notFoundContent) ? notFoundContent[direction === 'left' ? 0 : 1] : notFoundContent, [notFoundContent, direction]);
+  const [filteredItems, filteredRenderItems] = (0, _react.useMemo)(() => {
+    const filterItems = [];
+    const filterRenderItems = [];
+    dataSource.forEach(item => {
+      const renderedItem = renderItem(item);
+      if (filterValue && !matchFilter(renderedItem.renderedText, item)) {
+        return;
+      }
+      filterItems.push(item);
+      filterRenderItems.push(renderedItem);
+    });
+    return [filterItems, filterRenderItems];
+  }, [dataSource, filterValue]);
+  const checkedActiveItems = (0, _react.useMemo)(() => {
+    return filteredItems.filter(item => checkedKeys.includes(item.key) && !item.disabled);
+  }, [checkedKeys, filteredItems]);
+  const checkStatus = (0, _react.useMemo)(() => {
+    if (checkedActiveItems.length === 0) {
+      return 'none';
+    }
+    const checkedKeysMap = (0, _transKeys.groupKeysMap)(checkedKeys);
+    if (filteredItems.every(item => checkedKeysMap.has(item.key) || !!item.disabled)) {
+      return 'all';
+    }
+    return 'part';
+  }, [checkedActiveItems.length, checkedKeys, filteredItems]);
+  const renderListBody = () => {
+    const search = showSearch ? (/*#__PURE__*/_react.default.createElement("div", {
+      className: `${prefixCls}-body-search-wrapper`
+    }, /*#__PURE__*/_react.default.createElement(_search.default, {
+      prefixCls: `${prefixCls}-search`,
+      onChange: internalHandleFilter,
+      handleClear: internalHandleClear,
+      placeholder: searchOptions.placeholder || searchPlaceholder,
+      value: filterValue,
+      disabled: disabled
+    }))) : null;
+    const {
+      customize,
+      bodyContent
+    } = customRenderListBody(Object.assign(Object.assign({}, (0, _omit.default)(props, _ListBody.OmitProps)), {
+      filteredItems,
+      filteredRenderItems,
+      selectedKeys: checkedKeys
+    }));
+    let bodyNode;
+    // We should wrap customize list body in a classNamed div to use flex layout.
+    if (customize) {
+      bodyNode = /*#__PURE__*/_react.default.createElement("div", {
+        className: `${prefixCls}-body-customize-wrapper`
+      }, bodyContent);
+    } else {
+      bodyNode = filteredItems.length ? bodyContent : (/*#__PURE__*/_react.default.createElement("div", {
+        className: `${prefixCls}-body-not-found`
+      }, notFoundContentEle));
+    }
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)(`${prefixCls}-body`, {
+        [`${prefixCls}-body-with-search`]: showSearch
+      })
+    }, search, bodyNode);
+  };
+  const checkBox = /*#__PURE__*/_react.default.createElement(_checkbox.default, {
+    disabled: dataSource.filter(d => !d.disabled).length === 0 || disabled,
+    checked: checkStatus === 'all',
+    indeterminate: checkStatus === 'part',
+    className: `${prefixCls}-checkbox`,
+    onChange: () => {
+      // Only select enabled items
+      onItemSelectAll === null || onItemSelectAll === void 0 ? void 0 : onItemSelectAll(filteredItems.filter(item => !item.disabled).map(({
+        key
+      }) => key), checkStatus !== 'all');
+    }
+  });
+  const getSelectAllLabel = (selectedCount, totalCount) => {
+    if (selectAllLabel) {
+      return typeof selectAllLabel === 'function' ? selectAllLabel({
+        selectedCount,
+        totalCount
+      }) : selectAllLabel;
+    }
+    const unit = totalCount > 1 ? itemsUnit : itemUnit;
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, (selectedCount > 0 ? `${selectedCount}/` : '') + totalCount, " ", unit);
+  };
+  // Custom Layout
+  const footerDom = footer && (footer.length < 2 ? footer(props) : footer(props, {
+    direction
+  }));
+  const listCls = (0, _classnames.default)(prefixCls, {
+    [`${prefixCls}-with-pagination`]: !!pagination,
+    [`${prefixCls}-with-footer`]: !!footerDom
+  });
+  // ====================== Get filtered, checked item list ======================
+  const listFooter = footerDom ? /*#__PURE__*/_react.default.createElement("div", {
+    className: `${prefixCls}-footer`
+  }, footerDom) : null;
+  const checkAllCheckbox = !showRemove && !pagination && checkBox;
+  let items;
+  if (showRemove) {
+    items = [/* Remove Current Page */
+    pagination ? {
+      key: 'removeCurrent',
+      label: removeCurrent,
+      onClick() {
+        var _a;
+        const pageKeys = getEnabledItemKeys((((_a = listBodyRef.current) === null || _a === void 0 ? void 0 : _a.items) || []).map(entity => entity.item));
+        onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(pageKeys);
+      }
+    } : null, /* Remove All */
+    {
+      key: 'removeAll',
+      label: removeAll,
+      onClick() {
+        onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(getEnabledItemKeys(filteredItems));
+      }
+    }].filter(Boolean);
+  } else {
+    items = [{
+      key: 'selectAll',
+      label: checkStatus === 'all' ? deselectAll : selectAll,
+      onClick() {
+        const keys = getEnabledItemKeys(filteredItems);
+        onItemSelectAll === null || onItemSelectAll === void 0 ? void 0 : onItemSelectAll(keys, keys.length !== checkedKeys.length);
+      }
+    }, pagination ? {
+      key: 'selectCurrent',
+      label: selectCurrent,
+      onClick() {
+        var _a;
+        const pageItems = ((_a = listBodyRef.current) === null || _a === void 0 ? void 0 : _a.items) || [];
+        onItemSelectAll === null || onItemSelectAll === void 0 ? void 0 : onItemSelectAll(getEnabledItemKeys(pageItems.map(entity => entity.item)), true);
+      }
+    } : null, {
+      key: 'selectInvert',
+      label: selectInvert,
+      onClick() {
+        var _a;
+        const availablePageItemKeys = getEnabledItemKeys((((_a = listBodyRef.current) === null || _a === void 0 ? void 0 : _a.items) || []).map(entity => entity.item));
+        const checkedKeySet = new Set(checkedKeys);
+        const newCheckedKeysSet = new Set(checkedKeySet);
+        availablePageItemKeys.forEach(key => {
+          if (checkedKeySet.has(key)) {
+            newCheckedKeysSet.delete(key);
+          } else {
+            newCheckedKeysSet.add(key);
+          }
+        });
+        onItemSelectAll === null || onItemSelectAll === void 0 ? void 0 : onItemSelectAll(Array.from(newCheckedKeysSet), 'replace');
+      }
+    }];
+  }
+  const dropdown = /*#__PURE__*/_react.default.createElement(_dropdown.default, {
+    className: `${prefixCls}-header-dropdown`,
+    menu: {
+      items
+    },
+    disabled: disabled
+  }, isValidIcon(selectionsIcon) ? selectionsIcon : /*#__PURE__*/_react.default.createElement(_DownOutlined.default, null));
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: listCls,
+    style: style
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    className: `${prefixCls}-header`
+  }, showSelectAll ? (/*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, checkAllCheckbox, dropdown)) : null, /*#__PURE__*/_react.default.createElement("span", {
+    className: `${prefixCls}-header-selected`
+  }, getSelectAllLabel(checkedActiveItems.length, filteredItems.length)), /*#__PURE__*/_react.default.createElement("span", {
+    className: `${prefixCls}-header-title`
+  }, titleText)), renderListBody(), listFooter);
+};
+if (process.env.NODE_ENV !== 'production') {
+  TransferList.displayName = 'TransferList';
+}
+var _default = exports.default = TransferList;

node_modules/antd/lib/transfer/operation.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { DirectionType } from '../config-provider';
+export interface TransferOperationProps {
+    className?: string;
+    leftArrowText?: string;
+    rightArrowText?: string;
+    moveToLeft?: React.MouseEventHandler<HTMLButtonElement | HTMLAnchorElement>;
+    moveToRight?: React.MouseEventHandler<HTMLButtonElement | HTMLAnchorElement>;
+    leftActive?: boolean;
+    rightActive?: boolean;
+    style?: React.CSSProperties;
+    disabled?: boolean;
+    direction?: DirectionType;
+    oneWay?: boolean;
+}
+declare const Operation: React.FC<TransferOperationProps>;
+export default Operation;

node_modules/antd/lib/transfer/operation.js

@@ -0,0 +1,48 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _LeftOutlined = _interopRequireDefault(require("@ant-design/icons/LeftOutlined"));
+var _RightOutlined = _interopRequireDefault(require("@ant-design/icons/RightOutlined"));
+var _button = _interopRequireDefault(require("../button"));
+const Operation = props => {
+  const {
+    disabled,
+    moveToLeft,
+    moveToRight,
+    leftArrowText = '',
+    rightArrowText = '',
+    leftActive,
+    rightActive,
+    className,
+    style,
+    direction,
+    oneWay
+  } = props;
+  return /*#__PURE__*/React.createElement("div", {
+    className: className,
+    style: style
+  }, /*#__PURE__*/React.createElement(_button.default, {
+    type: "primary",
+    size: "small",
+    disabled: disabled || !rightActive,
+    onClick: moveToRight,
+    icon: direction !== 'rtl' ? /*#__PURE__*/React.createElement(_RightOutlined.default, null) : /*#__PURE__*/React.createElement(_LeftOutlined.default, null)
+  }, rightArrowText), !oneWay && (/*#__PURE__*/React.createElement(_button.default, {
+    type: "primary",
+    size: "small",
+    disabled: disabled || !leftActive,
+    onClick: moveToLeft,
+    icon: direction !== 'rtl' ? /*#__PURE__*/React.createElement(_LeftOutlined.default, null) : /*#__PURE__*/React.createElement(_RightOutlined.default, null)
+  }, leftArrowText)));
+};
+if (process.env.NODE_ENV !== 'production') {
+  Operation.displayName = 'Operation';
+}
+var _default = exports.default = Operation;

node_modules/antd/lib/transfer/search.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface TransferSearchProps {
+    prefixCls?: string;
+    placeholder?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleClear?: () => void;
+    value?: string;
+    disabled?: boolean;
+}
+declare const Search: React.FC<TransferSearchProps>;
+export default Search;

node_modules/antd/lib/transfer/search.js

@@ -0,0 +1,41 @@
+"use strict";
+"use client";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _SearchOutlined = _interopRequireDefault(require("@ant-design/icons/SearchOutlined"));
+var _Input = _interopRequireDefault(require("../input/Input"));
+const Search = props => {
+  const {
+    placeholder = '',
+    value,
+    prefixCls,
+    disabled,
+    onChange,
+    handleClear
+  } = props;
+  const handleChange = React.useCallback(e => {
+    onChange === null || onChange === void 0 ? void 0 : onChange(e);
+    if (e.target.value === '') {
+      handleClear === null || handleClear === void 0 ? void 0 : handleClear();
+    }
+  }, [onChange]);
+  return /*#__PURE__*/React.createElement(_Input.default, {
+    placeholder: placeholder,
+    className: prefixCls,
+    value: value,
+    onChange: handleChange,
+    disabled: disabled,
+    allowClear: true,
+    prefix: /*#__PURE__*/React.createElement(_SearchOutlined.default, null)
+  });
+};
+if (process.env.NODE_ENV !== 'production') {
+  Search.displayName = 'Search';
+}
+var _default = exports.default = Search;

node_modules/antd/lib/transfer/style/index.d.ts

@@ -0,0 +1,36 @@
+import type { GetDefaultToken } from '../../theme/internal';
+export interface ComponentToken {
+    /**
+     * @desc 列表宽度
+     * @descEN Width of list
+     */
+    listWidth: number | string;
+    /**
+     * @desc 大号列表宽度
+     * @descEN Width of large list
+     */
+    listWidthLG: number | string;
+    /**
+     * @desc 列表高度
+     * @descEN Height of list
+     */
+    listHeight: number | string;
+    /**
+     * @desc 列表项高度
+     * @descEN Height of list item
+     */
+    itemHeight: number | string;
+    /**
+     * @desc 列表项纵向内边距
+     * @descEN Vertical padding of list item
+     */
+    itemPaddingBlock: number | string;
+    /**
+     * @desc 顶部高度
+     * @descEN Height of header
+     */
+    headerHeight: number | string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Transfer'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: React.ReactElement) => React.ReactElement, string, string];
+export default _default;

node_modules/antd/lib/transfer/style/index.js

@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareComponentToken = exports.default = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+const genTransferCustomizeStyle = token => {
+  const {
+    antCls,
+    componentCls,
+    listHeight,
+    controlHeightLG
+  } = token;
+  const tableCls = `${antCls}-table`;
+  const inputCls = `${antCls}-input`;
+  return {
+    [`${componentCls}-customize-list`]: {
+      [`${componentCls}-list`]: {
+        flex: '1 1 50%',
+        width: 'auto',
+        height: 'auto',
+        minHeight: listHeight,
+        minWidth: 0
+      },
+      // =================== Hook Components ===================
+      [`${tableCls}-wrapper`]: {
+        [`${tableCls}-small`]: {
+          border: 0,
+          borderRadius: 0,
+          [`${tableCls}-selection-column`]: {
+            width: controlHeightLG,
+            minWidth: controlHeightLG
+          }
+        },
+        [`${tableCls}-pagination${tableCls}-pagination`]: {
+          margin: 0,
+          padding: token.paddingXS
+        }
+      },
+      [`${inputCls}[disabled]`]: {
+        backgroundColor: 'transparent'
+      }
+    }
+  };
+};
+const genTransferStatusColor = (token, color) => {
+  const {
+    componentCls,
+    colorBorder
+  } = token;
+  return {
+    [`${componentCls}-list`]: {
+      borderColor: color,
+      '&-search:not([disabled])': {
+        borderColor: colorBorder
+      }
+    }
+  };
+};
+const genTransferStatusStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-status-error`]: Object.assign({}, genTransferStatusColor(token, token.colorError)),
+    [`${componentCls}-status-warning`]: Object.assign({}, genTransferStatusColor(token, token.colorWarning))
+  };
+};
+const genTransferListStyle = token => {
+  const {
+    componentCls,
+    colorBorder,
+    colorSplit,
+    lineWidth,
+    itemHeight,
+    headerHeight,
+    transferHeaderVerticalPadding,
+    itemPaddingBlock,
+    controlItemBgActive,
+    colorTextDisabled,
+    colorTextSecondary,
+    listHeight,
+    listWidth,
+    listWidthLG,
+    fontSizeIcon,
+    marginXS,
+    paddingSM,
+    lineType,
+    antCls,
+    iconCls,
+    motionDurationSlow,
+    controlItemBgHover,
+    borderRadiusLG,
+    colorBgContainer,
+    colorText,
+    controlItemBgActiveHover
+  } = token;
+  const contentBorderRadius = (0, _cssinjs.unit)(token.calc(borderRadiusLG).sub(lineWidth).equal());
+  return {
+    display: 'flex',
+    flexDirection: 'column',
+    width: listWidth,
+    height: listHeight,
+    border: `${(0, _cssinjs.unit)(lineWidth)} ${lineType} ${colorBorder}`,
+    borderRadius: token.borderRadiusLG,
+    '&-with-pagination': {
+      width: listWidthLG,
+      height: 'auto'
+    },
+    '&-search': {
+      [`${iconCls}-search`]: {
+        color: colorTextDisabled
+      }
+    },
+    '&-header': {
+      display: 'flex',
+      flex: 'none',
+      alignItems: 'center',
+      height: headerHeight,
+      // border-top is on the transfer dom. We should minus 1px for this
+      padding: `${(0, _cssinjs.unit)(token.calc(transferHeaderVerticalPadding).sub(lineWidth).equal())} ${(0, _cssinjs.unit)(paddingSM)} ${(0, _cssinjs.unit)(transferHeaderVerticalPadding)}`,
+      color: colorText,
+      background: colorBgContainer,
+      borderBottom: `${(0, _cssinjs.unit)(lineWidth)} ${lineType} ${colorSplit}`,
+      borderRadius: `${(0, _cssinjs.unit)(borderRadiusLG)} ${(0, _cssinjs.unit)(borderRadiusLG)} 0 0`,
+      '> *:not(:last-child)': {
+        marginInlineEnd: 4 // This is magic and fixed number, DO NOT use token since it may change.
+      },
+      '> *': {
+        flex: 'none'
+      },
+      '&-title': Object.assign(Object.assign({}, _style.textEllipsis), {
+        flex: 'auto',
+        textAlign: 'end'
+      }),
+      '&-dropdown': Object.assign(Object.assign({}, (0, _style.resetIcon)()), {
+        fontSize: fontSizeIcon,
+        transform: 'translateY(10%)',
+        cursor: 'pointer',
+        '&[disabled]': {
+          cursor: 'not-allowed'
+        }
+      })
+    },
+    '&-body': {
+      display: 'flex',
+      flex: 'auto',
+      flexDirection: 'column',
+      fontSize: token.fontSize,
+      // https://blog.csdn.net/qq449245884/article/details/107373672/
+      minHeight: 0,
+      '&-search-wrapper': {
+        position: 'relative',
+        flex: 'none',
+        padding: paddingSM
+      }
+    },
+    '&-content': {
+      flex: 'auto',
+      margin: 0,
+      padding: 0,
+      overflow: 'auto',
+      listStyle: 'none',
+      borderRadius: `0 0 ${contentBorderRadius} ${contentBorderRadius}`,
+      '&-item': {
+        display: 'flex',
+        alignItems: 'center',
+        minHeight: itemHeight,
+        padding: `${(0, _cssinjs.unit)(itemPaddingBlock)} ${(0, _cssinjs.unit)(paddingSM)}`,
+        transition: `all ${motionDurationSlow}`,
+        '> *:not(:last-child)': {
+          marginInlineEnd: marginXS
+        },
+        '> *': {
+          flex: 'none'
+        },
+        '&-text': Object.assign(Object.assign({}, _style.textEllipsis), {
+          flex: 'auto'
+        }),
+        '&-remove': Object.assign(Object.assign({}, (0, _style.operationUnit)(token)), {
+          color: colorBorder,
+          '&:hover, &:focus': {
+            color: colorTextSecondary
+          }
+        }),
+        [`&:not(${componentCls}-list-content-item-disabled)`]: {
+          '&:hover': {
+            backgroundColor: controlItemBgHover,
+            cursor: 'pointer'
+          },
+          [`&${componentCls}-list-content-item-checked:hover`]: {
+            backgroundColor: controlItemBgActiveHover
+          }
+        },
+        '&-checked': {
+          backgroundColor: controlItemBgActive
+        },
+        '&-disabled': {
+          color: colorTextDisabled,
+          cursor: 'not-allowed'
+        }
+      },
+      // Do not change hover style when `oneWay` mode
+      [`&-show-remove ${componentCls}-list-content-item:not(${componentCls}-list-content-item-disabled):hover`]: {
+        background: 'transparent',
+        cursor: 'default'
+      }
+    },
+    '&-pagination': {
+      padding: token.paddingXS,
+      textAlign: 'end',
+      borderTop: `${(0, _cssinjs.unit)(lineWidth)} ${lineType} ${colorSplit}`,
+      [`${antCls}-pagination-options`]: {
+        paddingInlineEnd: token.paddingXS
+      }
+    },
+    '&-body-not-found': {
+      flex: 'none',
+      width: '100%',
+      margin: 'auto 0',
+      color: colorTextDisabled,
+      textAlign: 'center'
+    },
+    '&-footer': {
+      borderTop: `${(0, _cssinjs.unit)(lineWidth)} ${lineType} ${colorSplit}`
+    },
+    // fix: https://github.com/ant-design/ant-design/issues/44489
+    '&-checkbox': {
+      lineHeight: 1
+    }
+  };
+};
+const genTransferStyle = token => {
+  const {
+    antCls,
+    iconCls,
+    componentCls,
+    marginXS,
+    marginXXS,
+    fontSizeIcon,
+    colorBgContainerDisabled
+  } = token;
+  return {
+    [componentCls]: Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+      position: 'relative',
+      display: 'flex',
+      alignItems: 'stretch',
+      [`${componentCls}-disabled`]: {
+        [`${componentCls}-list`]: {
+          background: colorBgContainerDisabled
+        }
+      },
+      [`${componentCls}-list`]: genTransferListStyle(token),
+      [`${componentCls}-operation`]: {
+        display: 'flex',
+        flex: 'none',
+        flexDirection: 'column',
+        alignSelf: 'center',
+        margin: `0 ${(0, _cssinjs.unit)(marginXS)}`,
+        verticalAlign: 'middle',
+        gap: marginXXS,
+        [`${antCls}-btn ${iconCls}`]: {
+          fontSize: fontSizeIcon
+        }
+      }
+    })
+  };
+};
+const genTransferRTLStyle = token => {
+  const {
+    componentCls
+  } = token;
+  return {
+    [`${componentCls}-rtl`]: {
+      direction: 'rtl'
+    }
+  };
+};
+const prepareComponentToken = token => {
+  const {
+    fontSize,
+    lineHeight,
+    controlHeight,
+    controlHeightLG,
+    lineWidth
+  } = token;
+  const fontHeight = Math.round(fontSize * lineHeight);
+  return {
+    listWidth: 180,
+    listHeight: 200,
+    listWidthLG: 250,
+    headerHeight: controlHeightLG,
+    itemHeight: controlHeight,
+    itemPaddingBlock: (controlHeight - fontHeight) / 2,
+    transferHeaderVerticalPadding: Math.ceil((controlHeightLG - lineWidth - fontHeight) / 2)
+  };
+};
+// ============================== Export ==============================
+exports.prepareComponentToken = prepareComponentToken;
+var _default = exports.default = (0, _internal.genStyleHooks)('Transfer', token => {
+  const transferToken = (0, _internal.mergeToken)(token);
+  return [genTransferStyle(transferToken), genTransferCustomizeStyle(transferToken), genTransferStatusStyle(transferToken), genTransferRTLStyle(transferToken)];
+}, prepareComponentToken);