From 56035c131cacbdf32c3eee3387f266768a85124b Mon Sep 17 00:00:00 2001
From: saller <weskerli@163.com>
Date: Fri, 13 Jan 2023 17:27:42 +0800
Subject: [PATCH] feat(cdk:utils): add tree utils, fix data param of
 getAllSelectedKeys, fix filtered or paginated tree data value error (#1406)

* feat(cdk:utils): add tree utils

* fix(comp:transfer): correct `data` param of `getAllSelectedKeys`
 `data` param of `getAllSelectedKeys`  strategy fuction should be datasource when mod is immediate

* fix(pro:transfer): filtered or paginated tree data value error
when tree data is filtered or paginated, target data is overidden by new keys which should be appended insteadt
---
 packages/cdk/utils/__tests__/tree.spec.ts     | 257 ++++++++++++++
 packages/cdk/utils/index.ts                   |   1 +
 packages/cdk/utils/src/tree.ts                | 188 ++++++++++
 .../src/composables/useTransferSelectState.ts |   3 +-
 packages/components/utils/index.ts            |   1 +
 .../utils/src/useTreeCheckStateResolver.ts    | 282 +++++++++++++++
 .../transfer/__tests__/proTransfer.spec.ts    |  11 +-
 packages/pro/transfer/demo/BasicTable.vue     |   4 +-
 packages/pro/transfer/demo/BasicTree.vue      |   4 +-
 packages/pro/transfer/demo/FlattenTree.vue    |   4 +-
 .../pro/transfer/demo/TableCustomLabel.vue    |   4 +-
 .../pro/transfer/demo/TableMaxSelectedCnt.vue |   4 +-
 packages/pro/transfer/demo/TableOneWay.vue    |   4 +-
 .../pro/transfer/demo/TablePagination.vue     |   4 +-
 packages/pro/transfer/demo/TableRemote.vue    |   5 +-
 packages/pro/transfer/demo/TableVirtual.vue   |   8 +-
 .../transfer/demo/TreeCascaderStrategy.vue    |   5 +-
 .../pro/transfer/demo/TreeCustomLabel.vue     |   4 +-
 .../pro/transfer/demo/TreeLoadChildren.vue    |  10 +-
 packages/pro/transfer/demo/TreeOneWay.vue     |  21 +-
 packages/pro/transfer/demo/TreePagination.vue |  18 +-
 packages/pro/transfer/demo/TreeRemote.vue     |   4 +-
 packages/pro/transfer/demo/TreeVirtual.vue    |   6 +-
 .../src/composables/useTransferData.ts        |  20 +-
 .../src/composables/useTransferTableProps.ts  |  31 +-
 .../src/composables/useTransferTreeProps.ts   |  77 ++--
 .../src/composables/useTreeDataStrategy.ts    | 328 +++---------------
 .../composables/useTreeDataStrategyContext.ts |  88 +++--
 .../src/composables/useTreeExpandedKeys.ts    |   8 +-
 .../transfer/src/content/ProTransferTree.tsx  |  29 +-
 packages/pro/transfer/src/token.ts            |  13 +-
 packages/pro/transfer/src/types.ts            |   9 +-
 packages/pro/transfer/src/utils.ts            | 148 --------
 .../src/wrapper/TreeTransferWrapper.tsx       |  29 +-
 34 files changed, 1060 insertions(+), 572 deletions(-)
 create mode 100644 packages/cdk/utils/__tests__/tree.spec.ts
 create mode 100644 packages/cdk/utils/src/tree.ts
 create mode 100644 packages/components/utils/src/useTreeCheckStateResolver.ts
 delete mode 100644 packages/pro/transfer/src/utils.ts

diff --git a/packages/cdk/utils/__tests__/tree.spec.ts b/packages/cdk/utils/__tests__/tree.spec.ts
new file mode 100644
index 000000000..9f57806b7
--- /dev/null
+++ b/packages/cdk/utils/__tests__/tree.spec.ts
@@ -0,0 +1,257 @@
+import { filterTree, flattenTree, getTreeKeys, mapTree, mergeTree, traverseTree } from '../src/tree'
+
+interface Data {
+  key: string
+  label: string
+  children?: Data[]
+}
+
+const treeData: Data[] = [
+  {
+    label: 'Node 0',
+    key: '0',
+    children: [
+      {
+        label: 'Node 0-0',
+        key: '0-0',
+        children: [
+          { label: 'Node 0-0-0', key: '0-0-0' },
+          { label: 'Node 0-0-1', key: '0-0-1' },
+          { label: 'Node 0-0-2', key: '0-0-2' },
+        ],
+      },
+      {
+        label: 'Node 0-1',
+        key: '0-1',
+        children: [
+          { label: 'Node 0-1-0', key: '0-1-0' },
+          { label: 'Node 0-1-1', key: '0-1-1' },
+          { label: 'Node 0-1-2', key: '0-1-2' },
+        ],
+      },
+    ],
+  },
+  { label: 'Node 1', key: '1' },
+]
+const treeDataKeys = ['0', '0-0', '0-0-0', '0-0-1', '0-0-2', '0-1', '0-1-0', '0-1-1', '0-1-2', '1']
+const treeDataParentsMap = new Map<string, string[]>([
+  ['0', []],
+  ['1', []],
+  ['0-0', ['0']],
+  ['0-1', ['0']],
+  ['0-0-0', ['0-0', '0']],
+  ['0-0-1', ['0-0', '0']],
+  ['0-0-2', ['0-0', '0']],
+  ['0-1-0', ['0-1', '0']],
+  ['0-1-1', ['0-1', '0']],
+  ['0-1-2', ['0-1', '0']],
+])
+
+describe('tree.ts', () => {
+  test('traverseTree work', () => {
+    const keys: string[] = []
+    traverseTree(treeData, 'children', (item, parents) => {
+      keys.push(item.key)
+      expect(parents.map(parent => parent.key)).toEqual(treeDataParentsMap.get(item.key))
+      expect(parents.every(parent => parent.label === `Node ${parent.key}`)).toBeTruthy()
+    })
+
+    expect(keys).toEqual(treeDataKeys)
+  })
+
+  test('mapTree work', () => {
+    expect(
+      mapTree(treeData, 'children', (item, parents) => {
+        expect(parents.map(parent => parent.key)).toEqual(treeDataParentsMap.get(item.key))
+        expect(parents.every(parent => parent.label === `Node ${parent.key}`)).toBeTruthy()
+
+        return {
+          ...item,
+          mapped: true,
+        }
+      }),
+    ).toEqual([
+      {
+        label: 'Node 0',
+        key: '0',
+        mapped: true,
+        children: [
+          {
+            label: 'Node 0-0',
+            key: '0-0',
+            mapped: true,
+            children: [
+              { label: 'Node 0-0-0', key: '0-0-0', mapped: true },
+              { label: 'Node 0-0-1', key: '0-0-1', mapped: true },
+              { label: 'Node 0-0-2', key: '0-0-2', mapped: true },
+            ],
+          },
+          {
+            label: 'Node 0-1',
+            key: '0-1',
+            mapped: true,
+            children: [
+              { label: 'Node 0-1-0', key: '0-1-0', mapped: true },
+              { label: 'Node 0-1-1', key: '0-1-1', mapped: true },
+              { label: 'Node 0-1-2', key: '0-1-2', mapped: true },
+            ],
+          },
+        ],
+      },
+      { label: 'Node 1', key: '1', mapped: true },
+    ])
+  })
+
+  test('filterTree work with straytegy or work', () => {
+    expect(
+      filterTree(
+        treeData,
+        'children',
+        (item, parents) => {
+          expect(parents.map(parent => parent.key)).toEqual(treeDataParentsMap.get(item.key))
+          expect(parents.every(parent => parent.label === `Node ${parent.key}`)).toBeTruthy()
+          return /1/.test(item.label)
+        },
+        'or',
+      ),
+    ).toEqual([
+      {
+        label: 'Node 0',
+        key: '0',
+        children: [
+          {
+            label: 'Node 0-0',
+            key: '0-0',
+            children: [{ label: 'Node 0-0-1', key: '0-0-1' }],
+          },
+          {
+            label: 'Node 0-1',
+            key: '0-1',
+            children: [
+              { label: 'Node 0-1-0', key: '0-1-0' },
+              { label: 'Node 0-1-1', key: '0-1-1' },
+              { label: 'Node 0-1-2', key: '0-1-2' },
+            ],
+          },
+        ],
+      },
+      { label: 'Node 1', key: '1' },
+    ])
+  })
+
+  test('filterTree work with straytegy and work', () => {
+    expect(
+      filterTree(
+        treeData,
+        'children',
+        (item, parents) => {
+          expect(parents.map(parent => parent.key)).toEqual(treeDataParentsMap.get(item.key))
+          expect(parents.every(parent => parent.label === `Node ${parent.key}`)).toBeTruthy()
+          return /1/.test(item.label)
+        },
+        'and',
+      ),
+    ).toEqual([{ label: 'Node 1', key: '1' }])
+  })
+
+  test('mergeTree work', () => {
+    interface TargetData extends Data {
+      overidden?: boolean
+      children?: TargetData[]
+    }
+
+    expect(
+      mergeTree(
+        treeData,
+        [
+          {
+            label: 'Node 0',
+            key: '0',
+            children: [
+              {
+                label: 'Node 0-0',
+                key: '0-0',
+                children: [
+                  { label: 'Node 0-0-1-overidden', key: '0-0-1', overidden: true },
+                  { label: 'Node 0-0-3', key: '0-0-3' },
+                ],
+              },
+              {
+                label: 'Node 0-1',
+                key: '0-1',
+                children: [{ label: 'Node 0-1-3', key: '0-1-3' }],
+              },
+            ],
+          },
+          { label: 'Node 2', key: '2' },
+        ] as TargetData[],
+        'children',
+        item => item.key,
+      ),
+    ).toEqual([
+      {
+        label: 'Node 0',
+        key: '0',
+        children: [
+          {
+            label: 'Node 0-0',
+            key: '0-0',
+            children: [
+              { label: 'Node 0-0-0', key: '0-0-0' },
+              { label: 'Node 0-0-1-overidden', key: '0-0-1', overidden: true },
+              { label: 'Node 0-0-2', key: '0-0-2' },
+              { label: 'Node 0-0-3', key: '0-0-3' },
+            ],
+          },
+          {
+            label: 'Node 0-1',
+            key: '0-1',
+            children: [
+              { label: 'Node 0-1-0', key: '0-1-0' },
+              { label: 'Node 0-1-1', key: '0-1-1' },
+              { label: 'Node 0-1-2', key: '0-1-2' },
+              { label: 'Node 0-1-3', key: '0-1-3' },
+            ],
+          },
+        ],
+      },
+      { label: 'Node 1', key: '1' },
+      { label: 'Node 2', key: '2' },
+    ])
+  })
+
+  test('flattenTree work', () => {
+    expect(flattenTree(treeData, 'children').map(item => item.key)).toEqual(treeDataKeys)
+  })
+  test('flattenTree with Map work', () => {
+    const flattenedTree = flattenTree(treeData, 'children', item => ({ ...item, mapped: true }))
+    expect(flattenedTree.map(item => item.key)).toEqual(treeDataKeys)
+    expect(flattenedTree.every(item => item.mapped)).toBeTruthy()
+  })
+  test('flattenTree with leafOnly work', () => {
+    expect(flattenTree(treeData, 'children', undefined, true).map(item => item.key)).toEqual([
+      '0-0-0',
+      '0-0-1',
+      '0-0-2',
+      '0-1-0',
+      '0-1-1',
+      '0-1-2',
+      '1',
+    ])
+  })
+
+  test('getTreeKeys work', () => {
+    expect(getTreeKeys(treeData, 'children', item => item.key)).toEqual(treeDataKeys)
+  })
+  test('getTreeKeys with leafOnly work', () => {
+    expect(getTreeKeys(treeData, 'children', item => item.key, true)).toEqual([
+      '0-0-0',
+      '0-0-1',
+      '0-0-2',
+      '0-1-0',
+      '0-1-1',
+      '0-1-2',
+      '1',
+    ])
+  })
+})
diff --git a/packages/cdk/utils/index.ts b/packages/cdk/utils/index.ts
index 7ea3562c7..73d848462 100644
--- a/packages/cdk/utils/index.ts
+++ b/packages/cdk/utils/index.ts
@@ -18,3 +18,4 @@ export * from './src/typeof'
 export * from './src/uniqueId'
 export * from './src/useEventListener'
 export * from './src/vNode'
+export * from './src/tree'
diff --git a/packages/cdk/utils/src/tree.ts b/packages/cdk/utils/src/tree.ts
new file mode 100644
index 000000000..0a0c3185d
--- /dev/null
+++ b/packages/cdk/utils/src/tree.ts
@@ -0,0 +1,188 @@
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/IDuxFE/idux/blob/main/LICENSE
+ */
+
+import type { VKey } from './props'
+
+import { isArray, isNil } from 'lodash-es'
+
+export type TreeTypeData<V extends object, C extends VKey> = {
+  [key in C]?: (TreeTypeData<V, C> & V)[]
+}
+
+export function traverseTree<V extends TreeTypeData<V, C>, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  fn: (item: V, parents: V[]) => void,
+  traverseStrategy: 'pre' | 'post' = 'pre',
+): void {
+  const traverse = (_data: V[], parents: V[]) => {
+    for (let idx = 0; idx < _data.length; idx++) {
+      const item = _data[idx]
+      traverseStrategy === 'pre' && fn(item, parents)
+      if (item[childrenKey]) {
+        traverse(item[childrenKey]!, [item, ...parents])
+      }
+      traverseStrategy === 'post' && fn(item, parents)
+    }
+  }
+
+  traverse(data, [])
+}
+
+export function mapTree<V extends TreeTypeData<V, C>, R extends object, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  mapFn: (item: V, parents: V[]) => R | undefined,
+): (R & TreeTypeData<R, C>)[] {
+  const map = (_data: V[], parents: V[]) => {
+    const res: (TreeTypeData<R, C> & R)[] = []
+    for (let idx = 0; idx < _data.length; idx++) {
+      const item = _data[idx]
+      const mappedItem = mapFn(item, parents) as R & TreeTypeData<R, C>
+      if (!mappedItem) {
+        continue
+      }
+
+      if (item[childrenKey]) {
+        const mappedChildren = map(item[childrenKey]!, [item, ...parents])
+        ;(mappedItem[childrenKey] as (R & TreeTypeData<R, C>)[]) = mappedChildren
+      }
+
+      res.push(mappedItem)
+    }
+
+    return res
+  }
+  return map(data, [])
+}
+
+export function filterTree<V extends TreeTypeData<V, C>, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  filterFn: (item: V, parents: V[]) => boolean,
+  filterStrategy: 'and' | 'or' = 'or',
+): V[] {
+  const filter = (_data: V[], parents: V[]): V[] => {
+    const res: V[] = []
+    for (let idx = 0; idx < _data.length; idx++) {
+      let children: V[] | undefined
+      const item = _data[idx]
+
+      if (item[childrenKey]) {
+        children = filter(item[childrenKey]!, [item, ...parents])
+      }
+
+      let itemValid = filterFn(item, parents)
+      const childrenValid = (children && children.length > 0) || (!item[childrenKey]?.length && itemValid)
+
+      itemValid = filterStrategy === 'and' ? childrenValid && itemValid : childrenValid || itemValid
+
+      if (itemValid) {
+        res.push({
+          ...item,
+          [childrenKey]: item[childrenKey] && children,
+        })
+      }
+    }
+
+    return res
+  }
+
+  return filter(data, [])
+}
+
+export function mergeTree<V extends TreeTypeData<V, C>, R extends V, C extends keyof V | keyof R>(
+  originalTree: V[],
+  overideTree: R[],
+  childrenKey: C,
+  getKey: (item: V) => VKey,
+): (V & Partial<R>)[] {
+  const result = originalTree.map(item => ({ ...item })) as (V & Partial<R>)[]
+  for (const overideItem of overideTree) {
+    const originalItem = result.find(item => {
+      const overideItemKey = getKey(overideItem)
+      const originalItemKey = getKey(item)
+
+      return !isNil(overideItemKey) && !isNil(originalItemKey) && overideItemKey === originalItemKey
+    })
+
+    if (!originalItem) {
+      result.push({ ...overideItem })
+      continue
+    }
+
+    for (const key of [
+      ...Object.getOwnPropertyNames(overideItem),
+      ...Object.getOwnPropertySymbols(overideItem),
+    ] as (keyof R)[]) {
+      if (key === childrenKey) {
+        continue
+      }
+
+      originalItem[key] = overideItem[key]
+    }
+
+    if (isArray(overideItem[childrenKey])) {
+      originalItem[childrenKey] = mergeTree(
+        originalItem[childrenKey] ?? [],
+        overideItem[childrenKey]!,
+        childrenKey,
+        getKey,
+      ) as (V & Partial<R>)[C]
+    }
+  }
+
+  return result
+}
+
+export function flattenTree<V extends TreeTypeData<V, C>, C extends keyof V>(data: V[], childrenKey: C): V[]
+export function flattenTree<V extends TreeTypeData<V, C>, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  mapFn: undefined,
+  leafOnly?: boolean,
+): V[]
+export function flattenTree<V extends TreeTypeData<V, C>, R extends object, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  mapFn: (item: V) => R,
+  leafOnly?: boolean,
+): (R & TreeTypeData<R, C>)[]
+export function flattenTree<V extends TreeTypeData<V, C>, R extends object, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  mapFn?: (item: V) => R,
+  leafOnly = false,
+): V[] | (R & TreeTypeData<R, C>)[] {
+  const res: V[] | (R & TreeTypeData<R, C>)[] = []
+
+  traverseTree(data, childrenKey, item => {
+    if (!leafOnly || !item[childrenKey] || item[childrenKey]!.length <= 0) {
+      const mappedItem = mapFn ? mapFn(item) : item
+      mappedItem && res.push(mappedItem as V & (R & TreeTypeData<R, C>))
+    }
+  })
+
+  return res
+}
+
+export function getTreeKeys<V extends TreeTypeData<V, C>, C extends keyof V>(
+  data: V[],
+  childrenKey: C,
+  getKey: (item: V) => VKey,
+  leafOnly = false,
+): VKey[] {
+  const keys: VKey[] = []
+
+  traverseTree(data, childrenKey, item => {
+    if (!leafOnly || !item[childrenKey]?.length) {
+      keys.push(getKey(item))
+    }
+  })
+
+  return keys
+}
diff --git a/packages/components/transfer/src/composables/useTransferSelectState.ts b/packages/components/transfer/src/composables/useTransferSelectState.ts
index e8ac61c2d..467ac45d5 100644
--- a/packages/components/transfer/src/composables/useTransferSelectState.ts
+++ b/packages/components/transfer/src/composables/useTransferSelectState.ts
@@ -47,6 +47,7 @@ export function useTransferSelectState(
 
   const {
     dataKeyMap,
+    dataSource,
     sourceData,
     targetData,
     sourceDataKeys,
@@ -187,7 +188,7 @@ export function useTransferSelectState(
       return
     }
 
-    const data = isSource ? sourceData.value : targetData.value
+    const data = isSource ? (props.mode === 'default' ? sourceData.value : dataSource.value) : targetData.value
     const _disabledKeys = isSource ? (props.mode === 'default' ? disabledSourceKeys : disabledKeys) : disabledTargetKeys
     const selectedKeySet = isSource ? sourceSelectedKeySet : targetSelectedKeySet
     const setSelectedKeys = isSource ? setSourceSelectedKeys : setTargetSelectedKeys
diff --git a/packages/components/utils/index.ts b/packages/components/utils/index.ts
index b3110daa2..40faef9ea 100644
--- a/packages/components/utils/index.ts
+++ b/packages/components/utils/index.ts
@@ -11,4 +11,5 @@ export * from './src/convertVNode'
 export * from './src/portalTarget'
 export * from './src/useDisabled'
 export * from './src/useKey'
+export * from './src/useTreeCheckStateResolver'
 export * from './src/zIndex'
diff --git a/packages/components/utils/src/useTreeCheckStateResolver.ts b/packages/components/utils/src/useTreeCheckStateResolver.ts
new file mode 100644
index 000000000..0bb8b47c2
--- /dev/null
+++ b/packages/components/utils/src/useTreeCheckStateResolver.ts
@@ -0,0 +1,282 @@
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/IDuxFE/idux/blob/main/LICENSE
+ */
+
+import { type Ref, computed } from 'vue'
+
+import { isArray, isObject } from 'lodash-es'
+
+import { type TreeTypeData, type VKey, getTreeKeys, traverseTree } from '@idux/cdk/utils'
+
+interface GetAllCheckedKeys<V extends TreeTypeData<V, C>, C extends keyof V> {
+  (data: V[]): VKey[]
+  (defaultUnCheckedKeys: VKey[]): VKey[]
+  (data: V[], defaultUnCheckedKeys: VKey[]): VKey[]
+}
+interface GetAllUncheckedKeys<V extends TreeTypeData<V, C>, C extends keyof V> {
+  (data: V[]): VKey[]
+  (defaultCheckedKeys: VKey[]): VKey[]
+  (data: V[], defaultCheckedKeys: VKey[]): VKey[]
+}
+
+export interface TreeCheckStateResolverContext<V extends TreeTypeData<V, C>, C extends keyof V> {
+  data: V[] | undefined
+  dataMap: Map<VKey, V>
+  parentKeyMap: Map<VKey, VKey>
+  depthMap: Map<VKey, number>
+}
+export interface TreeCheckStateResolver<V extends TreeTypeData<V, C>, C extends keyof V> {
+  appendKeys: (checkedKeys: VKey[] | Set<VKey>, appendedKeys: VKey[]) => VKey[]
+  removeKeys: (checkedKeys: VKey[] | Set<VKey>, removedKeys: VKey[]) => VKey[]
+
+  getAllCheckedKeys: GetAllCheckedKeys<V, C>
+  getAllUncheckedKeys: GetAllUncheckedKeys<V, C>
+}
+export type TreeCascadeStrategy = 'all' | 'child' | 'parent' | 'off'
+
+export function useTreeCheckStateResolver<V extends TreeTypeData<V, C>, C extends keyof V>(
+  data: Ref<V[]>,
+  childrenKey: Ref<C>,
+  getKey: Ref<(item: V) => VKey>,
+  cascadeStrategy?: Ref<TreeCascadeStrategy>,
+): TreeCheckStateResolver<V, C>
+export function useTreeCheckStateResolver<V extends TreeTypeData<V, C>, C extends keyof V>(
+  context: Ref<TreeCheckStateResolverContext<V, C>>,
+  childrenKey: Ref<C>,
+  getKey: Ref<(item: V) => VKey>,
+  cascadeStrategy?: Ref<TreeCascadeStrategy>,
+): TreeCheckStateResolver<V, C>
+export function useTreeCheckStateResolver<V extends TreeTypeData<V, C>, C extends keyof V>(
+  dataOrContext: Ref<V[] | TreeCheckStateResolverContext<V, C>>,
+  childrenKey: Ref<C>,
+  getKey: Ref<(item: V) => VKey>,
+  cascadeStrategy?: Ref<TreeCascadeStrategy>,
+): TreeCheckStateResolver<V, C> {
+  const _getContext = (
+    dataOrContext: V[] | TreeCheckStateResolverContext<V, C>,
+  ): TreeCheckStateResolverContext<V, C> => {
+    if (!isArray(dataOrContext)) {
+      return dataOrContext
+    }
+
+    const dataMap = new Map<VKey, V>()
+    const parentKeyMap = new Map<VKey, VKey>()
+    const depthMap = new Map<VKey, number>()
+
+    traverseTree(dataOrContext, childrenKey.value, (item, parents) => {
+      const key = getKey.value(item)
+      const parent = parents[0]
+      dataMap.set(key, item)
+      depthMap.set(key, parents.length)
+
+      if (parent) {
+        parentKeyMap.set(key, getKey.value(parent))
+      }
+    })
+
+    return {
+      data: dataOrContext,
+      dataMap,
+      parentKeyMap,
+      depthMap,
+    }
+  }
+
+  const mergedCascadeStrategy = computed(() => cascadeStrategy?.value ?? 'all')
+  const _context = computed(() => _getContext(dataOrContext.value))
+
+  const _getParents = (key: VKey, resolverContext: TreeCheckStateResolverContext<V, C>) => {
+    const { parentKeyMap, dataMap } = resolverContext
+    const parents: V[] = []
+
+    let currentKey = key
+    while (parentKeyMap.has(currentKey)) {
+      const parentKey = parentKeyMap.get(currentKey)!
+      const parent = dataMap.get(parentKey)
+      parent && parents.push(parent)
+      currentKey = parentKey
+    }
+    return parents
+  }
+  const _getAllData = () => {
+    const { data, parentKeyMap, dataMap } = _context.value
+    if (data) {
+      return data
+    }
+
+    const _data: V[] = []
+    for (const key of parentKeyMap.keys()) {
+      if (!parentKeyMap.has(key) && dataMap.has(key)) {
+        _data.push(dataMap.get(key)!)
+      }
+    }
+
+    return _data
+  }
+
+  const _append = (
+    checkedKeys: VKey[] | Set<VKey>,
+    appendedKeys: VKey[],
+    resolverContext: TreeCheckStateResolverContext<V, C>,
+  ) => {
+    if (!appendedKeys.length) {
+      return Array.from(checkedKeys)
+    }
+
+    if (mergedCascadeStrategy.value === 'off') {
+      return Array.from(new Set([...checkedKeys, ...appendedKeys]))
+    }
+
+    const { dataMap } = resolverContext
+
+    const newKeySet = new Set(checkedKeys)
+    appendedKeys.forEach(key => {
+      if (!dataMap.has(key)) {
+        return
+      }
+
+      const treeData = dataMap.get(key)!
+      getTreeKeys([treeData], childrenKey.value, getKey.value, mergedCascadeStrategy.value === 'child').forEach(key => {
+        newKeySet.add(key)
+      })
+    })
+
+    if (mergedCascadeStrategy.value === 'child') {
+      return Array.from(newKeySet).filter(key => !dataMap.get(key)?.[childrenKey.value]?.length)
+    }
+
+    appendedKeys.forEach(key => {
+      _getParents(key, resolverContext).forEach(parent => {
+        if (parent[childrenKey.value]?.every(child => newKeySet.has(getKey.value(child)))) {
+          newKeySet.add(key)
+        }
+      })
+    })
+
+    if (mergedCascadeStrategy.value === 'all') {
+      return Array.from(newKeySet)
+    }
+
+    newKeySet.forEach(key => {
+      if (!newKeySet.has(key)) {
+        return
+      }
+
+      const children = dataMap.get(key)?.[childrenKey.value]
+      if (children) {
+        traverseTree(children, childrenKey.value, item => {
+          newKeySet.delete(getKey.value(item))
+        })
+      }
+    })
+
+    return Array.from(newKeySet)
+  }
+  const _remove = (
+    checkedKeys: VKey[] | Set<VKey>,
+    removedKeys: VKey[],
+    resolverContext: TreeCheckStateResolverContext<V, C>,
+  ) => {
+    if (!removedKeys.length) {
+      return Array.from(checkedKeys)
+    }
+
+    const newKeySet = new Set(checkedKeys)
+    if (mergedCascadeStrategy.value === 'off') {
+      removedKeys.forEach(key => {
+        newKeySet.delete(key)
+      })
+      return Array.from(newKeySet)
+    }
+
+    const { dataMap } = resolverContext
+
+    const deletedKeys = new Set()
+    // store already deleted keys
+    const deleteKey = (key: VKey) => {
+      deletedKeys.add(key)
+      newKeySet.delete(key)
+    }
+
+    removedKeys.forEach(key => {
+      if (!dataMap.has(key)) {
+        return
+      }
+
+      getTreeKeys([dataMap.get(key)!], childrenKey.value, getKey.value).forEach(key => {
+        deleteKey(key)
+      })
+
+      const parents = _getParents(key, resolverContext)
+
+      if (mergedCascadeStrategy.value === 'parent') {
+        const keysInChain = [key, ...parents.map(getKey.value)]
+        const selectedKeyIdx = keysInChain.findIndex(key => newKeySet.has(key))
+
+        // if one of the ancestors was selected
+        // replace parent node with child nodes
+        if (selectedKeyIdx > -1) {
+          // only travers chain from selected node to the bottom
+          parents.slice(0, selectedKeyIdx).forEach(parent => {
+            if (!parent[childrenKey.value]) {
+              return
+            }
+
+            parent[childrenKey.value]!.forEach(child => {
+              const childKey = getKey.value(child)
+              // add only if the child node hasn't been deleted before
+              if (!deletedKeys.has(childKey)) {
+                newKeySet.add(childKey)
+              }
+            })
+
+            deleteKey(getKey.value(parent))
+          })
+        }
+      } else {
+        parents.forEach(parent => {
+          deleteKey(getKey.value(parent))
+        })
+      }
+    })
+    return Array.from(newKeySet)
+  }
+  const appendKeys = (checkedKeys: VKey[] | Set<VKey>, appendedKeys: VKey[]) =>
+    _append(checkedKeys, appendedKeys, _context.value)
+  const removeKeys = (checkedKeys: VKey[] | Set<VKey>, removedKeys: VKey[]) =>
+    _remove(checkedKeys, removedKeys, _context.value)
+
+  const _getAllCheckedKeys = (data: V[] | undefined, defaultUnCheckedKeys: VKey[]) => {
+    const _data = data ?? _getAllData()
+    const tempKeys =
+      mergedCascadeStrategy.value === 'parent'
+        ? _data.map(getKey.value)
+        : new Set(getTreeKeys(_data, childrenKey.value, getKey.value, mergedCascadeStrategy.value === 'child'))
+
+    return _remove(tempKeys, defaultUnCheckedKeys, data ? _getContext(data) : _context.value)
+  }
+  const _getAllUncheckedKeys = (data: V[] | undefined, defaultCheckedKeys: VKey[]) => {
+    return _append([], defaultCheckedKeys, data ? _getContext(data) : _context.value)
+  }
+
+  const getAllCheckedKeys = (data?: V[] | VKey[], defaultUnCheckedKeys?: VKey[]) => {
+    const dataProvided = ((data?: V[] | VKey[]): data is V[] => isObject(data?.[0]))(data)
+
+    return _getAllCheckedKeys(dataProvided ? data : undefined, defaultUnCheckedKeys ?? (dataProvided ? [] : data ?? []))
+  }
+  const getAllUncheckedKeys = (data?: V[] | VKey[], defaultCheckedKeys?: VKey[]) => {
+    const dataProvided = ((data?: V[] | VKey[]): data is V[] => isObject(data?.[0]))(data)
+
+    return _getAllUncheckedKeys(dataProvided ? data : undefined, defaultCheckedKeys ?? (dataProvided ? [] : data ?? []))
+  }
+
+  return {
+    appendKeys,
+    removeKeys,
+    getAllCheckedKeys,
+    getAllUncheckedKeys,
+  }
+}
diff --git a/packages/pro/transfer/__tests__/proTransfer.spec.ts b/packages/pro/transfer/__tests__/proTransfer.spec.ts
index aa483d7cb..b41286655 100644
--- a/packages/pro/transfer/__tests__/proTransfer.spec.ts
+++ b/packages/pro/transfer/__tests__/proTransfer.spec.ts
@@ -7,12 +7,13 @@ import { IxTransferList } from '@idux/components/transfer'
 import TransferOperations from '@idux/components/transfer/src/TransferOperations'
 
 import ProTransfer from '../src/ProTransfer'
-import { ProTransferProps, TreeTransferData } from '../src/types'
+import { ProTransferProps, TransferData } from '../src/types'
 
-interface Data extends TreeTransferData<'children'> {
+interface Data extends TransferData {
   key: string
   label: string
   disabled?: boolean
+  children?: Data[]
 }
 
 const createData = (idx: number, includeDisabled = true): Data => ({
@@ -201,14 +202,14 @@ describe('ProTransfer', () => {
     await sourceTree.findAll('.ix-tree-node')[0].find('input').setValue(true)
     await appendTrigger.trigger('click')
 
-    expect(onChange).toBeCalledWith(['1-2-2', '1', '1-1', '1-2', '1-2-1', '1-3'], ['1-2-2'])
+    expect(onChange).toBeCalledWith(['1-2-2', '1', '1-2', '1-2-1', '1-1', '1-3'], ['1-2-2'])
 
-    await wrapper.setProps({ value: ['1-2-2', '1', '1-1', '1-2', '1-2-1', '1-3'] })
+    await wrapper.setProps({ value: ['1-2-2', '1', '1-2', '1-2-1', '1-1', '1-3'] })
 
     await targetTree.findAll('.ix-tree-node')[0].find('input').setValue(true)
     await removeTrigger.trigger('click')
 
-    expect(onChange).toBeCalledWith(['1-2-2'], ['1-2-2', '1', '1-1', '1-2', '1-2-1', '1-3'])
+    expect(onChange).toBeCalledWith(['1-2-2'], ['1-2-2', '1', '1-2', '1-2-1', '1-1', '1-3'])
   })
 
   test('table immediate work', async () => {
diff --git a/packages/pro/transfer/demo/BasicTable.vue b/packages/pro/transfer/demo/BasicTable.vue
index 55301e7c2..d6cebd310 100644
--- a/packages/pro/transfer/demo/BasicTable.vue
+++ b/packages/pro/transfer/demo/BasicTable.vue
@@ -9,11 +9,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/BasicTree.vue b/packages/pro/transfer/demo/BasicTree.vue
index 0f5f604ec..6563967c4 100644
--- a/packages/pro/transfer/demo/BasicTree.vue
+++ b/packages/pro/transfer/demo/BasicTree.vue
@@ -3,9 +3,11 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
diff --git a/packages/pro/transfer/demo/FlattenTree.vue b/packages/pro/transfer/demo/FlattenTree.vue
index d79759b74..a69b29761 100644
--- a/packages/pro/transfer/demo/FlattenTree.vue
+++ b/packages/pro/transfer/demo/FlattenTree.vue
@@ -3,9 +3,11 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
diff --git a/packages/pro/transfer/demo/TableCustomLabel.vue b/packages/pro/transfer/demo/TableCustomLabel.vue
index 79728659c..b83a666dd 100644
--- a/packages/pro/transfer/demo/TableCustomLabel.vue
+++ b/packages/pro/transfer/demo/TableCustomLabel.vue
@@ -19,11 +19,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TableMaxSelectedCnt.vue b/packages/pro/transfer/demo/TableMaxSelectedCnt.vue
index 40a490f85..821b7746f 100644
--- a/packages/pro/transfer/demo/TableMaxSelectedCnt.vue
+++ b/packages/pro/transfer/demo/TableMaxSelectedCnt.vue
@@ -11,11 +11,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TableOneWay.vue b/packages/pro/transfer/demo/TableOneWay.vue
index c2b397ee2..55f09bc59 100644
--- a/packages/pro/transfer/demo/TableOneWay.vue
+++ b/packages/pro/transfer/demo/TableOneWay.vue
@@ -10,11 +10,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TablePagination.vue b/packages/pro/transfer/demo/TablePagination.vue
index a0e8d38a8..10a05986e 100644
--- a/packages/pro/transfer/demo/TablePagination.vue
+++ b/packages/pro/transfer/demo/TablePagination.vue
@@ -10,11 +10,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TableRemote.vue b/packages/pro/transfer/demo/TableRemote.vue
index bfeee424c..c43d16dd6 100644
--- a/packages/pro/transfer/demo/TableRemote.vue
+++ b/packages/pro/transfer/demo/TableRemote.vue
@@ -17,12 +17,13 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData, TransferPaginationProps } from '@idux/components/transfer'
+
 import { computed, onMounted, ref } from 'vue'
 
 import { TableColumn } from '@idux/components/table'
-import { TransferPaginationProps } from '@idux/components/transfer'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TableVirtual.vue b/packages/pro/transfer/demo/TableVirtual.vue
index 2c13df121..45af022cd 100644
--- a/packages/pro/transfer/demo/TableVirtual.vue
+++ b/packages/pro/transfer/demo/TableVirtual.vue
@@ -19,12 +19,12 @@
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
+import type { TableColumn } from '@idux/components/table'
+import type { ProTransferInstance, TransferData } from '@idux/pro/transfer'
 
-import { TableColumn } from '@idux/components/table'
-import { ProTransferInstance } from '@idux/pro/transfer'
+import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: number
   disabled: boolean
   name: string
diff --git a/packages/pro/transfer/demo/TreeCascaderStrategy.vue b/packages/pro/transfer/demo/TreeCascaderStrategy.vue
index ec8cf0fa3..da41b6864 100644
--- a/packages/pro/transfer/demo/TreeCascaderStrategy.vue
+++ b/packages/pro/transfer/demo/TreeCascaderStrategy.vue
@@ -18,10 +18,11 @@
 
 <script setup lang="ts">
 import type { CascaderStrategy } from '@idux/components/cascader'
+import type { TransferData } from '@idux/pro/transfer'
 
 import { ref, watch } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
@@ -80,7 +81,7 @@ const dataSource: Data[] = [
             children: [
               {
                 key: '1-3-2-1',
-                disabled: false,
+                disabled: true,
                 label: 'Selection-1-3-2-1',
               },
               {
diff --git a/packages/pro/transfer/demo/TreeCustomLabel.vue b/packages/pro/transfer/demo/TreeCustomLabel.vue
index fb368b521..170375127 100644
--- a/packages/pro/transfer/demo/TreeCustomLabel.vue
+++ b/packages/pro/transfer/demo/TreeCustomLabel.vue
@@ -13,9 +13,11 @@
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
diff --git a/packages/pro/transfer/demo/TreeLoadChildren.vue b/packages/pro/transfer/demo/TreeLoadChildren.vue
index f0922ed30..7057d067f 100644
--- a/packages/pro/transfer/demo/TreeLoadChildren.vue
+++ b/packages/pro/transfer/demo/TreeLoadChildren.vue
@@ -9,18 +9,20 @@
 </template>
 
 <script setup lang="ts">
+import type { TreeNode } from '@idux/components/tree'
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
   children?: Data[]
-  isLeaf?: boolean
 }
 
 const targetKeys = ref<string[]>([])
-const loadChildren = (node: Data) => {
+const loadChildren = ((node: Data) => {
   const depth = node.key.split('-').length
   if (depth > 2) {
     return
@@ -41,7 +43,7 @@ const loadChildren = (node: Data) => {
       1000,
     )
   })
-}
+}) as (node: TreeNode) => Promise<TreeNode[]>
 
 const dataSource: Data[] = [
   {
diff --git a/packages/pro/transfer/demo/TreeOneWay.vue b/packages/pro/transfer/demo/TreeOneWay.vue
index 4e5855ee3..59b076685 100644
--- a/packages/pro/transfer/demo/TreeOneWay.vue
+++ b/packages/pro/transfer/demo/TreeOneWay.vue
@@ -1,18 +1,31 @@
 <template>
-  <IxProTransfer v-model:value="targetKeys" type="tree" :data-source="dataSource" mode="immediate" />
+  <IxProTransfer
+    v-model:value="targetKeys"
+    searchable
+    :search-fn="searchFn"
+    type="tree"
+    :data-source="dataSource"
+    mode="immediate"
+  />
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+const targetKeys = ref<string[]>(['1-2', '1-2-1', '1-2-2', '1-3-2-1', '2'])
+
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
   children?: Data[]
 }
 
-const targetKeys = ref<string[]>(['1-2', '1-2-1', '1-2-2', '1-3-2-1', '2'])
+const searchFn = (_: boolean, item: unknown, searchValue: string | undefined) => {
+  return !searchValue || (item as Data).label.indexOf(searchValue) > -1
+}
 
 const dataSource: Data[] = [
   {
@@ -28,7 +41,7 @@ const dataSource: Data[] = [
       {
         key: '1-2',
         disabled: false,
-        label: 'Selection-1-2',
+        label: 'Selection-1-2-parent',
         children: [
           {
             key: '1-2-1',
diff --git a/packages/pro/transfer/demo/TreePagination.vue b/packages/pro/transfer/demo/TreePagination.vue
index dfe720d30..dfdb67c6b 100644
--- a/packages/pro/transfer/demo/TreePagination.vue
+++ b/packages/pro/transfer/demo/TreePagination.vue
@@ -1,11 +1,21 @@
 <template>
-  <IxProTransfer v-model:value="targetKeys" type="tree" pagination :data-source="dataSource" />
+  <IxProTransfer
+    v-model:value="targetKeys"
+    searchable
+    :search-fn="searchFn"
+    type="tree"
+    mode="immediate"
+    pagination
+    :data-source="dataSource"
+  />
 </template>
 
 <script setup lang="ts">
+import type { TransferData } from '@idux/pro/transfer'
+
 import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
@@ -14,6 +24,10 @@ interface Data {
 
 const targetKeys = ref<string[]>(['1-2', '1-2-1', '1-2-2'])
 
+const searchFn = (_: boolean, item: unknown, searchValue: string | undefined) => {
+  return !searchValue || (item as Data).label.indexOf(searchValue) > -1
+}
+
 const dataSource: Data[] = Array.from(new Array(50)).map((_, idx) => ({
   key: `${idx}`,
   disabled: false,
diff --git a/packages/pro/transfer/demo/TreeRemote.vue b/packages/pro/transfer/demo/TreeRemote.vue
index 9c11db85e..22ae51960 100644
--- a/packages/pro/transfer/demo/TreeRemote.vue
+++ b/packages/pro/transfer/demo/TreeRemote.vue
@@ -14,11 +14,11 @@
 </template>
 
 <script setup lang="ts">
-import type { TransferPaginationProps } from '@idux/components/transfer'
+import type { TransferData, TransferPaginationProps } from '@idux/components/transfer'
 
 import { computed, onMounted, ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   label: string
   disabled?: boolean
diff --git a/packages/pro/transfer/demo/TreeVirtual.vue b/packages/pro/transfer/demo/TreeVirtual.vue
index edeb927de..b04f631bb 100644
--- a/packages/pro/transfer/demo/TreeVirtual.vue
+++ b/packages/pro/transfer/demo/TreeVirtual.vue
@@ -11,11 +11,11 @@
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
+import type { ProTransferInstance, TransferData } from '@idux/pro/transfer'
 
-import { ProTransferInstance } from '@idux/pro/transfer'
+import { ref } from 'vue'
 
-interface Data {
+interface Data extends TransferData {
   key: string
   disabled: boolean
   label: string
diff --git a/packages/pro/transfer/src/composables/useTransferData.ts b/packages/pro/transfer/src/composables/useTransferData.ts
index 95d3b8635..2209cea24 100644
--- a/packages/pro/transfer/src/composables/useTransferData.ts
+++ b/packages/pro/transfer/src/composables/useTransferData.ts
@@ -11,9 +11,7 @@ import type { GetKeyFn } from '@idux/components/utils'
 
 import { type ComputedRef, computed, reactive } from 'vue'
 
-import { type VKey, callEmit } from '@idux/cdk/utils'
-
-import { traverseTree } from '../utils'
+import { type VKey, callEmit, traverseTree } from '@idux/cdk/utils'
 
 export type TransferTreeLoadChildren = ComputedRef<((node: TreeNode<VKey>) => Promise<TreeNode<VKey>[]>) | undefined>
 
@@ -23,7 +21,7 @@ export interface TransferDataContext {
   loadTargetChildren: TransferTreeLoadChildren
 }
 
-export function useTransferData<C extends VKey>(
+export function useTransferData<V extends TreeTransferData<V, C>, C extends string>(
   props: ProTransferProps,
   getKey: ComputedRef<GetKeyFn>,
   childrenKey: ComputedRef<C>,
@@ -34,7 +32,7 @@ export function useTransferData<C extends VKey>(
   handleSourceExpandedChange?: (keys: VKey[]) => void,
   handleTargetExpandedChange?: (keys: VKey[]) => void,
 ): TransferDataContext {
-  const loadedChildrenMap = reactive(new Map<VKey, TreeTransferData<C>[]>())
+  const loadedChildrenMap = reactive(new Map<VKey, TreeTransferData<V, C>[]>())
 
   const setExpanded = (key: VKey, isSource: boolean) => {
     const expandedKeys = isSource ? sourceExpandedKeys?.value : targetExpandedKeys?.value
@@ -49,7 +47,7 @@ export function useTransferData<C extends VKey>(
     }
   }
 
-  const mergeData = (data: TreeTransferData<C>[]): TreeTransferData<C>[] => {
+  const mergeData = (data: TreeTransferData<V, C>[]): TreeTransferData<V, C>[] => {
     const _childrenKey = childrenKey.value
 
     return data.map(item => {
@@ -57,11 +55,11 @@ export function useTransferData<C extends VKey>(
       const loadedChildren = loadedChildrenMap.get(getKey.value(item))
 
       if (loadedChildren) {
-        mappedItem[_childrenKey] = loadedChildren as TreeTransferData<C>[C]
+        mappedItem[_childrenKey] = loadedChildren as TreeTransferData<V, C>[C]
       }
 
       if (mappedItem[_childrenKey] && mappedItem[_childrenKey]!.length > 0) {
-        mappedItem[_childrenKey] = mergeData(mappedItem[_childrenKey]!) as TreeTransferData<C>[C]
+        mappedItem[_childrenKey] = mergeData(mappedItem[_childrenKey]!) as TreeTransferData<V, C>[C]
       }
 
       return mappedItem
@@ -73,7 +71,7 @@ export function useTransferData<C extends VKey>(
       return props.dataSource
     }
 
-    const data = mergeData(props.dataSource as TreeTransferData<C>[])
+    const data = mergeData(props.dataSource as TreeTransferData<V, C>[])
     return data
   })
 
@@ -89,7 +87,7 @@ export function useTransferData<C extends VKey>(
     }
 
     return async (node: TreeNode<VKey>, isSource: boolean) => {
-      const loadedData = (await _loadChildren(node as TreeTransferData<C>)) as TreeTransferData<C>[]
+      const loadedData = (await _loadChildren(node as TreeTransferData<V, C>)) as TreeTransferData<V, C>[]
       const key = getKey.value(node)
 
       if (!loadedData || loadedData.length <= 0) {
@@ -102,7 +100,7 @@ export function useTransferData<C extends VKey>(
       if (targetKeySet.value.has(key)) {
         const orignalKeys = Array.from(targetKeySet.value)
         const keySet = new Set(targetKeySet.value)
-        traverseTree<C>(loadedData, childrenKey.value, item => {
+        traverseTree(loadedData, childrenKey.value, item => {
           keySet.add(getKey.value(item))
         })
 
diff --git a/packages/pro/transfer/src/composables/useTransferTableProps.ts b/packages/pro/transfer/src/composables/useTransferTableProps.ts
index 0703c4d90..ceceecab0 100644
--- a/packages/pro/transfer/src/composables/useTransferTableProps.ts
+++ b/packages/pro/transfer/src/composables/useTransferTableProps.ts
@@ -26,8 +26,23 @@ export function useTransferTableProps(
 ): ComputedRef<TableProps> {
   const { paginatedData, paginatedDataSource, selectedKeys, getKey } = transferBindings
 
+  const convertedColumns = computed(() =>
+    convertTableColumns(
+      isSource ? props.tableProps?.sourceColumns : props.tableProps?.targetColumns,
+      mergedPrefixCls,
+      transferBindings,
+      props,
+      slots,
+      isSource,
+    ),
+  )
+
+  const onScroll: TableProps['onScroll'] = evt => callEmit(props.onScroll, isSource, evt)
+  const onScrolledChange: TableProps['onScrolledChange'] = (startIndex, endIndex, visibleData) =>
+    callEmit(props.onScrolledChange, isSource, startIndex, endIndex, visibleData)
+  const onScrolledBottom: TableProps['onScrolledBottom'] = () => callEmit(props.onScrolledBottom, isSource)
+
   return computed<TableProps>(() => {
-    const columns = isSource ? props.tableProps?.sourceColumns : props.tableProps?.targetColumns
     /* eslint-disable indent */
     const scroll = props.scroll?.height
       ? {
@@ -45,21 +60,15 @@ export function useTransferTableProps(
       autoHeight: !scroll,
       ...customTableProps,
       dataSource: isSource && props.mode === 'immediate' ? paginatedDataSource.value : paginatedData.value,
-      columns: convertTableColumns(columns, mergedPrefixCls, transferBindings, props, slots, isSource),
+      columns: convertedColumns.value,
       scroll,
       pagination: false,
       selectedRowKeys: selectedKeys.value,
       virtual: props.virtual,
       getKey: getKey.value as (record: unknown) => number | string,
-      onScroll: evt => {
-        callEmit(props.onScroll, isSource, evt)
-      },
-      onScrolledChange: (startIndex, endIndex, visibleData) => {
-        callEmit(props.onScrolledChange, isSource, startIndex, endIndex, visibleData)
-      },
-      onScrolledBottom: () => {
-        callEmit(props.onScrolledBottom, isSource)
-      },
+      onScroll,
+      onScrolledChange,
+      onScrolledBottom,
     }
   })
 }
diff --git a/packages/pro/transfer/src/composables/useTransferTreeProps.ts b/packages/pro/transfer/src/composables/useTransferTreeProps.ts
index 42fa83a1f..c9c6a7b8c 100644
--- a/packages/pro/transfer/src/composables/useTransferTreeProps.ts
+++ b/packages/pro/transfer/src/composables/useTransferTreeProps.ts
@@ -5,9 +5,8 @@
  * found in the LICENSE file at https://github.com/IDuxFE/idux/blob/main/LICENSE
  */
 
-import type { TransferTreeLoadChildren } from './useTransferData'
-import type { TreeExpandedKeysContext } from './useTreeExpandedKeys'
-import type { ProTransferProps, TransferData } from '../types'
+import type { TreeTransferContext } from '../token'
+import type { ProTransferProps, TransferData, TreeTransferData } from '../types'
 import type { TransferBindings } from '@idux/components/transfer'
 import type { TreeNode, TreeProps } from '@idux/components/tree'
 
@@ -15,30 +14,69 @@ import { type ComputedRef, computed } from 'vue'
 
 import { isNumber } from 'lodash-es'
 
-import { type VKey, callEmit } from '@idux/cdk/utils'
+import { type TreeTypeData, type VKey, callEmit, getTreeKeys } from '@idux/cdk/utils'
 
-export function useTransferTreeProps(
+export function useTransferTreeProps<V extends TreeTransferData<V, C>, C extends string>(
   props: ProTransferProps,
-  transferBindings: TransferBindings,
-  expandedKeysContext: TreeExpandedKeysContext,
-  childrenKey: ComputedRef<string>,
-  loadChildren: TransferTreeLoadChildren,
+  treeTransferContext: TreeTransferContext<V, C>,
+  transferBindings: TransferBindings<V>,
   isSource: boolean,
 ): ComputedRef<TreeProps> {
   const {
     paginatedData,
-    paginatedDataSource,
     selectedKeys,
+    searchValue,
+    pagination,
+    paginatedDataSource,
     disabledKeys,
     disabledDataSourceKeys,
     getKey,
     handleSelectChange,
   } = transferBindings
+  const {
+    cascaderStrategy,
+    childrenKey,
+    dataStrategyContext: { checkStateResolver },
+    expandedKeysContext,
+    loadSourceChildren,
+    loadTargetChildren,
+  } = treeTransferContext
   const { sourceExpandedKeys, targetExpandedKeys, handleSourceExpandedChange, handleTargetExpandedChange } =
     expandedKeysContext
 
   const _disabledKeys = isSource && props.mode === 'immediate' ? disabledDataSourceKeys : disabledKeys
   const treeDataSource = isSource && props.mode === 'immediate' ? paginatedDataSource : paginatedData
+  const loadChildren = isSource ? loadSourceChildren! : loadTargetChildren!
+
+  // when tree data is paginated or filtered,
+  // using internal checked keys logic will cause checked keys to change unexpectedly because checked keys won't be resolved by the whole tree but paginated or filtered tree
+  // then target keys could be miscalulated when mode is 'immediate'
+  // so we manage check state outside the tree component
+  const shouldUseExternalCheckStateResolver = computed(
+    () => props.mode === 'immediate' && (!!pagination.value || !!searchValue.value),
+  )
+
+  const handleChecked = (checked: boolean, node: TreeNode) => {
+    if (shouldUseExternalCheckStateResolver.value) {
+      const keys = getTreeKeys([node] as TreeTypeData<TreeNode, C>[], childrenKey.value, getKey.value, true).filter(
+        key => !_disabledKeys.value.has(key),
+      )
+      handleSelectChange(checkStateResolver[checked ? 'appendKeys' : 'removeKeys'](selectedKeys.value, keys))
+    }
+  }
+  const handleCheckedKeysUpdate = (keys: VKey[]) => {
+    if (!shouldUseExternalCheckStateResolver.value) {
+      handleSelectChange(keys)
+      return
+    }
+  }
+
+  const disabled: TreeProps['disabled'] = node =>
+    _disabledKeys.value.has(getKey.value(node as TransferData)) || !!props.disabled
+  const onScroll: TreeProps['onScroll'] = evt => callEmit(props.onScroll, isSource, evt)
+  const onScrolledChange: TreeProps['onScrolledChange'] = (startIndex, endIndex, visibleData) =>
+    callEmit(props.onScrolledChange, isSource, startIndex, endIndex, visibleData)
+  const onScrolledBottom: TreeProps['onScrolledBottom'] = () => callEmit(props.onScrolledBottom, isSource)
 
   return computed<TreeProps>(() => {
     const height = isNumber(props.scroll?.height) ? props.scroll?.height : undefined
@@ -49,10 +87,10 @@ export function useTransferTreeProps(
       blocked: true,
       childrenKey: childrenKey.value,
       checkable: isSource || props.mode !== 'immediate',
-      cascaderStrategy: props.treeProps?.cascaderStrategy || 'all',
+      cascaderStrategy: cascaderStrategy.value,
       checkedKeys: selectedKeys.value,
       dataSource: treeDataSource.value,
-      disabled: node => _disabledKeys.value.has(getKey.value(node as TransferData)) || !!props.disabled,
+      disabled,
       draggable: false,
       expandedKeys: isSource ? sourceExpandedKeys.value : targetExpandedKeys.value,
       height,
@@ -60,17 +98,12 @@ export function useTransferTreeProps(
       loadChildren: loadChildren.value,
       selectable: true,
       virtual: props.virtual,
-      'onUpdate:checkedKeys': handleSelectChange,
+      onCheck: handleChecked,
+      'onUpdate:checkedKeys': handleCheckedKeysUpdate,
       'onUpdate:expandedKeys': isSource ? handleSourceExpandedChange : handleTargetExpandedChange,
-      onScroll: evt => {
-        callEmit(props.onScroll, isSource, evt)
-      },
-      onScrolledChange: (startIndex, endIndex, visibleData) => {
-        callEmit(props.onScrolledChange, isSource, startIndex, endIndex, visibleData)
-      },
-      onScrolledBottom: () => {
-        callEmit(props.onScrolledBottom, isSource)
-      },
+      onScroll,
+      onScrolledChange,
+      onScrolledBottom,
     }
   })
 }
diff --git a/packages/pro/transfer/src/composables/useTreeDataStrategy.ts b/packages/pro/transfer/src/composables/useTreeDataStrategy.ts
index 2b6e26508..7141194dd 100644
--- a/packages/pro/transfer/src/composables/useTreeDataStrategy.ts
+++ b/packages/pro/transfer/src/composables/useTreeDataStrategy.ts
@@ -6,31 +6,31 @@
  */
 
 import type { ProTransferProps, TreeTransferData } from '../types'
-import type { VKey } from '@idux/cdk/utils'
 import type { TransferDataStrategyProp } from '@idux/components/transfer'
-import type { GetKeyFn } from '@idux/components/utils'
+import type { GetKeyFn, TreeCheckStateResolver } from '@idux/components/utils'
 
 import { type ComputedRef, type Ref, ref, watch } from 'vue'
 
+import { type VKey, filterTree, flattenTree, mergeTree, traverseTree } from '@idux/cdk/utils'
 import { type CascaderStrategy } from '@idux/components/cascader'
 
 import { type TreeDataStrategyContext, useTreeDataStrategyContext } from './useTreeDataStrategyContext'
-import { combineTrees, filterTree, flattenTree, genFlattenedTreeKeys, traverseTree } from '../utils'
 
-export function useTreeDataStrategies<C extends VKey>(
+export function useTreeDataStrategies<V extends TreeTransferData<V, C>, C extends string>(
   props: ProTransferProps,
   childrenKey: ComputedRef<C>,
+  getKey: ComputedRef<GetKeyFn>,
   cascadeStrategy: ComputedRef<CascaderStrategy>,
 ): {
-  context: TreeDataStrategyContext<C>
-  mergedDataStrategy: Ref<TransferDataStrategyProp<TreeTransferData<C>>>
+  context: TreeDataStrategyContext<V, C>
+  mergedDataStrategy: Ref<TransferDataStrategyProp<V>>
 } {
-  const context = useTreeDataStrategyContext(props, childrenKey)
-  const getMergedDataStrategy = () => ({
+  const context = useTreeDataStrategyContext<V, C>(props, childrenKey, getKey, cascadeStrategy)
+  const getMergedDataStrategy = (): TransferDataStrategyProp<V> => ({
     ...context.baseDataStrategy,
-    ...createStrategy(context, childrenKey, cascadeStrategy.value, props.flatTargetData),
+    ...createStrategy(context, cascadeStrategy.value, props.flatTargetData),
   })
-  const mergedDataStrategy = ref<TransferDataStrategyProp<TreeTransferData<C>>>(getMergedDataStrategy())
+  const mergedDataStrategy = ref<TransferDataStrategyProp<V>>(getMergedDataStrategy())
   watch([cascadeStrategy, childrenKey], () => {
     mergedDataStrategy.value = getMergedDataStrategy()
   })
@@ -41,47 +41,28 @@ export function useTreeDataStrategies<C extends VKey>(
   }
 }
 
-const commonRemoveFn = (keys: VKey[], selectedKeySet: VKey[], parentKeyMap: Map<VKey, VKey | undefined>) => {
-  const newKeys = new Set(selectedKeySet)
-
-  keys.forEach(key => {
-    let currentKey: VKey | undefined = key
-    while (currentKey) {
-      newKeys.delete(currentKey)
-      currentKey = parentKeyMap.get(currentKey!)
-    }
-  })
-
-  return Array.from(newKeys)
-}
-
-const getAllSelectedKeys = <C extends VKey>(
+const getAllSelectedKeys = <V extends TreeTransferData<V, C>, C extends string>(
   selected: boolean,
-  data: TreeTransferData<C>[],
+  checkStateResolver: TreeCheckStateResolver<V, C>,
+  data: V[],
   selectedKeySet: Set<VKey>,
   disabledkeySet: Set<VKey>,
-  getKey: GetKeyFn,
-  childrenKey: C,
 ) => {
-  let tempKeys: Set<VKey>
-  if (!selected) {
-    tempKeys = new Set()
-    disabledkeySet.forEach(key => {
-      selectedKeySet.has(key) && tempKeys.add(key)
-    })
-  } else {
-    tempKeys = new Set(genFlattenedTreeKeys(data, childrenKey, getKey))
-    disabledkeySet.forEach(key => {
-      !selectedKeySet.has(key) && tempKeys.delete(key)
-    })
-  }
+  const defaultKeys: VKey[] = []
+  disabledkeySet.forEach(key => {
+    if (selected) {
+      !selectedKeySet.has(key) && defaultKeys.push(key)
+    } else {
+      selectedKeySet.has(key) && defaultKeys.push(key)
+    }
+  })
 
-  return Array.from(tempKeys)
+  return checkStateResolver[selected ? 'getAllCheckedKeys' : 'getAllUncheckedKeys'](data, defaultKeys)
 }
 
-const genDisabledKeys = <C extends VKey>(
-  data: TreeTransferData<C>[],
-  getKey: (item: TreeTransferData<C>) => VKey,
+const genDisabledKeys = <V extends TreeTransferData<V, C>, C extends string>(
+  data: V[],
+  getKey: (item: V) => VKey,
   childrenKey: C,
   cascade: boolean,
 ): Set<VKey> => {
@@ -92,12 +73,12 @@ const genDisabledKeys = <C extends VKey>(
     childrenKey,
     (item, parents) => {
       const key = getKey(item)
-      const cihldren = item[childrenKey]
+      const children = item[childrenKey]
       if (
         item.disabled ||
         (cascade &&
           (parents.some(parent => parent.disabled) ||
-            (cihldren?.length && cihldren.every(child => keys.has(getKey(child))))))
+            (children?.length && children.every(child => keys.has(getKey(child))))))
       ) {
         keys.add(key)
       }
@@ -108,21 +89,19 @@ const genDisabledKeys = <C extends VKey>(
   return keys
 }
 
-function createSeparateDataSourceFn<C extends VKey>(
+function createSeparateDataSourceFn<V extends TreeTransferData<V, C>, C extends string>(
   childrenKey: ComputedRef<C>,
-  cachedTargetData: Ref<TreeTransferData<C>[]>,
+  cachedTargetData: Ref<V[]>,
   cascaderStrategy: CascaderStrategy,
   targetDataCount: Ref<number>,
-): Exclude<TransferDataStrategyProp<TreeTransferData<C>>['separateDataSource'], undefined> {
+  flatTargetData: boolean | 'all' = false,
+): Exclude<TransferDataStrategyProp<V>['separateDataSource'], undefined> {
   const targetDataKeySet = new Set<VKey>()
 
-  const getFilterFn = (
-    selectedKeySet: Set<VKey>,
-    getKey: GetKeyFn,
-  ): ((data: TreeTransferData<C>[], isSource: boolean) => TreeTransferData<C>[]) => {
+  const getFilterFn = (selectedKeySet: Set<VKey>, getKey: GetKeyFn): ((data: V[], isSource: boolean) => V[]) => {
     // under cascaderStrategy `parent`, selected child nodes are not in selectedKeys
     // so we consider the item is selected when its parent exists in selectedKeys
-    const filterFn: (item: TreeTransferData<C>, parent: TreeTransferData<C>[], isSource: boolean) => boolean = (() => {
+    const filterFn: (item: V, parent: V[], isSource: boolean) => boolean = (() => {
       switch (cascaderStrategy) {
         case 'all':
         case 'off':
@@ -156,7 +135,7 @@ function createSeparateDataSourceFn<C extends VKey>(
         )
       }
 
-      const res: TreeTransferData<C>[] = []
+      const res: V[] = []
       traverseTree(data, childrenKey.value, (item, parent) => {
         const key = getKey(item)
         if (filterFn(item, parent, isSource) && !targetDataKeySet.has(key)) {
@@ -177,40 +156,21 @@ function createSeparateDataSourceFn<C extends VKey>(
     targetDataCount.value = targetDataKeySet.size
     targetDataKeySet.clear()
 
-    // combine new data with previous data
+    // merge new data with previous data
     // beacause we intend to cache selected data after dataSource changes
-    const targetData = combineTrees(newTargetData, previousTargetData, childrenKey.value, getKey)
+    const targetData = mergeTree(previousTargetData, newTargetData, childrenKey.value, getKey)
     cachedTargetData.value = targetData
 
     return {
       sourceData: filterData(data, true),
-      targetData,
-    }
-  }
-}
-
-function createSeparateDataSourceFnWithFlatten<C extends VKey>(
-  childrenKey: ComputedRef<C>,
-  cachedTargetData: Ref<TreeTransferData<C>[]>,
-  cascaderStrategy: CascaderStrategy,
-  targetDataCount: Ref<number>,
-  flatTargetData: boolean | 'all' = false,
-): Exclude<TransferDataStrategyProp<TreeTransferData<C>>['separateDataSource'], undefined> {
-  const fn = createSeparateDataSourceFn(childrenKey, cachedTargetData, cascaderStrategy, targetDataCount)
-
-  return (...args) => {
-    const { sourceData, targetData } = fn(...args)
-
-    return {
-      sourceData,
       targetData:
         cascaderStrategy === 'off' ? targetData : flattenTargetTree(targetData, childrenKey.value, flatTargetData),
     }
   }
 }
 
-function flattenTargetTree<C extends VKey>(
-  data: TreeTransferData<C>[],
+function flattenTargetTree<V extends TreeTransferData<V, C>, C extends string>(
+  data: V[],
   childrenKey: C,
   flatTargetData: boolean | 'all',
 ) {
@@ -221,209 +181,31 @@ function flattenTargetTree<C extends VKey>(
   return flattenTree(data, childrenKey, item => ({ ...item, children: undefined }), flatTargetData !== 'all')
 }
 
-function createStrategy<C extends VKey>(
-  context: TreeDataStrategyContext<C>,
-  childrenKey: ComputedRef<C>,
+function createStrategy<V extends TreeTransferData<V, C>, C extends string>(
+  context: TreeDataStrategyContext<V, C>,
   cascaderStrategy: CascaderStrategy,
   flatTargetData: boolean | 'all',
-) {
-  switch (cascaderStrategy) {
-    case 'parent':
-      return createParentStrategy(context, childrenKey, flatTargetData)
-    case 'child':
-      return createChildStrategy(context, childrenKey, flatTargetData)
-    case 'off':
-      return createOffStrategy(context, childrenKey, flatTargetData)
-    case 'all':
-    default:
-      return createAllStrategy(context, childrenKey, flatTargetData)
-  }
-}
-
-function createAllStrategy<C extends VKey>(
-  context: TreeDataStrategyContext<C>,
-  childrenKey: ComputedRef<C>,
-  flatTargetData: boolean | 'all',
-): TransferDataStrategyProp<TreeTransferData<C>> {
-  const { cachedTargetData, parentKeyMap, targetDataCount } = context
-  return {
-    genDisabledKeys: (data, getKey) => genDisabledKeys(data, getKey, childrenKey.value, true),
-    separateDataSource: createSeparateDataSourceFnWithFlatten(
-      childrenKey,
-      cachedTargetData,
-      'all',
-      targetDataCount,
-      flatTargetData,
-    ),
-    getAllSelectedKeys: (selected, data, selectedKeySet, disabledKeySet, getKey) =>
-      getAllSelectedKeys(selected, data, selectedKeySet, disabledKeySet, getKey, childrenKey.value),
-    remove: (keys, selectedKeySet) => commonRemoveFn(keys, selectedKeySet, parentKeyMap),
-  }
-}
-
-function createChildStrategy<C extends VKey>(
-  context: TreeDataStrategyContext<C>,
-  childrenKey: ComputedRef<C>,
-  flatTargetData: boolean | 'all',
-): TransferDataStrategyProp<TreeTransferData<C>> {
-  const { cachedTargetData, parentKeyMap, targetDataCount } = context
-
-  return {
-    genDisabledKeys: (data, getKey) => genDisabledKeys(data, getKey, childrenKey.value, true),
-    getAllSelectedKeys(selected, data, selectedKeySet, disabledKeySet, getKey) {
-      if (!selected) {
-        return Array.from(selectedKeySet).filter(key => disabledKeySet.has(key))
-      }
-
-      const keys: VKey[] = []
-      flattenTree(data, childrenKey.value, undefined, true).forEach(node => {
-        const key = getKey(node)
-        if (selectedKeySet.has(key)) {
-          keys.push(key)
-        } else if (!disabledKeySet.has(key)) {
-          keys.push(key)
-        }
-      })
-
-      return keys
-    },
-    separateDataSource: createSeparateDataSourceFnWithFlatten(
-      childrenKey,
-      cachedTargetData,
-      'child',
-      targetDataCount,
-      flatTargetData,
-    ),
-    remove: (keys, selectedKeySet) => commonRemoveFn(keys, selectedKeySet, parentKeyMap),
-  }
-}
-
-function createParentStrategy<C extends VKey>(
-  context: TreeDataStrategyContext<C>,
-  childrenKey: ComputedRef<C>,
-  flatTargetData: boolean | 'all',
-): TransferDataStrategyProp<TreeTransferData<C>> {
-  const { cachedTargetData, dataKeyMap, targetDataCount } = context
-  const separateDataSource = createSeparateDataSourceFn(childrenKey, cachedTargetData, 'parent', targetDataCount)
-
-  return {
-    genDisabledKeys: (data, getKey) => genDisabledKeys(data, getKey, childrenKey.value, true),
-    getAllSelectedKeys: (selected, data, selectedKeySet, disabledKeySet, getKey) => {
-      const keys: VKey[] = []
-
-      if (selected) {
-        traverseTree(data, childrenKey.value, (item, parents) => {
-          const key = getKey(item)
-          if (disabledKeySet.has(key)) {
-            ;[...parents, item].some(node => selectedKeySet.has(getKey(node))) && keys.push(key)
-            return
-          }
-
-          if (!item[childrenKey.value]?.length) {
-            keys.push(key)
-          } else if (item[childrenKey.value]!.every(child => !disabledKeySet.has(getKey(child)))) {
-            keys.push(key)
-          }
-        })
-      } else {
-        traverseTree(data, childrenKey.value, (item, parents) => {
-          const key = getKey(item)
-          if (!disabledKeySet.has(key)) {
-            return
-          }
-
-          if ([...parents, item].some(node => selectedKeySet.has(getKey(node)))) {
-            keys.push(key)
-            return
-          }
-        })
-      }
-
-      return keys
-    },
-    separateDataSource(data, _, selectedKeySet, getKey) {
-      const { sourceData, targetData } = separateDataSource(data, _, selectedKeySet, getKey)
-      return {
-        sourceData,
-        targetData: flattenTargetTree(targetData, childrenKey.value, flatTargetData),
-      }
-    },
-    append(keys, selectedKey, getKey) {
-      const newKeySet = new Set([...selectedKey, ...keys])
-
-      keys.forEach(key => {
-        const children = dataKeyMap.get(key)?.[childrenKey.value]
-        if (children) {
-          traverseTree(children, childrenKey.value, item => {
-            newKeySet.delete(getKey(item))
-          })
-        }
-      })
-
-      return Array.from(newKeySet)
-    },
-    remove(keys: VKey[], selectedKey: VKey[], getKey: GetKeyFn) {
-      const keySet = new Set(keys)
-      const newKeySet = new Set(selectedKey)
-      const deletedKeys = new Set()
-
-      // store already deleted keys
-      const deleteKey = (key: VKey) => {
-        deletedKeys.add(key)
-        newKeySet.delete(key)
-      }
-
-      // it is not possible to get the correct selected keys from bottom to top
-      traverseTree(cachedTargetData.value, childrenKey.value, (item, parents) => {
-        if (keySet.has(getKey(item))) {
-          const keysInChain = [item, ...parents].map(getKey)
-          const selectedKeyIdx = keysInChain.findIndex(key => newKeySet.has(key))
-
-          // if one of the ancestors was selected
-          // replace parent node with child nodes
-          if (selectedKeyIdx > -1) {
-            // only travers chain from selected node to the bottom
-            parents.slice(0, selectedKeyIdx).forEach(parent => {
-              parent[childrenKey.value]?.forEach(child => {
-                const childKey = getKey(child)
-                // add only if the child node hasn't been deleted before
-                if (!deletedKeys.has(childKey)) {
-                  newKeySet.add(childKey)
-                }
-              })
-            })
-            // not one of the ancestors should be selected
-            keysInChain.slice(0, selectedKeyIdx + 1).forEach(key => deleteKey(key))
-          }
-        } else if (parents.some(parent => keySet.has(getKey(parent)))) {
-          // if some of the ancestors was removed
-          // remove the node itself
-          deleteKey(getKey(item))
-        }
-      })
-
-      return Array.from(newKeySet)
-    },
-  }
-}
-
-function createOffStrategy<C extends VKey>(
-  context: TreeDataStrategyContext<C>,
-  childrenKey: ComputedRef<C>,
-  flatTargetData: boolean | 'all',
-): TransferDataStrategyProp<TreeTransferData<C>> {
-  const { cachedTargetData, targetDataCount } = context
+): TransferDataStrategyProp<V> {
+  const { cachedTargetData, checkStateResolver, childrenKey, dataMap, targetDataCount } = context
 
   return {
-    genDisabledKeys: (data, getKey) => genDisabledKeys(data, getKey, childrenKey.value, false),
-    separateDataSource: createSeparateDataSourceFnWithFlatten(
+    genDisabledKeys: (data, getKey) => genDisabledKeys(data, getKey, childrenKey.value, cascaderStrategy !== 'off'),
+    getAllSelectedKeys: (selected, data, selectedKeySet, disabledKeySet) =>
+      getAllSelectedKeys(selected, checkStateResolver, data, selectedKeySet, disabledKeySet),
+    separateDataSource: createSeparateDataSourceFn(
       childrenKey,
       cachedTargetData,
-      'off',
+      cascaderStrategy,
       targetDataCount,
       flatTargetData,
     ),
-    getAllSelectedKeys: (selected, data, selectedKeySet, disabledKeySet, getKey) =>
-      getAllSelectedKeys(selected, data, selectedKeySet, disabledKeySet, getKey, childrenKey.value),
+    append: (keys, selectedKey) => checkStateResolver.appendKeys(selectedKey, keys),
+    remove: (keys, selectedkey) =>
+      checkStateResolver.removeKeys(
+        selectedkey,
+        cascaderStrategy === 'all' || cascaderStrategy === 'child'
+          ? keys.filter(key => !dataMap.get(key)?.[childrenKey.value]?.length)
+          : keys,
+      ),
   }
 }
diff --git a/packages/pro/transfer/src/composables/useTreeDataStrategyContext.ts b/packages/pro/transfer/src/composables/useTreeDataStrategyContext.ts
index 97b1e5c9c..70af3e205 100644
--- a/packages/pro/transfer/src/composables/useTreeDataStrategyContext.ts
+++ b/packages/pro/transfer/src/composables/useTreeDataStrategyContext.ts
@@ -6,58 +6,94 @@
  */
 
 import type { ProTransferProps, TreeTransferData } from '../types'
-import type { VKey } from '@idux/cdk/utils'
 import type { TransferDataStrategyProp } from '@idux/components/transfer'
 
-import { type ComputedRef, type Ref, onUnmounted, ref } from 'vue'
+import { type ComputedRef, type Ref, computed, onUnmounted, ref } from 'vue'
 
-import { filterTree, genFlattenedTreeKeys, traverseTree } from '../utils'
+import { type VKey, filterTree, getTreeKeys, mergeTree, traverseTree } from '@idux/cdk/utils'
+import {
+  type GetKeyFn,
+  type TreeCascadeStrategy,
+  type TreeCheckStateResolver,
+  type TreeCheckStateResolverContext,
+  useTreeCheckStateResolver,
+} from '@idux/components/utils'
 
-export interface TreeDataStrategyContext<C extends VKey> {
-  baseDataStrategy: TransferDataStrategyProp<TreeTransferData<C>>
-  dataKeyMap: Map<VKey, TreeTransferData<C>>
-  parentKeyMap: Map<VKey, VKey | undefined>
-  cachedTargetData: Ref<TreeTransferData<C>[]>
+export interface TreeDataStrategyContext<
+  V extends TreeTransferData<V, C> = TreeTransferData,
+  C extends string = 'children',
+> {
+  baseDataStrategy: TransferDataStrategyProp<V>
+  checkStateResolver: TreeCheckStateResolver<V, C>
+  dataMap: Map<VKey, V>
+  parentKeyMap: Map<VKey, VKey>
+  getKey: ComputedRef<GetKeyFn>
+  childrenKey: ComputedRef<C>
+  cachedTargetData: Ref<V[]>
   targetDataCount: Ref<number>
 }
 
-export function useTreeDataStrategyContext<C extends VKey>(
+export function useTreeDataStrategyContext<V extends TreeTransferData<V, C>, C extends string>(
   props: ProTransferProps,
   childrenKey: ComputedRef<C>,
-): TreeDataStrategyContext<C> {
-  const cachedTargetData = ref(props.defaultTargetData ?? []) as Ref<TreeTransferData<C>[]>
+  getKey: ComputedRef<GetKeyFn>,
+  cascadeStrategy: ComputedRef<TreeCascadeStrategy>,
+): TreeDataStrategyContext<V, C> {
+  const cachedTargetData = ref(props.defaultTargetData ?? []) as Ref<V[]>
   const targetDataCount = ref(0)
-  const dataKeyMap: Map<VKey, TreeTransferData<C>> = new Map()
-  const parentKeyMap: Map<VKey, VKey | undefined> = new Map()
+  const dataMap: Map<VKey, V> = new Map()
+  const parentKeyMap: Map<VKey, VKey> = new Map()
+  const depthMap: Map<VKey, number> = new Map()
+
+  const dataRef: Ref<V[]> = ref([])
+  const checkStateResolverContext = computed<TreeCheckStateResolverContext<V, C>>(() => ({
+    data: dataRef.value,
+    dataMap,
+    parentKeyMap,
+    depthMap,
+  }))
+
+  const checkStateResolver = useTreeCheckStateResolver(checkStateResolverContext, childrenKey, getKey, cascadeStrategy)
 
   onUnmounted(() => {
     cachedTargetData.value = []
-    dataKeyMap.clear()
+    dataMap.clear()
     parentKeyMap.clear()
+    depthMap.clear()
   })
 
   return {
     cachedTargetData,
+    checkStateResolver,
     targetDataCount,
-    dataKeyMap,
+    dataMap,
     parentKeyMap,
+    getKey,
+    childrenKey,
     baseDataStrategy: {
-      genDataKeys: (data, getKey) => {
-        return new Set(genFlattenedTreeKeys(data, childrenKey.value, getKey))
+      genDataKeys: data => {
+        return new Set(getTreeKeys(data, childrenKey.value, getKey.value))
       },
-      genDataKeyMap: (data, getKey) => {
+      genDataKeyMap: data => {
         parentKeyMap.clear()
-        dataKeyMap.clear()
+        dataMap.clear()
+        depthMap.clear()
+        dataRef.value = data
 
-        traverseTree(data, childrenKey.value, (node, parents) => {
-          const key = getKey(node)
-          dataKeyMap.set(key, node)
+        traverseTree(
+          mergeTree(cachedTargetData.value, data, childrenKey.value, getKey.value),
+          childrenKey.value,
+          (node, parents) => {
+            const key = getKey.value(node)
+            dataMap.set(key, node)
+            depthMap.set(key, parents.length)
 
-          const parent = parents[0]
-          parentKeyMap.set(key, parent && getKey(parent))
-        })
+            const parent = parents[0]
+            parent && parentKeyMap.set(key, getKey.value(parent))
+          },
+        )
 
-        return new Map(dataKeyMap)
+        return new Map(dataMap)
       },
       dataFilter: (data, searchValue, searchFn) => {
         if (!searchValue) {
diff --git a/packages/pro/transfer/src/composables/useTreeExpandedKeys.ts b/packages/pro/transfer/src/composables/useTreeExpandedKeys.ts
index 8e0fc78ce..514652aaa 100644
--- a/packages/pro/transfer/src/composables/useTreeExpandedKeys.ts
+++ b/packages/pro/transfer/src/composables/useTreeExpandedKeys.ts
@@ -10,9 +10,7 @@ import type { GetKeyFn } from '@idux/components/utils'
 
 import { type ComputedRef, computed, watch } from 'vue'
 
-import { type VKey, useControlledProp } from '@idux/cdk/utils'
-
-import { traverseTree } from '../utils'
+import { type VKey, traverseTree, useControlledProp } from '@idux/cdk/utils'
 
 export interface TreeExpandedKeysContext {
   sourceExpandedKeys: ComputedRef<VKey[]>
@@ -21,13 +19,13 @@ export interface TreeExpandedKeysContext {
   handleTargetExpandedChange: (keys: VKey[]) => void
 }
 
-export function useTreeExpandedKeys<C extends VKey>(
+export function useTreeExpandedKeys<V extends TreeTransferData<V, C>, C extends string>(
   props: ProTransferProps,
   childrenKey: ComputedRef<C>,
   getKey: ComputedRef<GetKeyFn>,
   targetKeySet: ComputedRef<Set<VKey>>,
   parentKeyMap: Map<VKey, VKey | undefined>,
-  dataKeyMap: Map<VKey, TreeTransferData<C>>,
+  dataKeyMap: Map<VKey, TreeTransferData<V, C>>,
 ): TreeExpandedKeysContext {
   const [sourceExpandedKeys, setSourceExpandedKeys] = useControlledProp(props, 'sourceExpandedKeys', () => [])
   const [targetExpandedKeys, setTargetExpandedKeys] = useControlledProp(props, 'targetExpandedKeys', () => [])
diff --git a/packages/pro/transfer/src/content/ProTransferTree.tsx b/packages/pro/transfer/src/content/ProTransferTree.tsx
index 27d2041b4..1a4502e2e 100644
--- a/packages/pro/transfer/src/content/ProTransferTree.tsx
+++ b/packages/pro/transfer/src/content/ProTransferTree.tsx
@@ -7,16 +7,15 @@
 
 import { computed, defineComponent, inject, normalizeStyle } from 'vue'
 
-import { type VKey, convertCssPixel } from '@idux/cdk/utils'
+import { VKey, convertCssPixel, getTreeKeys } from '@idux/cdk/utils'
 import { ɵEmpty } from '@idux/components/_private/empty'
-import { TRANSFER_SOURCE_TOKEN, TRANSFER_TARGET_TOKEN } from '@idux/components/transfer'
+import { TRANSFER_SOURCE_TOKEN, TRANSFER_TARGET_TOKEN, type TransferBindings } from '@idux/components/transfer'
 import { IxTree } from '@idux/components/tree'
 
 import { renderRemoveIcon } from './RenderRemovableLabel'
 import { useTransferTreeProps } from '../composables/useTransferTreeProps'
 import { proTransferContext, treeTransferContext } from '../token'
 import { type TreeTransferData, proTransferTreeContentProps } from '../types'
-import { genFlattenedTreeKeys } from '../utils'
 
 export default defineComponent({
   props: proTransferTreeContentProps,
@@ -28,27 +27,25 @@ export default defineComponent({
       sourceContentRef,
       targetContentRef,
     } = inject(proTransferContext)!
-    const { expandedKeysContext, childrenKey, loadSourceChildren, loadTargetChildren } = inject(treeTransferContext)!
 
     const proTransferTreeCls = computed(() => `${mergedPrefixCls.value}-tree-content`)
 
-    const transferBindings = inject(props.isSource ? TRANSFER_SOURCE_TOKEN : TRANSFER_TARGET_TOKEN)!
+    const treeContext = inject(treeTransferContext)!
+    const { childrenKey } = treeContext
+    const transferBindings = inject(
+      props.isSource ? TRANSFER_SOURCE_TOKEN : TRANSFER_TARGET_TOKEN,
+    )! as TransferBindings<TreeTransferData>
     const { disabledKeys, getKey, triggerRemove } = transferBindings
-    const treeProps = useTransferTreeProps(
-      proTransferProps,
-      transferBindings,
-      expandedKeysContext!,
-      childrenKey,
-      props.isSource ? loadSourceChildren! : loadTargetChildren!,
-      props.isSource,
-    )
-
-    const renderTreeRemovableSuffix = ({ node }: { node: TreeTransferData<VKey> }) => {
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const treeProps = useTransferTreeProps<any, string>(proTransferProps, treeContext, transferBindings, props.isSource)
+
+    const renderTreeRemovableSuffix = ({ node }: { node: TreeTransferData<Record<VKey, unknown>, string> }) => {
       const prefixCls = proTransferTreeCls.value
       const key = getKey.value(node)
 
       const onClick = () => {
-        triggerRemove(genFlattenedTreeKeys([node], childrenKey.value, getKey.value))
+        triggerRemove(getTreeKeys([node], childrenKey.value, getKey.value).filter(key => !disabledKeys.value.has(key)))
       }
 
       return (
diff --git a/packages/pro/transfer/src/token.ts b/packages/pro/transfer/src/token.ts
index 84a39b384..9cfcd9947 100644
--- a/packages/pro/transfer/src/token.ts
+++ b/packages/pro/transfer/src/token.ts
@@ -6,10 +6,10 @@
  */
 
 import type { TransferTreeLoadChildren } from './composables/useTransferData'
+import type { TreeDataStrategyContext } from './composables/useTreeDataStrategyContext'
 import type { TreeExpandedKeysContext } from './composables/useTreeExpandedKeys'
-import type { ProTransferProps, TransferContentInstance } from './types'
-import type { CascaderStrategy } from '@idux/components/cascader'
-import type { GetKeyFn } from '@idux/components/utils'
+import type { ProTransferProps, TransferContentInstance, TreeTransferData } from './types'
+import type { GetKeyFn, TreeCascadeStrategy } from '@idux/components/utils'
 import type { ComputedRef, InjectionKey, Ref, Slots } from 'vue'
 
 export interface ProTransferContext {
@@ -20,11 +20,12 @@ export interface ProTransferContext {
   sourceContentRef: Ref<TransferContentInstance | undefined>
   targetContentRef: Ref<TransferContentInstance | undefined>
 }
-export interface TreeTransferContext {
-  cascaderStrategy: ComputedRef<CascaderStrategy>
-  childrenKey: ComputedRef<string>
+export interface TreeTransferContext<V extends TreeTransferData<V, C> = TreeTransferData, C extends string = string> {
+  cascaderStrategy: ComputedRef<TreeCascadeStrategy>
+  childrenKey: ComputedRef<C>
   loadSourceChildren: TransferTreeLoadChildren
   loadTargetChildren: TransferTreeLoadChildren
+  dataStrategyContext: TreeDataStrategyContext<V, C>
   expandedKeysContext: TreeExpandedKeysContext
 }
 
diff --git a/packages/pro/transfer/src/types.ts b/packages/pro/transfer/src/types.ts
index c492bb4df..d0d0a0bc7 100644
--- a/packages/pro/transfer/src/types.ts
+++ b/packages/pro/transfer/src/types.ts
@@ -8,7 +8,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import type { VirtualScrollToFn } from '@idux/cdk/scroll'
-import type { ExtractInnerPropTypes, ExtractPublicPropTypes, MaybeArray, VKey } from '@idux/cdk/utils'
+import type { ExtractInnerPropTypes, ExtractPublicPropTypes, MaybeArray, TreeTypeData, VKey } from '@idux/cdk/utils'
 import type { CascaderStrategy } from '@idux/components/cascader'
 import type { EmptyProps } from '@idux/components/empty'
 import type { TableColumn, TableProps } from '@idux/components/table'
@@ -25,9 +25,8 @@ import type { DefineComponent, HTMLAttributes, PropType } from 'vue'
 export type ProTransferTypes = 'table' | 'tree'
 export type { TransferData } from '@idux/components/transfer'
 
-export type TreeTransferData<C extends VKey = 'children'> = TransferData & {
-  [key in C]?: TreeTransferData<C>[]
-}
+export type TreeTransferData<V extends object = Record<VKey, unknown>, C extends string = 'children'> = TransferData &
+  TreeTypeData<V, C>
 
 export type ProTransferTableProps<T = any, K = VKey> = {
   sourceColumns: TableColumn<T, K>[]
@@ -45,7 +44,7 @@ export type ProTransferTreeProps = Pick<
   | 'onExpand'
   | 'onExpandedChange'
 > & {
-  cascaderStrategy: CascaderStrategy
+  cascaderStrategy?: CascaderStrategy
 }
 
 export interface TransferContentInstance {
diff --git a/packages/pro/transfer/src/utils.ts b/packages/pro/transfer/src/utils.ts
deleted file mode 100644
index 881b1d4dd..000000000
--- a/packages/pro/transfer/src/utils.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- * @license
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://github.com/IDuxFE/idux/blob/main/LICENSE
- */
-
-import type { TreeTransferData } from './types'
-import type { VKey } from '@idux/cdk/utils'
-
-import { isArray, isNil } from 'lodash-es'
-
-export function traverseTree<C extends VKey>(
-  data: TreeTransferData<C>[],
-  childrenKey: C,
-  fn: (item: TreeTransferData<C>, parents: TreeTransferData<C>[]) => void,
-  traverseStrategy: 'pre' | 'post' = 'pre',
-): void {
-  const traverse = (_data: TreeTransferData<C>[], parents: TreeTransferData<C>[]) => {
-    _data.forEach(item => {
-      traverseStrategy === 'pre' && fn(item, parents)
-      if (item[childrenKey]) {
-        traverse(item[childrenKey]!, [item, ...parents])
-      }
-      traverseStrategy === 'post' && fn(item, parents)
-    })
-  }
-
-  traverse(data, [])
-}
-
-export function mapTree<C extends VKey>(
-  data: TreeTransferData<C>[],
-  childrenKey: C,
-  fn: (item: TreeTransferData<C>, parents: TreeTransferData<C>[]) => TreeTransferData<C>,
-): TreeTransferData<C>[] {
-  const map = (_data: TreeTransferData<C>[], parents: TreeTransferData<C>[]) => {
-    return _data.map(item => {
-      const mappedItem = fn(item, parents)
-      if (item[childrenKey]) {
-        const mappedChildren = map(item[childrenKey]!, [item, ...parents])
-        mappedItem[childrenKey] = mappedChildren as TreeTransferData<C>[C]
-      }
-
-      return mappedItem
-    })
-  }
-  return map(data, [])
-}
-
-export function filterTree<C extends VKey>(
-  data: TreeTransferData<C>[],
-  childrenKey: C,
-  fn: (item: TreeTransferData<C>, parents: TreeTransferData<C>[]) => boolean,
-  filterStrategy: 'and' | 'or' = 'or',
-): TreeTransferData<C>[] {
-  const _filter = (_data: TreeTransferData<C>[], parents: TreeTransferData<C>[]): TreeTransferData<C>[] => {
-    return _data
-      .map(item => {
-        let children: TreeTransferData<C>[] | undefined
-
-        if (isArray(item[childrenKey])) {
-          children = _filter(item[childrenKey]!, [item, ...parents])
-        }
-
-        let itemValid = fn(item, parents)
-        itemValid =
-          filterStrategy === 'and'
-            ? !!(children && children.length > 0) && itemValid
-            : !!(children && children.length > 0) || itemValid
-
-        return (
-          itemValid && {
-            ...item,
-            [childrenKey]: item[childrenKey] && children,
-          }
-        )
-      })
-      .filter(Boolean) as TreeTransferData<C>[]
-  }
-
-  return _filter(data, [])
-}
-
-export function combineTrees<C extends VKey>(
-  sourceTree: TreeTransferData<C>[],
-  targetTree: TreeTransferData<C>[],
-  childrenKey: C,
-  getRowKey: (item: TreeTransferData<C>) => VKey,
-): TreeTransferData<C>[] {
-  sourceTree.forEach(item => {
-    const targetItem = targetTree.find(_item => {
-      const sourceKey = getRowKey(item)
-      const targetKey = getRowKey(_item)
-
-      return !isNil(sourceKey) && !isNil(targetKey) && sourceKey === targetKey
-    })
-
-    if (!targetItem) {
-      targetTree.push(item)
-      return
-    }
-
-    if (!isArray(item[childrenKey])) {
-      return
-    }
-
-    if (!isArray(targetItem[childrenKey])) {
-      ;(targetItem[childrenKey] as TreeTransferData<C>[]) = []
-    }
-
-    combineTrees(item[childrenKey]!, targetItem[childrenKey]!, childrenKey, getRowKey)
-  })
-
-  return targetTree
-}
-
-export function flattenTree<C extends VKey>(
-  data: TreeTransferData<C>[],
-  childrenKey: C,
-  mapFn?: (item: TreeTransferData<C>) => TreeTransferData<C>,
-  leafOnly = false,
-): TreeTransferData<C>[] {
-  const res: TreeTransferData<C>[] = []
-
-  traverseTree(data, childrenKey, item => {
-    if (!leafOnly || !item[childrenKey] || item[childrenKey]!.length <= 0) {
-      const mappedItem = mapFn ? mapFn(item) : item
-      mappedItem && res.push(mappedItem)
-    }
-  })
-
-  return res
-}
-
-export function genFlattenedTreeKeys<C extends VKey>(
-  data: TreeTransferData<C>[],
-  childrenKey: C,
-  getRowKey: (item: TreeTransferData<C>) => VKey,
-): VKey[] {
-  const keys: VKey[] = []
-
-  traverseTree(data, childrenKey, item => {
-    keys.push(getRowKey(item))
-  })
-
-  return keys
-}
diff --git a/packages/pro/transfer/src/wrapper/TreeTransferWrapper.tsx b/packages/pro/transfer/src/wrapper/TreeTransferWrapper.tsx
index 381704689..e17c39fce 100644
--- a/packages/pro/transfer/src/wrapper/TreeTransferWrapper.tsx
+++ b/packages/pro/transfer/src/wrapper/TreeTransferWrapper.tsx
@@ -34,11 +34,14 @@ export default defineComponent({
     const cascaderStrategy = computed(() => props.treeProps?.cascaderStrategy ?? 'all')
     const childrenKey = computed(() => props.treeProps?.childrenKey ?? 'children')
 
-    const {
-      dataStrategyContext: { dataKeyMap, targetDataCount },
-      expandedKeysContext,
-      mergedDataStrategy,
-    } = useTreeContext(props, childrenKey, cascaderStrategy, getKey, targetKeySet)
+    const { dataStrategyContext, expandedKeysContext, mergedDataStrategy } = useTreeContext(
+      props,
+      childrenKey,
+      cascaderStrategy,
+      getKey,
+      targetKeySet,
+    )
+    const { dataMap, targetDataCount } = dataStrategyContext
     const { dataSource, loadSourceChildren, loadTargetChildren } = useTransferData(
       props,
       getKey,
@@ -56,6 +59,7 @@ export default defineComponent({
       childrenKey,
       loadSourceChildren,
       loadTargetChildren,
+      dataStrategyContext,
       expandedKeysContext,
     })
 
@@ -66,13 +70,13 @@ export default defineComponent({
         <ProTransferTree isSource={isSource} />
       )
     }
-    const renderTranferTreeHeaderLabel = (params: { isSource: boolean; data: TreeTransferData<VKey>[] }) => {
+    const renderTranferTreeHeaderLabel = (params: { isSource: boolean; data: TreeTransferData[] }) => {
       if (slots.headerLabel) {
         return slots.headerLabel(params)
       }
 
       const label = params.isSource ? transferLocale.toSelect : transferLocale.selected
-      const count = params.isSource ? (dataKeyMap?.size ?? 0) - targetDataCount.value : targetDataCount.value
+      const count = params.isSource ? (dataMap?.size ?? 0) - targetDataCount.value : targetDataCount.value
 
       return `${label} (${count})`
     }
@@ -120,24 +124,25 @@ export default defineComponent({
   },
 })
 
-function useTreeContext<C extends VKey>(
+function useTreeContext<C extends string>(
   props: ProTransferProps,
   childrenKey: ComputedRef<C>,
   cascadeStrategy: ComputedRef<CascaderStrategy>,
   getKey: ComputedRef<GetKeyFn>,
   targetKeySet: ComputedRef<Set<VKey>>,
 ): {
-  dataStrategyContext: TreeDataStrategyContext<C>
+  dataStrategyContext: TreeDataStrategyContext<TreeTransferData, C>
   expandedKeysContext: TreeExpandedKeysContext
-  mergedDataStrategy: Ref<TransferDataStrategyProp<TreeTransferData<C>>>
+  mergedDataStrategy: Ref<TransferDataStrategyProp<TreeTransferData<TreeTransferData, C>>>
 } {
   const { context: dataStrategyContext, mergedDataStrategy } = useTreeDataStrategies(
     props,
     childrenKey,
+    getKey,
     cascadeStrategy,
   )
-  const { parentKeyMap, dataKeyMap } = dataStrategyContext
-  const expandedKeysContext = useTreeExpandedKeys(props, childrenKey, getKey, targetKeySet, parentKeyMap, dataKeyMap)
+  const { parentKeyMap, dataMap } = dataStrategyContext
+  const expandedKeysContext = useTreeExpandedKeys(props, childrenKey, getKey, targetKeySet, parentKeyMap, dataMap)
 
   return {
     dataStrategyContext,