feat:区划组件

张含笑

2026-02-03 98f9efe4b5161a0931e863451f4b7a30fef65322

feat:区划组件

 applications/task-work-order/src/components/RegionSelect/main.vue

New file
@@ -0,0 +1,198 @@
<template>
  <el-tree-select
    class="gd-select"
    popper-class="gd-tree-select-popper"
    :model-value="modelValue"
    @update:model-value="handleChange"
    node-key="id"
    :default-expanded-keys="expandedKeys"
    :props="treeSelectProps"
    :placeholder="placeholder"
    :clearable="clearable"
    :filterable="filterable"
    :check-strictly="checkStrictly"
    lazy
    :load="loadRegionNode"
    :render-after-expand="false"
  />
</template>

<script setup>
import { ref, watch, onMounted } from 'vue'
import request from '@/axios'

// 懒加载获取区域节点数据
const regionLazyTreeApi = params => {
  return request({
    url: `/blade-system/region/lazy-tree`,
    method: 'get',
    params,
  })
}

// 定义组件属性
const props = defineProps({
  modelValue: {
    type: [String, Number],
    default: ''
  },
  placeholder: {
    type: String,
    default: '请选择'
  },
  clearable: {
    type: Boolean,
    default: true
  },
  filterable: {
    type: Boolean,
    default: true
  },
  checkStrictly: {
    type: Boolean,
    default: true
  }
})

// 定义组件事件
const emit = defineEmits(['update:modelValue', 'change'])

// 组件内部状态
const expandedKeys = ref([]) // 展开的节点
const regionNodeCache = ref(new Map()) // 缓存区域节点

// 树形选择器配置
const treeSelectProps = {
  value: 'id',
  label: 'name',
  children: 'children',
  // 判断叶子节点
  isLeaf: (data, node) => {
    return node.level >= 2
  }
}

// 处理值变化
function handleChange(value) {
  emit('update:modelValue', value)
  // 从缓存中获取区域名称
  const node = regionNodeCache.value.get(value)
  const areaName = node?.name || ''
  // 同时返回区域代码和区域名称
  emit('change', { code: value, name: areaName })
}

// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
  try {
    // 限制只加载两级，当前节点 level >= 1 时不加载子节点
    if (node.level >= 2) {
      resolve([])
      return
    }

    // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
    const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
    const parentCode = node.data?.id || '360800000000'
    const res = await regionLazyTreeApi(params)
    const nodes = res?.data?.data || []

    // 处理返回的节点数据
    const processedNodes = nodes.map(item => {
      const nodeId = item.id || item.value
      // 缓存节点及其父节点关系
      regionNodeCache.value.set(nodeId, {
        id: nodeId,
        name: item.name || item.title || item.label,
        parentId: parentCode,
        hasChildren: item.hasChildren || false
      })

      return {
        id: nodeId,
        name: item.name || item.title || item.label,
        hasChildren: item.hasChildren || false
      }
    })

    resolve(processedNodes)
  } catch (error) {
    console.error('获取区域数据失败:', error)
    resolve([])
  }
}

// 加载区域节点路径
async function loadRegionPath(regionCode) {
  if (!regionCode) return

  try {
    const path = []
    const queue = [{ code: '360800000000', currentPath: ['360800000000'] }]
    let found = false

    // 广度优先搜索，逐层加载节点直到找到目标节点
    while (queue.length > 0 && !found) {
      const { code, currentPath } = queue.shift()

      // 获取当前节点的子节点
      const res = await regionLazyTreeApi({ parentCode: code })
      const nodes = res?.data?.data || []

      for (const node of nodes) {
        const nodeId = node.id || node.value

        // 缓存节点及其父节点关系
        regionNodeCache.value.set(nodeId, {
          id: nodeId,
          name: node.name || node.title || node.label,
          parentId: code,
          hasChildren: node.hasChildren || false
        })

        // 检查是否找到目标节点
        if (nodeId === regionCode) {
          path.push(...currentPath, nodeId)
          found = true
          break
        }

        // 如果有子节点，加入队列继续搜索
        if (node.hasChildren) {
          queue.push({
            code: nodeId,
            currentPath: [...currentPath, nodeId]
          })
        }
      }
    }

    if (path.length > 0) {
      expandedKeys.value = path
    }
  } catch (error) {
    console.error('加载区域路径失败:', error)
  }
}

// 监听modelValue变化，当值变化时加载路径
watch(
  () => props.modelValue,
  async (newValue) => {
    if (newValue) {
      await loadRegionPath(String(newValue))
    } else {
      expandedKeys.value = []
    }
  },
  { immediate: true }
)

// 暴露方法给父组件
defineExpose({
  loadRegionPath
})
</script>

<style scoped lang="scss">
</style>

 applications/task-work-order/src/views/orderView/appConfiguration/inventory/FormDiaLog.vue

@@ -42,23 +42,12 @@
            <el-row>
                <el-col :span="12">
                    <el-form-item label="所属区划" prop="areaCode">
                        <el-tree-select
                            class="gd-select"
                            popper-class="gd-tree-select-popper"
                            v-model="formData.areaCode"
                            node-key="id"
                            :default-expanded-keys="expandedKeys"
                            :props="treeSelectProps"
                            placeholder="请选择"
                            clearable
                            filterable
                            :check-strictly="true"
                            lazy
                            :load="loadRegionNode"
                            :render-after-expand="false"
                            @change="handleAreaChange"
                        />
                    </el-form-item>
                    <RegionSelect
                        v-model="formData.areaCode"
                        placeholder="请选择"
                        @change="handleAreaChange"
                    />
                </el-form-item>
                </el-col>
                <el-col :span="12">
                    <el-form-item label="实施清单名称" prop="implementName">
@@ -106,7 +95,8 @@
import { computed, ref, inject } from 'vue'
import { ElMessage } from 'element-plus'
import { fieldRules } from '@ztzf/utils'
import { inventorySubmitApi, inventoryDetailApi, regionLazyTreeApi } from './inventoryApi'
import { inventorySubmitApi, inventoryDetailApi } from './inventoryApi'
import RegionSelect from '@/components/RegionSelect/main.vue'

// 初始化表单数据
const initForm = () => ({
@@ -135,20 +125,6 @@
const submitting = ref(false) // 提交中
const dialogReadonly = computed(() => dialogMode.value === 'view')
const titleEnum = ref({ edit: '编辑', view: '查看', add: '新增' })
const expandedKeys = ref([]) // 树形选择器展开的节点
const regionNodeCache = ref(new Map()) // 缓存区域节点及其父节点关系

// 区域树形选择器配置
const treeSelectProps = ref({
    value: 'id',
    label: 'name',
    children: 'children',
    // 判断叶子节点
    isLeaf: (data, node) => {
        // 如果是第二级节点，则认为是叶子节点
        return node.level >= 2
    },
})

// 表单校验规则
const rules = {
@@ -188,10 +164,14 @@
        formData.value.areaName = ''
        return
    }
    // 从缓存中获取区域名称
    const node = regionNodeCache.value.get(value)
    if (node) {
        formData.value.areaName = node.name || ''
    // 处理RegionSelect组件传递的包含code和name的对象
    if (typeof value === 'object' && value.code) {
        formData.value.areaCode = value.code
        formData.value.areaName = value.name || ''
    } else {
        // 兼容旧的字符串值格式
        formData.value.areaCode = value
        formData.value.areaName = ''
    }
}

@@ -220,62 +200,6 @@
        data.areaCode = String(data.areaCode)
    }
    formData.value = data

    // 如果是编辑模式，获取区域节点的路径以展开树形选择器
    if (dialogMode.value === 'edit' && data.areaCode) {
        await loadRegionPath(data.areaCode)
    }
}

// 加载区域节点路径
async function loadRegionPath(areaCode) {
    try {
        const path = []
        const queue = [{ code: '360800000000', currentPath: ['360800000000'] }]
        let found = false

        // 广度优先搜索，逐层加载节点直到找到目标节点
        while (queue.length > 0 && !found) {
            const { code, currentPath } = queue.shift()

            // 获取当前节点的子节点
            const res = await regionLazyTreeApi({ parentCode: code })
            const nodes = res?.data?.data || []

            for (const node of nodes) {
                const nodeId = node.id || node.value

                // 缓存节点及其父节点关系
                regionNodeCache.value.set(nodeId, {
                    id: nodeId,
                    name: node.name || node.title || node.label,
                    parentId: code,
                    hasChildren: node.hasChildren || false,
                })

                // 检查是否找到目标节点
                if (nodeId === areaCode) {
                    path.push(...currentPath, nodeId)
                    found = true
                    break
                }

                // 如果有子节点，加入队列继续搜索
                if (node.hasChildren) {
                    queue.push({
                        code: nodeId,
                        currentPath: [...currentPath, nodeId],
                    })
                }
            }
        }

        if (path.length > 0) {
            expandedKeys.value = path
        }
    } catch (error) {
        console.error('加载区域路径失败:', error)
    }
}

// 打开弹框
@@ -284,45 +208,6 @@
    formData.value = dialogMode.value === 'add' ? initForm() : row
    if (dialogMode.value !== 'add') {
        await loadDetail()
    }
}

// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
    try {
        // 限制只加载两级，当前节点 level >= 1 时不加载子节点
        if (node.level >= 2) {
            resolve([])
            return
        }
        // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
        const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
        const parentCode = node.data?.id || '360800000000'
        const res = await regionLazyTreeApi(params)
        const nodes = res?.data?.data || []

        // 处理返回的节点数据
        const processedNodes = nodes.map(item => {
            const nodeId = item.id || item.value
            // 缓存节点及其父节点关系
            regionNodeCache.value.set(nodeId, {
                id: nodeId,
                name: item.name || item.title || item.label,
                parentId: parentCode,
                hasChildren: item.hasChildren || false,
            })

            return {
                id: nodeId,
                name: item.name || item.title || item.label,
                hasChildren: item.hasChildren || false,
            }
        })

        resolve(processedNodes)
    } catch (error) {
        console.error('获取区域数据失败:', error)
        resolve([])
    }
}


 applications/task-work-order/src/views/orderView/appConfiguration/inventory/index.vue

@@ -2,22 +2,13 @@
    <basic-container>
        <el-form ref="queryParamsRef" :model="searchParams" class="gd-search-form">
            <el-form-item label="所属区划" prop="areaCode">
                <el-tree-select
                    class="gd-select gray"
                    popper-class="gd-tree-select-popper"
                    v-model="searchParams.areaCode"
                    node-key="id"
                    :props="treeSelectProps"
                    placeholder="请选择"
                    clearable
                    filterable
                    @change="handleSearch"
                    :check-strictly="true"
                    lazy
                    :load="loadRegionNode"
                    :render-after-expand="false"
                />
            </el-form-item>
            <RegionSelect
                class="gd-select gray"
                v-model="searchParams.areaCode"
                placeholder="请选择"
                @change="handleSearch"
            />
        </el-form-item>
             <el-form-item label="实施清单名称" prop="implementName">
                <el-input
                    class="gd-input gray"
@@ -105,7 +96,8 @@
import { ElMessage, ElMessageBox } from 'element-plus'
import FormDiaLog from './FormDiaLog.vue'
import ConfigDiaLog from './ConfigDiaLog.vue'
import { inventoryPageApi, inventoryRemoveApi, regionLazyTreeApi, deptTreeApi } from './inventoryApi'
import { inventoryPageApi, inventoryRemoveApi, deptTreeApi } from './inventoryApi'
import RegionSelect from '@/components/RegionSelect/main.vue'

// 初始化查询参数
const initSearchParams = () => ({
@@ -129,17 +121,6 @@
const dictObj = ref({}) // 字典对象
const deptTree = ref([]) // 部门树数据

// 树形选择器配置
const treeSelectProps = {
    value: 'id',
    label: 'name',
    children: 'children',
    // 添加isLeaf配置，告诉组件如何判断叶子节点
    isLeaf: (data, node) => {
        return data.leaf === true
    },
}

// 部门树配置
const treeProps = {
    value: 'id',
@@ -152,40 +133,7 @@
provide('deptTree', deptTree)
provide('treeProps', treeProps)

// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
    try {
        // 限制只加载两级，当前节点 level >= 1 时不加载子节点
        if (node.level >= 2) {
            resolve([])
            return
        }

        // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
        const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
        const res = await regionLazyTreeApi(params)
        const nodes = res?.data?.data || []

        // 处理返回的节点数据
        const processedNodes = nodes.map(item => {
            // 判断是否为叶子节点：如果是第二级（node.level === 1）则为叶子节点
            const isLeaf = node.level === 1

            return {
                id: item.id || item.value,
                name: item.name || item.title || item.label,
                hasChildren: item.hasChildren || false,
                // 关键：设置leaf属性，告知Tree组件该节点是否为叶子节点
                leaf: isLeaf,
            }
        })

        resolve(processedNodes)
    } catch (error) {
        console.error('获取区域数据失败:', error)
        resolve([])
    }
}

// 获取部门树数据
async function getDeptTree() {

 applications/task-work-order/src/views/orderView/organizational/agenciesManagement/FormDiaLog.vue

@@ -43,20 +43,10 @@
        </el-col>
        <el-col :span="12">
          <el-form-item label="所属区划" prop="areaCode">
            <el-tree-select
            <RegionSelect
              class="gd-select"
              popper-class="gd-tree-select-popper"
              v-model="formData.areaCode"
              node-key="id"
              :default-expanded-keys="expandedKeys"
              :props="treeSelectProps"
              placeholder="请选择"
              clearable
              filterable
              :check-strictly="true"
              lazy
              :load="loadRegionNode"
              :render-after-expand="false"
            />
          </el-form-item>
        </el-col>
@@ -109,9 +99,9 @@
import { fieldRules } from '@ztzf/utils'
import {
  agenciesSubmitApi,
  agenciesDetailApi,
  regionLazyTreeApi
  agenciesDetailApi
} from './agenciesApi'
import RegionSelect from '@/components/RegionSelect/main.vue'

// 初始化表单数据
const initForm = () => ({
@@ -133,18 +123,7 @@
const submitting = ref(false) // 提交中
const dialogReadonly = computed(() => dialogMode.value === 'view')
const titleEnum = ref({ edit: '编辑', view: '查看', add: '新增' })
const expandedKeys = ref([]) // 树形选择器展开的节点
const regionNodeCache = ref(new Map()) // 缓存区域节点及其父节点关系
const treeSelectProps = ref({
  value: 'id',
  label: 'name',
  children: 'children',
  // 判断叶子节点
  isLeaf: (data, node) => {
    // 如果是第二级节点，则认为是叶子节点
    return node.level >= 2
  }
})

const rules = {
  deptName: fieldRules(true),
  areaCode: fieldRules(true),
@@ -181,62 +160,6 @@
    data.areaCode = String(data.areaCode)
  }
  formData.value = data
  
  // 如果是编辑模式，获取区域节点的路径以展开树形选择器
  if (dialogMode.value === 'edit' && data.areaCode) {
    await loadRegionPath(data.areaCode)
  }
}

// 加载区域节点路径
async function loadRegionPath(areaCode) {
  try {
    const path = []
    const queue = [{ code: '360800000000', currentPath: ['360800000000'] }]
    let found = false
    
    // 广度优先搜索，逐层加载节点直到找到目标节点
    while (queue.length > 0 && !found) {
      const { code, currentPath } = queue.shift()
      
      // 获取当前节点的子节点
      const res = await regionLazyTreeApi({ parentCode: code })
      const nodes = res?.data?.data || []
      
      for (const node of nodes) {
        const nodeId = node.id || node.value
        
        // 缓存节点及其父节点关系
        regionNodeCache.value.set(nodeId, {
          id: nodeId,
          name: node.name || node.title || node.label,
          parentId: code,
          hasChildren: node.hasChildren || false
        })
        
        // 检查是否找到目标节点
        if (nodeId === areaCode) {
          path.push(...currentPath, nodeId)
          found = true
          break
        }
        
        // 如果有子节点，加入队列继续搜索
        if (node.hasChildren) {
          queue.push({
            code: nodeId,
            currentPath: [...currentPath, nodeId]
          })
        }
      }
    }
    
    if (path.length > 0) {
      expandedKeys.value = path
    }
  } catch (error) {
    console.error('加载区域路径失败:', error)
  }
}

// 打开弹框
@@ -245,44 +168,6 @@
  formData.value = dialogMode.value === 'add' ? initForm() : row
  if (dialogMode.value !== 'add') {
    await loadDetail()
  }
}
// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
  try {
      // 限制只加载两级，当前节点 level >= 1 时不加载子节点
    if (node.level >= 2) {
      resolve([])
      return
    }
    // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
    const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
    const parentCode = node.data?.id || '360800000000'
    const res = await regionLazyTreeApi(params)
    const nodes = res?.data?.data || []
    
    // 处理返回的节点数据
    const processedNodes = nodes.map(item => {
      const nodeId = item.id || item.value
      // 缓存节点及其父节点关系
      regionNodeCache.value.set(nodeId, {
        id: nodeId,
        name: item.name || item.title || item.label,
        parentId: parentCode,
        hasChildren: item.hasChildren || false
      })
      
      return {
        id: nodeId,
        name: item.name || item.title || item.label,
        hasChildren: item.hasChildren || false
      }
    })
    
    resolve(processedNodes)
  } catch (error) {
    console.error('获取区域数据失败:', error)
    resolve([])
  }
}


 applications/task-work-order/src/views/orderView/organizational/agenciesManagement/index.vue

@@ -22,20 +22,13 @@
      </el-form-item>

      <el-form-item label="所属区划" prop="areaCode">
        <el-tree-select
        <RegionSelect
          class="gd-select gray"
          popper-class="gd-tree-select-popper"
          v-model="searchParams.areaCode"
          node-key="id"
          :props="treeSelectProps"
          placeholder="请选择"
          clearable
          filterable
          @change="handleSearch"
          :check-strictly="true"
          lazy
          :load="loadRegionNode"
          :render-after-expand="false"
        />
      </el-form-item>

@@ -146,13 +139,13 @@
import { onMounted, ref, provide, nextTick } from 'vue'
import { ElMessage, ElMessageBox, ElUpload } from 'element-plus'
import FormDiaLog from './FormDiaLog.vue'
import RegionSelect from '@/components/RegionSelect/main.vue'
import {
  agenciesPageApi,
  agenciesRemoveApi,
  agenciesImportApi,
  agenciesExportApi,
  agenciesExportTemplateApi,
  regionLazyTreeApi,
  agenciesSubmitApi
} from './agenciesApi'
import { getDictionaryByCode } from '@/api/system/dictbiz'
@@ -176,17 +169,6 @@
const regionOptions = ref([]) // 区域选项
const dictObj = ref({}) // 字典对象
const selectedFiles = ref([]) // 勾选的文件列表

// 树形选择器配置
const treeSelectProps = {
  value: 'id',
  label: 'name',
  children: 'children',
  // 添加isLeaf配置，告诉组件如何判断叶子节点
  isLeaf: (data, node) => {
    return data.leaf === true
  }
}
// 导入机构相关
const isShowImportView = ref(false)
const importFileName = ref('')
@@ -214,41 +196,6 @@
  getDictionaryByCode('institutionStatus').then(res => {
            dictObj.value = res.data.data
  })
}

// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
  try {
    // 限制只加载两级，当前节点 level >= 1 时不加载子节点
    if (node.level >= 2) {
      resolve([])
      return
    }
    
    // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
    const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
    const res = await regionLazyTreeApi(params)
    const nodes = res?.data?.data || []
    
    // 处理返回的节点数据
    const processedNodes = nodes.map(item => {
      // 判断是否为叶子节点：如果是第二级（node.level === 1）则为叶子节点
      const isLeaf = node.level === 1
      
      return {
        id: item.id || item.value,
        name: item.name || item.title || item.label,
        hasChildren: item.hasChildren || false,
        // 关键：设置leaf属性，告知Tree组件该节点是否为叶子节点
        leaf: isLeaf
      }
    })
    
    resolve(processedNodes)
  } catch (error) {
    console.error('获取区域数据失败:', error)
    resolve([])
  }
}
// 获取列表
async function getList() {

 applications/task-work-order/src/views/orderView/organizational/zoningManagement/FormDiaLog.vue

@@ -56,20 +56,10 @@
        </el-col>
        <el-col :span="12">
          <el-form-item label="上级区划" prop="parentCode">
            <el-tree-select
            <RegionSelect
              class="gd-select"
              popper-class="gd-tree-select-popper"
              v-model="formData.parentCode"
              node-key="id"
              :default-expanded-keys="expandedKeys"
              :props="treeSelectProps"
              placeholder="请选择"
              clearable
              filterable
              :check-strictly="true"
              lazy
              :load="loadRegionNode"
              :render-after-expand="false"
            />
          </el-form-item>
        </el-col>
@@ -132,19 +122,10 @@
import { fieldRules } from '@ztzf/utils'
import {
  zoningSubmitApi,
  zoningDetailApi,
  regionLazyTreeApi
  zoningDetailApi
} from './zoningApi'
const treeSelectProps = ref({
  value: 'id',
  label: 'name',
  children: 'children',
  // 判断叶子节点
  isLeaf: (data, node) => {
    // 如果是第二级节点，则认为是叶子节点
    return node.level >= 2
  }
})
import RegionSelect from '@/components/RegionSelect/main.vue'

// 初始化表单数据
const initForm = () => ({
  code: '',
@@ -168,8 +149,6 @@
const submitting = ref(false) // 提交中
const dialogReadonly = computed(() => dialogMode.value === 'view')
const titleEnum = ref({ edit: '编辑', view: '查看', add: '新增' })
const expandedKeys = ref([]) // 树形选择器展开的节点
const regionNodeCache = ref(new Map()) // 缓存区域节点及其父节点关系

const rules = {
  code: fieldRules(true),
@@ -212,62 +191,6 @@
    data.parentCode = String(data.parentCode)
  }
  formData.value = data
  
  // 如果是编辑模式，获取区域节点的路径以展开树形选择器
  if (dialogMode.value === 'edit' && data.parentCode) {
    await loadRegionPath(data.parentCode)
  }
}

// 加载区域节点路径
async function loadRegionPath(parentCode) {
  try {
    const path = []
    const queue = [{ code: '360800000000', currentPath: ['360800000000'] }]
    let found = false
    
    // 广度优先搜索，逐层加载节点直到找到目标节点
    while (queue.length > 0 && !found) {
      const { code, currentPath } = queue.shift()
      
      // 获取当前节点的子节点
      const res = await regionLazyTreeApi({ parentCode: code })
      const nodes = res?.data?.data || []
      
      for (const node of nodes) {
        const nodeId = node.id || node.value
        
        // 缓存节点及其父节点关系
        regionNodeCache.value.set(nodeId, {
          id: nodeId,
          name: node.name || node.title || node.label,
          parentId: code,
          hasChildren: node.hasChildren || false
        })
        
        // 检查是否找到目标节点
        if (nodeId === parentCode) {
          path.push(...currentPath, nodeId)
          found = true
          break
        }
        
        // 如果有子节点，加入队列继续搜索
        if (node.hasChildren) {
          queue.push({
            code: nodeId,
            currentPath: [...currentPath, nodeId]
          })
        }
      }
    }
    
    if (path.length > 0) {
      expandedKeys.value = path
    }
  } catch (error) {
    console.error('加载区域路径失败:', error)
  }
}

// 打开弹框
@@ -276,44 +199,6 @@
  formData.value = dialogMode.value === 'add' ? initForm() : row
  if (dialogMode.value !== 'add') {
    await loadDetail()
  }
}
// 懒加载获取区域节点数据
async function loadRegionNode(node, resolve) {
  try {
      // 限制只加载两级，当前节点 level >= 1 时不加载子节点
    if (node.level >= 2) {
      resolve([])
      return
    }
    // 初始化加载时传递 code 参数，加载子节点时传递 parentCode 参数
    const params = node.data?.id ? { parentCode: node.data.id } : { code: '360800000000' }
    const parentCode = node.data?.id || '360800000000'
    const res = await regionLazyTreeApi(params)
    const nodes = res?.data?.data || []
    
    // 处理返回的节点数据
    const processedNodes = nodes.map(item => {
      const nodeId = item.id || item.value
      // 缓存节点及其父节点关系
      regionNodeCache.value.set(nodeId, {
        id: nodeId,
        name: item.name || item.title || item.label,
        parentId: parentCode,
        hasChildren: item.hasChildren || false
      })
      
      return {
        id: nodeId,
        name: item.name || item.title || item.label,
        hasChildren: item.hasChildren || false
      }
    })
    
    resolve(processedNodes)
  } catch (error) {
    console.error('获取区域数据失败:', error)
    resolve([])
  }
}
defineExpose({ open })