@yoka-ui/ui 1.0.1

package/dist/lib/components/TreeTransfer/index.less

@@ -0,0 +1,69 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+.tree-transfer-wrapper {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+
+  .ant-spin-nested-loading {
+    width: 100%;
+    height: 100%;
+
+    .ant-spin-container {
+      width: 100%;
+      height: 100%;
+    }
+  }
+
+  // 主内容区域
+  .tree-transfer-content {
+    display: flex;
+    align-items: stretch;
+    height: 100%;
+  }
+
+  // 中间操作按钮区域
+  .tree-transfer-operations {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 8px;
+    padding-left: 7px;
+    width: 40px;
+    flex-shrink: 0;
+
+    .ant-space {
+      .tree-transfer-operation-btn {
+        width: 25px;
+        height: 25px;
+        min-width: 25px;
+        padding: 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+
+        .anticon {
+          font-size: 12px;
+          margin: 0;
+        }
+      }
+    }
+  }
+}

package/dist/lib/components/TreeTransfer/types.d.ts

@@ -0,0 +1,122 @@
+/// <reference types="react" />
+import type { ColumnsType } from 'antd/es/table';
+/**
+ * 默认每页显示条数
+ */
+export declare const DEFAULT_PAGE_SIZE = 20;
+/**
+ * 树形表格行数据基类
+ * @template T - 自定义数据类型
+ */
+export interface TreeTransferRow<T = any> {
+    /** 唯一标识 */
+    key: string | number;
+    /** 父节点唯一标识 */
+    parentKey?: string | number;
+    /** 子节点列表 */
+    children?: TreeTransferRow<T>[];
+    /** 是否为父节点 */
+    isParent?: boolean;
+    /** 自定义数据 */
+    data: T;
+}
+/**
+ * 穿梭框面板Props
+ */
+export interface TreeTransferPanelProps<T = any> {
+    /** 数据源 */
+    dataSource: TreeTransferRow<T>[];
+    /** 已选中的行keys */
+    selectedRowKeys: React.Key[];
+    /** 行选择回调 */
+    onRowSelect: (selectedRows: TreeTransferRow<T>[], selectedRowKeys: React.Key[]) => void;
+    /** 搜索关键词 */
+    searchValue: string;
+    /** 设置搜索关键词 */
+    setSearchValue: (value: string) => void;
+    searchPlaceholder?: string;
+    /** 总数 */
+    totalCount: number;
+    /** 面板标题 */
+    title: string;
+    /** 是否显示分页 */
+    showPagination?: boolean;
+    /** 当前页码 */
+    currentPage?: number;
+    /** 每页条数（与父组件 pageSize 保持一致，用于分页器） */
+    pageSize?: number;
+    /** 分页变化回调 */
+    onPageChange?: (page: number) => void;
+    /** 自定义列配置，如果不传则使用默认配置 */
+    columns?: ColumnsType<TreeTransferRow<T>>;
+    /** 自定义渲染函数 */
+    customRender?: {
+        /** 自定义行单元格渲染 */
+        onCell?: (record: TreeTransferRow<T>) => any;
+        /** 自定义单元格内容渲染 */
+        cellRender?: (text: any, record: TreeTransferRow<T>, index: number) => React.ReactNode;
+    };
+}
+/**
+ * 穿梭框面板状态
+ */
+export interface TreeTransferPanelState {
+    /** 当前页数据 */
+    dataSource: TreeTransferRow[];
+    /** 选中的keys */
+    selectedRowKeys: React.Key[];
+    /** 搜索关键词 */
+    searchValue: string;
+    /** 当前页码 */
+    currentPage: number;
+    /** 总条数 */
+    totalCount: number;
+}
+/**
+ * 穿梭框主组件Props
+ * @template T - 数据类型
+ */
+export interface TreeTransferProps<T = any> {
+    /** 左侧数据源（完整数据） */
+    leftDataSource: TreeTransferRow<T>[];
+    /** 右侧数据源（完整数据） */
+    rightDataSource: TreeTransferRow<T>[];
+    /** 数据加载状态 */
+    loading?: boolean;
+    /** 左侧面板标题 */
+    leftTitle?: string;
+    /** 右侧面板标题 */
+    rightTitle?: string;
+    /** 左侧总数文本（如需自定义） */
+    leftCountText?: string;
+    /** 右侧总数文本（如需自定义） */
+    rightCountText?: string;
+    /** 搜索框占位符 */
+    searchPlaceholder?: string;
+    /** 是否允许跨页选择 */
+    crossPageSelection?: boolean;
+    /** 每页显示条数 */
+    pageSize?: number;
+    /** 自定义列配置 */
+    columns?: ColumnsType<TreeTransferRow<T>>;
+    /** 自定义渲染 */
+    customRender?: TreeTransferPanelProps['customRender'];
+    /** 搜索字段，支持字段名或自定义函数 */
+    searchFields?: (string | ((item: T) => string))[];
+    /** 选中项变化回调 */
+    onChange?: (params: {
+        leftSelected: TreeTransferRow<T>[];
+        rightSelected: TreeTransferRow<T>[];
+        leftData: TreeTransferRow<T>[];
+        rightData: TreeTransferRow<T>[];
+    }) => void;
+}
+/**
+ * 权限移动数据（用于穿梭操作）
+ */
+export interface TransferItem<T = any> {
+    /** 所属父节点key */
+    parentKey: string | number;
+    /** 移动的数据 */
+    data: T;
+}

package/dist/lib/components/TreeTransfer/types.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/TreeTransfer/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE
+});
+module.exports = __toCommonJS(types_exports);
+var DEFAULT_PAGE_SIZE = 20;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PAGE_SIZE
+});
+//# sourceMappingURL=types.js.map

package/dist/lib/components/TreeTransfer/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/TreeTransfer/types.ts"],
+  "sourcesContent": ["/*\n *  Licensed to the Apache Software Foundation (ASF) under one or more\n *  contributor license agreements.  See the NOTICE file distributed with\n *  this work for additional information regarding copyright ownership.\n *  The ASF licenses this file to You under the Apache License, Version 2.0\n *  (the \"License\"); you may not use this file except in compliance with\n *  the License.  You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n *  Unless required by applicable law or agreed to in writing, software\n *  distributed under the License is distributed on an \"AS IS\" BASIS,\n *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *  See the License for the specific language governing permissions and\n *  limitations under the License.\n *\n */\n\nimport type { ColumnsType } from 'antd/es/table';\n\n/**\n * 默认每页显示条数\n */\nexport const DEFAULT_PAGE_SIZE = 20;\n\n/**\n * 树形表格行数据基类\n * @template T - 自定义数据类型\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface TreeTransferRow<T = any> {\n  /** 唯一标识 */\n  key: string | number;\n  /** 父节点唯一标识 */\n  parentKey?: string | number;\n  /** 子节点列表 */\n  children?: TreeTransferRow<T>[];\n  /** 是否为父节点 */\n  isParent?: boolean;\n  /** 自定义数据 */\n  data: T;\n}\n\n/**\n * 穿梭框面板Props\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface TreeTransferPanelProps<T = any> {\n  /** 数据源 */\n  dataSource: TreeTransferRow<T>[];\n  /** 已选中的行keys */\n  selectedRowKeys: React.Key[];\n  /** 行选择回调 */\n  onRowSelect: (selectedRows: TreeTransferRow<T>[], selectedRowKeys: React.Key[]) => void;\n  /** 搜索关键词 */\n  searchValue: string;\n  /** 设置搜索关键词 */\n  setSearchValue: (value: string) => void;\n  searchPlaceholder?: string;\n  /** 总数 */\n  totalCount: number;\n  /** 面板标题 */\n  title: string;\n  /** 是否显示分页 */\n  showPagination?: boolean;\n  /** 当前页码 */\n  currentPage?: number;\n  /** 每页条数（与父组件 pageSize 保持一致，用于分页器） */\n  pageSize?: number;\n  /** 分页变化回调 */\n  onPageChange?: (page: number) => void;\n  /** 自定义列配置，如果不传则使用默认配置 */\n  columns?: ColumnsType<TreeTransferRow<T>>;\n  /** 自定义渲染函数 */\n  customRender?: {\n    /** 自定义行单元格渲染 */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    onCell?: (record: TreeTransferRow<T>) => any;\n    /** 自定义单元格内容渲染 */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    cellRender?: (text: any, record: TreeTransferRow<T>, index: number) => React.ReactNode;\n  };\n}\n\n/**\n * 穿梭框面板状态\n */\nexport interface TreeTransferPanelState {\n  /** 当前页数据 */\n  dataSource: TreeTransferRow[];\n  /** 选中的keys */\n  selectedRowKeys: React.Key[];\n  /** 搜索关键词 */\n  searchValue: string;\n  /** 当前页码 */\n  currentPage: number;\n  /** 总条数 */\n  totalCount: number;\n}\n\n/**\n * 穿梭框主组件Props\n * @template T - 数据类型\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface TreeTransferProps<T = any> {\n  /** 左侧数据源（完整数据） */\n  leftDataSource: TreeTransferRow<T>[];\n  /** 右侧数据源（完整数据） */\n  rightDataSource: TreeTransferRow<T>[];\n  /** 数据加载状态 */\n  loading?: boolean;\n  /** 左侧面板标题 */\n  leftTitle?: string;\n  /** 右侧面板标题 */\n  rightTitle?: string;\n  /** 左侧总数文本（如需自定义） */\n  leftCountText?: string;\n  /** 右侧总数文本（如需自定义） */\n  rightCountText?: string;\n  /** 搜索框占位符 */\n  searchPlaceholder?: string;\n  /** 是否允许跨页选择 */\n  crossPageSelection?: boolean;\n  /** 每页显示条数 */\n  pageSize?: number;\n  /** 自定义列配置 */\n  columns?: ColumnsType<TreeTransferRow<T>>;\n  /** 自定义渲染 */\n  customRender?: TreeTransferPanelProps['customRender'];\n  /** 搜索字段，支持字段名或自定义函数 */\n  searchFields?: (string | ((item: T) => string))[];\n  /** 选中项变化回调 */\n  onChange?: (params: {\n    leftSelected: TreeTransferRow<T>[];\n    rightSelected: TreeTransferRow<T>[];\n    leftData: TreeTransferRow<T>[];\n    rightData: TreeTransferRow<T>[];\n  }) => void;\n}\n\n/**\n * 权限移动数据（用于穿梭操作）\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface TransferItem<T = any> {\n  /** 所属父节点key */\n  parentKey: string | number;\n  /** 移动的数据 */\n  data: T;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBO,IAAM,oBAAoB;",
+  "names": []
+}

package/dist/lib/components/TreeTransfer/utils/index.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="react" />
+import { TreeTransferRow } from '../types';
+/**
+ * 从平铺的数据构建树形结构
+ *
+ * @param data - 平铺的数据数组
+ * @param options - 配置选项
+ * @returns 树形结构数据
+ *
+ * @example
+ * ```tsx
+ * const flatData = [
+ *   { id: '1', parentId: null, name: '应用1' },
+ *   { id: '1-1', parentId: '1', name: '权限1' },
+ * ];
+ *
+ * const treeData = buildTreeData(flatData, {
+ *   keyField: 'id',
+ *   parentField: 'parentId',
+ * });
+ * ```
+ */
+export declare function buildTreeData<T extends Record<string, any>>(data: T[], options?: {
+    /** 唯一键字段名，默认 'id' */
+    keyField?: string;
+    /** 父键字段名，默认 'parentId' */
+    parentField?: string;
+    /** 判断是否为父节点的函数，默认：无父键则为父节点 */
+    isParent?: (item: T) => boolean;
+}): TreeTransferRow<T>[];
+/**
+ * 将树形结构平铺为一维数组（深度优先）
+ *
+ * @example
+ * ```tsx
+ * const flat = flattenTreeData([{ key: '1', children: [{ key: '1-1' }] }]);
+ * // → [{ key: '1' }, { key: '1-1' }]
+ * ```
+ */
+export declare function flattenTreeData<T = any>(treeData: TreeTransferRow<T>[]): TreeTransferRow<T>[];
+/**
+ * 根据页码切片数据（前端分页）
+ *
+ * @param data - 数据数组
+ * @param page - 页码（从 1 开始）
+ * @param pageSize - 每页条数
+ * @returns 当前页数据
+ */
+export declare function sliceDataByPage<T = any>(data: TreeTransferRow<T>[], page: number, pageSize?: number): TreeTransferRow<T>[];
+/**
+ * 过滤数据（支持模糊搜索，递归保留有匹配子节点的父节点）
+ *
+ * @param data - 数据数组
+ * @param searchValue - 搜索关键词（空字符串返回全量数据）
+ * @param fields - 搜索字段列表，支持字段名或自定义取值函数，默认 ['id', 'name']
+ * @returns 过滤后的数据
+ */
+export declare function filterData<T = any>(data: TreeTransferRow<T>[], searchValue: string, fields?: (string | ((item: T) => string))[]): TreeTransferRow<T>[];
+/**
+ * 获取选中节点及其所有后代节点的 key 集合（用于批量移除）
+ *
+ * 修复说明：原实现对 3+ 层树只展开 2 层。现改为对每个选中节点
+ * 递归收集完整后代链，支持任意深度的树结构。
+ *
+ * @param selectedKeys - 选中的 keys
+ * @param dataSource - 完整数据源
+ * @returns 所有相关 key（字符串形式，含选中节点本身）
+ *
+ * @example
+ * ```tsx
+ * // 选中 'app1'（含 2 级子节点）
+ * getAllDescendantKeys(['app1'], dataSource);
+ * // → ['app1', 'app1-perm1', 'app1-perm1-sub1', 'app1-perm2', ...]
+ * ```
+ */
+export declare function getAllDescendantKeys(selectedKeys: React.Key[], dataSource: TreeTransferRow[]): string[];
+/**
+ * 计算数据总节点数（包含所有后代）
+ */
+export declare function countTotalNodes<T = any>(data: TreeTransferRow<T>[]): number;
+/**
+ * 计算顶层节点数（用于分页总数，不含嵌套子节点）
+ */
+export declare function countParentNodes<T = any>(data: TreeTransferRow<T>[]): number;
+/**
+ * 查找节点及其所有后代节点（按 key 定位）
+ */
+export declare function findNodeWithDescendants<T = any>(key: string | number, dataSource: TreeTransferRow<T>[]): TreeTransferRow<T>[];
+/**
+ * 从树形数据中移除指定 key 的节点（不可变，返回新数组）
+ *
+ * @param dataSource - 数据源
+ * @param keysToRemove - 要移除的节点 key 集合
+ * @returns 过滤后的新数据源
+ */
+export declare function removeNodesFromTree<T = any>(dataSource: TreeTransferRow<T>[], keysToRemove: Set<string | number>): TreeTransferRow<T>[];
+/**
+ * 向树形数据添加节点
+ *
+ * @param dataSource - 数据源
+ * @param parentKey - 父节点 key；传 null 表示添加到根
+ * @param nodes - 要添加的节点列表
+ * @returns 新的数据源
+ */
+export declare function addNodesToTree<T = any>(dataSource: TreeTransferRow<T>[], parentKey: string | number | null, nodes: TreeTransferRow<T>[]): TreeTransferRow<T>[];
+/**
+ * 从树形数据中提取"顶层选中节点"（用于穿梭框移动操作）
+ *
+ * 行为：遍历树，遇到选中节点时直接收集（含其 children），不再向下递归。
+ * 这样可以避免父节点和其已选中的子节点被分别添加两次。
+ *
+ * 适用场景：AntD Table 的 checkStrictly:false 级联选择中，
+ * 选中父节点会自动勾选子节点。move 时只需携带父节点（含 children）。
+ * 若仅选了某个子节点，则该子节点会被作为顶层节点添加到目标列表。
+ *
+ * @param selectedKeys - 选中的 key 集合（字符串）
+ * @param dataSource - 数据源（支持嵌套树）
+ * @returns 最小集合的顶层选中节点列表
+ */
+export declare function extractTopLevelSelectedNodes<T = any>(selectedKeys: Set<string>, dataSource: TreeTransferRow<T>[]): TreeTransferRow<T>[];

package/dist/lib/components/TreeTransfer/utils/index.js

@@ -0,0 +1,208 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/TreeTransfer/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addNodesToTree: () => addNodesToTree,
+  buildTreeData: () => buildTreeData,
+  countParentNodes: () => countParentNodes,
+  countTotalNodes: () => countTotalNodes,
+  extractTopLevelSelectedNodes: () => extractTopLevelSelectedNodes,
+  filterData: () => filterData,
+  findNodeWithDescendants: () => findNodeWithDescendants,
+  flattenTreeData: () => flattenTreeData,
+  getAllDescendantKeys: () => getAllDescendantKeys,
+  removeNodesFromTree: () => removeNodesFromTree,
+  sliceDataByPage: () => sliceDataByPage
+});
+module.exports = __toCommonJS(utils_exports);
+var import_types = require("../types");
+function buildTreeData(data, options = {}) {
+  const { keyField = "id", parentField = "parentId", isParent = (item) => !item[parentField] } = options;
+  const map = /* @__PURE__ */ new Map();
+  const roots = [];
+  data.forEach((item) => {
+    const key = item[keyField];
+    map.set(key, { key, data: item, isParent: isParent(item), children: [] });
+  });
+  data.forEach((item) => {
+    const key = item[keyField];
+    const parentId = item[parentField];
+    const node = map.get(key);
+    if (parentId && map.has(parentId)) {
+      map.get(parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  });
+  return roots;
+}
+function flattenTreeData(treeData) {
+  const result = [];
+  function traverse(nodes) {
+    nodes.forEach((node) => {
+      var _a;
+      result.push(node);
+      if ((_a = node.children) == null ? void 0 : _a.length)
+        traverse(node.children);
+    });
+  }
+  traverse(treeData);
+  return result;
+}
+function sliceDataByPage(data, page, pageSize = import_types.DEFAULT_PAGE_SIZE) {
+  const start = (page - 1) * pageSize;
+  return data.slice(start, start + pageSize);
+}
+function filterData(data, searchValue, fields = ["id", "name"]) {
+  if (!searchValue.trim())
+    return data;
+  const lowerSearch = searchValue.toLowerCase();
+  return data.filter((item) => {
+    var _a;
+    const selfMatch = fields.some((field) => {
+      const value = typeof field === "function" ? field(item.data) : item.data[field];
+      return String(value ?? "").toLowerCase().includes(lowerSearch);
+    });
+    if (selfMatch)
+      return true;
+    if ((_a = item.children) == null ? void 0 : _a.length) {
+      return filterData(item.children, searchValue, fields).length > 0;
+    }
+    return false;
+  });
+}
+function getAllDescendantKeys(selectedKeys, dataSource) {
+  const keySet = new Set(selectedKeys.map(String));
+  const allKeys = [];
+  function collectWithDescendants(node) {
+    var _a;
+    allKeys.push(String(node.key));
+    (_a = node.children) == null ? void 0 : _a.forEach(collectWithDescendants);
+  }
+  function traverse(nodes) {
+    nodes.forEach((node) => {
+      var _a;
+      if (keySet.has(String(node.key))) {
+        collectWithDescendants(node);
+      } else {
+        if ((_a = node.children) == null ? void 0 : _a.length)
+          traverse(node.children);
+      }
+    });
+  }
+  traverse(dataSource);
+  return allKeys;
+}
+function countTotalNodes(data) {
+  let count = 0;
+  function traverse(nodes) {
+    nodes.forEach((node) => {
+      var _a;
+      count += 1;
+      if ((_a = node.children) == null ? void 0 : _a.length)
+        traverse(node.children);
+    });
+  }
+  traverse(data);
+  return count;
+}
+function countParentNodes(data) {
+  return data.length;
+}
+function findNodeWithDescendants(key, dataSource) {
+  const result = [];
+  function traverse(nodes) {
+    var _a;
+    for (const node of nodes) {
+      if (node.key === key) {
+        result.push(node);
+        (_a = node.children) == null ? void 0 : _a.forEach((child) => {
+          result.push(child);
+          if (child.children)
+            traverse(child.children);
+        });
+        return true;
+      }
+      if (node.children && traverse(node.children))
+        return true;
+    }
+    return false;
+  }
+  traverse(dataSource);
+  return result;
+}
+function removeNodesFromTree(dataSource, keysToRemove) {
+  var _a;
+  const result = [];
+  for (const node of dataSource) {
+    if (keysToRemove.has(node.key))
+      continue;
+    if ((_a = node.children) == null ? void 0 : _a.length) {
+      result.push({ ...node, children: removeNodesFromTree(node.children, keysToRemove) });
+    } else {
+      result.push(node);
+    }
+  }
+  return result;
+}
+function addNodesToTree(dataSource, parentKey, nodes) {
+  if (parentKey === null) {
+    return [...dataSource, ...nodes];
+  }
+  return dataSource.map((node) => {
+    if (node.key === parentKey) {
+      return { ...node, children: [...node.children ?? [], ...nodes] };
+    }
+    if (node.children) {
+      return { ...node, children: addNodesToTree(node.children, parentKey, nodes) };
+    }
+    return node;
+  });
+}
+function extractTopLevelSelectedNodes(selectedKeys, dataSource) {
+  const result = [];
+  function traverse(nodes) {
+    nodes.forEach((node) => {
+      var _a;
+      if (selectedKeys.has(String(node.key))) {
+        result.push(node);
+      } else if ((_a = node.children) == null ? void 0 : _a.length) {
+        traverse(node.children);
+      }
+    });
+  }
+  traverse(dataSource);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addNodesToTree,
+  buildTreeData,
+  countParentNodes,
+  countTotalNodes,
+  extractTopLevelSelectedNodes,
+  filterData,
+  findNodeWithDescendants,
+  flattenTreeData,
+  getAllDescendantKeys,
+  removeNodesFromTree,
+  sliceDataByPage
+});
+//# sourceMappingURL=index.js.map

package/dist/lib/components/TreeTransfer/utils/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/components/TreeTransfer/utils/index.ts"],
+  "sourcesContent": ["/*\n *  Licensed to the Apache Software Foundation (ASF) under one or more\n *  contributor license agreements.  See the NOTICE file distributed with\n *  this work for additional information regarding copyright ownership.\n *  The ASF licenses this file to You under the Apache License, Version 2.0\n *  (the \"License\"); you may not use this file except in compliance with\n *  the License.  You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n *  Unless required by applicable law or agreed to in writing, software\n *  distributed under the License is distributed on an \"AS IS\" BASIS,\n *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *  See the License for the specific language governing permissions and\n *  limitations under the License.\n *\n */\n\nimport { TreeTransferRow, DEFAULT_PAGE_SIZE } from '../types';\n\n/**\n * 从平铺的数据构建树形结构\n *\n * @param data - 平铺的数据数组\n * @param options - 配置选项\n * @returns 树形结构数据\n *\n * @example\n * ```tsx\n * const flatData = [\n *   { id: '1', parentId: null, name: '应用1' },\n *   { id: '1-1', parentId: '1', name: '权限1' },\n * ];\n *\n * const treeData = buildTreeData(flatData, {\n *   keyField: 'id',\n *   parentField: 'parentId',\n * });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function buildTreeData<T extends Record<string, any>>(\n  data: T[],\n  options: {\n    /** 唯一键字段名，默认 'id' */\n    keyField?: string;\n    /** 父键字段名，默认 'parentId' */\n    parentField?: string;\n    /** 判断是否为父节点的函数，默认：无父键则为父节点 */\n    isParent?: (item: T) => boolean;\n  } = {},\n): TreeTransferRow<T>[] {\n  const { keyField = 'id', parentField = 'parentId', isParent = (item) => !item[parentField] } = options;\n\n  const map = new Map<string | number, TreeTransferRow<T>>();\n  const roots: TreeTransferRow<T>[] = [];\n\n  // 第一次遍历：建立 key → node 映射\n  data.forEach((item) => {\n    const key = item[keyField];\n    map.set(key, { key, data: item, isParent: isParent(item), children: [] });\n  });\n\n  // 第二次遍历：挂载父子关系\n  data.forEach((item) => {\n    const key = item[keyField];\n    const parentId = item[parentField];\n    const node = map.get(key)!;\n\n    if (parentId && map.has(parentId)) {\n      map.get(parentId)!.children!.push(node);\n    } else {\n      roots.push(node);\n    }\n  });\n\n  return roots;\n}\n\n/**\n * 将树形结构平铺为一维数组（深度优先）\n *\n * @example\n * ```tsx\n * const flat = flattenTreeData([{ key: '1', children: [{ key: '1-1' }] }]);\n * // → [{ key: '1' }, { key: '1-1' }]\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function flattenTreeData<T = any>(treeData: TreeTransferRow<T>[]): TreeTransferRow<T>[] {\n  const result: TreeTransferRow<T>[] = [];\n\n  function traverse(nodes: TreeTransferRow<T>[]) {\n    nodes.forEach((node) => {\n      result.push(node);\n      if (node.children?.length) traverse(node.children);\n    });\n  }\n\n  traverse(treeData);\n  return result;\n}\n\n/**\n * 根据页码切片数据（前端分页）\n *\n * @param data - 数据数组\n * @param page - 页码（从 1 开始）\n * @param pageSize - 每页条数\n * @returns 当前页数据\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function sliceDataByPage<T = any>(\n  data: TreeTransferRow<T>[],\n  page: number,\n  pageSize: number = DEFAULT_PAGE_SIZE,\n): TreeTransferRow<T>[] {\n  const start = (page - 1) * pageSize;\n  return data.slice(start, start + pageSize);\n}\n\n/**\n * 过滤数据（支持模糊搜索，递归保留有匹配子节点的父节点）\n *\n * @param data - 数据数组\n * @param searchValue - 搜索关键词（空字符串返回全量数据）\n * @param fields - 搜索字段列表，支持字段名或自定义取值函数，默认 ['id', 'name']\n * @returns 过滤后的数据\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function filterData<T = any>(\n  data: TreeTransferRow<T>[],\n  searchValue: string,\n  fields: (string | ((item: T) => string))[] = ['id', 'name'],\n): TreeTransferRow<T>[] {\n  if (!searchValue.trim()) return data;\n\n  const lowerSearch = searchValue.toLowerCase();\n\n  return data.filter((item) => {\n    // 当前节点任意字段匹配即保留\n    const selfMatch = fields.some((field) => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const value = typeof field === 'function' ? field(item.data) : (item.data as any)[field];\n      return String(value ?? '')\n        .toLowerCase()\n        .includes(lowerSearch);\n    });\n\n    if (selfMatch) return true;\n\n    // 子节点有匹配项则保留父节点（子节点也递归过滤）\n    if (item.children?.length) {\n      return filterData(item.children, searchValue, fields).length > 0;\n    }\n\n    return false;\n  });\n}\n\n/**\n * 获取选中节点及其所有后代节点的 key 集合（用于批量移除）\n *\n * 修复说明：原实现对 3+ 层树只展开 2 层。现改为对每个选中节点\n * 递归收集完整后代链，支持任意深度的树结构。\n *\n * @param selectedKeys - 选中的 keys\n * @param dataSource - 完整数据源\n * @returns 所有相关 key（字符串形式，含选中节点本身）\n *\n * @example\n * ```tsx\n * // 选中 'app1'（含 2 级子节点）\n * getAllDescendantKeys(['app1'], dataSource);\n * // → ['app1', 'app1-perm1', 'app1-perm1-sub1', 'app1-perm2', ...]\n * ```\n */\nexport function getAllDescendantKeys(selectedKeys: React.Key[], dataSource: TreeTransferRow[]): string[] {\n  const keySet = new Set(selectedKeys.map(String));\n  const allKeys: string[] = [];\n\n  /** 递归收集节点本身及所有后代的 key */\n  function collectWithDescendants(node: TreeTransferRow): void {\n    allKeys.push(String(node.key));\n    node.children?.forEach(collectWithDescendants);\n  }\n\n  function traverse(nodes: TreeTransferRow[]): void {\n    nodes.forEach((node) => {\n      if (keySet.has(String(node.key))) {\n        // 选中节点：收集自身及全部后代\n        collectWithDescendants(node);\n      } else {\n        // 未选中：继续向下搜索\n        if (node.children?.length) traverse(node.children);\n      }\n    });\n  }\n\n  traverse(dataSource);\n  return allKeys;\n}\n\n/**\n * 计算数据总节点数（包含所有后代）\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function countTotalNodes<T = any>(data: TreeTransferRow<T>[]): number {\n  let count = 0;\n  function traverse(nodes: TreeTransferRow<T>[]) {\n    nodes.forEach((node) => {\n      count += 1;\n      if (node.children?.length) traverse(node.children);\n    });\n  }\n  traverse(data);\n  return count;\n}\n\n/**\n * 计算顶层节点数（用于分页总数，不含嵌套子节点）\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function countParentNodes<T = any>(data: TreeTransferRow<T>[]): number {\n  return data.length;\n}\n\n/**\n * 查找节点及其所有后代节点（按 key 定位）\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function findNodeWithDescendants<T = any>(\n  key: string | number,\n  dataSource: TreeTransferRow<T>[],\n): TreeTransferRow<T>[] {\n  const result: TreeTransferRow<T>[] = [];\n\n  function traverse(nodes: TreeTransferRow<T>[]): boolean {\n    for (const node of nodes) {\n      if (node.key === key) {\n        result.push(node);\n        node.children?.forEach((child) => {\n          result.push(child);\n          if (child.children) traverse(child.children);\n        });\n        return true;\n      }\n      if (node.children && traverse(node.children)) return true;\n    }\n    return false;\n  }\n\n  traverse(dataSource);\n  return result;\n}\n\n/**\n * 从树形数据中移除指定 key 的节点（不可变，返回新数组）\n *\n * @param dataSource - 数据源\n * @param keysToRemove - 要移除的节点 key 集合\n * @returns 过滤后的新数据源\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function removeNodesFromTree<T = any>(\n  dataSource: TreeTransferRow<T>[],\n  keysToRemove: Set<string | number>,\n): TreeTransferRow<T>[] {\n  const result: TreeTransferRow<T>[] = [];\n\n  for (const node of dataSource) {\n    if (keysToRemove.has(node.key)) continue;\n\n    if (node.children?.length) {\n      result.push({ ...node, children: removeNodesFromTree(node.children, keysToRemove) });\n    } else {\n      result.push(node);\n    }\n  }\n\n  return result;\n}\n\n/**\n * 向树形数据添加节点\n *\n * @param dataSource - 数据源\n * @param parentKey - 父节点 key；传 null 表示添加到根\n * @param nodes - 要添加的节点列表\n * @returns 新的数据源\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function addNodesToTree<T = any>(\n  dataSource: TreeTransferRow<T>[],\n  parentKey: string | number | null,\n  nodes: TreeTransferRow<T>[],\n): TreeTransferRow<T>[] {\n  if (parentKey === null) {\n    return [...dataSource, ...nodes];\n  }\n\n  return dataSource.map((node) => {\n    if (node.key === parentKey) {\n      return { ...node, children: [...(node.children ?? []), ...nodes] };\n    }\n    if (node.children) {\n      return { ...node, children: addNodesToTree(node.children, parentKey, nodes) };\n    }\n    return node;\n  });\n}\n\n/**\n * 从树形数据中提取\"顶层选中节点\"（用于穿梭框移动操作）\n *\n * 行为：遍历树，遇到选中节点时直接收集（含其 children），不再向下递归。\n * 这样可以避免父节点和其已选中的子节点被分别添加两次。\n *\n * 适用场景：AntD Table 的 checkStrictly:false 级联选择中，\n * 选中父节点会自动勾选子节点。move 时只需携带父节点（含 children）。\n * 若仅选了某个子节点，则该子节点会被作为顶层节点添加到目标列表。\n *\n * @param selectedKeys - 选中的 key 集合（字符串）\n * @param dataSource - 数据源（支持嵌套树）\n * @returns 最小集合的顶层选中节点列表\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function extractTopLevelSelectedNodes<T = any>(\n  selectedKeys: Set<string>,\n  dataSource: TreeTransferRow<T>[],\n): TreeTransferRow<T>[] {\n  const result: TreeTransferRow<T>[] = [];\n\n  function traverse(nodes: TreeTransferRow<T>[]): void {\n    nodes.forEach((node) => {\n      if (selectedKeys.has(String(node.key))) {\n        // 选中节点：整体移动（children 随之迁移）\n        result.push(node);\n      } else if (node.children?.length) {\n        // 父节点未选中：继续向下搜寻子节点选中项\n        traverse(node.children);\n      }\n    });\n  }\n\n  traverse(dataSource);\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": []
+}