@yorha2b-lab/autodev 7.7.8 → 7.8.1

package/src/workshop/react/extensions/useTableQuery.js

@@ -1,35 +1,8 @@
 import { useRef, useState, useEffect, useCallback } from 'react'
 
-/**
- * @hook useTableQuery
- * @description [地堡核心逻辑引擎] 高级异步数据驱动钩子。
- * 负责全自动管理表格的生命周期，包括数据抓取、状态同步、动态列指纹识别及“竞态病毒”物理免疫。
- *
- * @param {Object} params - 引擎配置包
- * @param {Array} [params.cols] - 初始战备物资：前端预设的静态列配置
- * @param {Function} params.api - 任务指令：必须返回 Promise 的数据抓取函数
- * @param {Object} [params.initialParams={}] - 初始导航坐标：包含 pageNo, pageSize 及默认过滤参数
- * @param {Function} params.formatResponse - 数据解码协议：将 API 原始信号转化为 { data, total, columns } 结构
- *
- * @returns {Object} 物理操作句柄包
- * @returns {number} .total - 仓库物资总量
- * @returns {boolean} .loading - 引擎负载状态
- * @returns {Function} .setSearch - 坐标修改器
- * @returns {Array} .dataSource - 已解压的物理物资列表
- * @returns {Function} .setLoading - 负载状态手动干预句柄
- * @returns {Object} .search - 当前导航参数（pageNo, pageSize 等）
- * @returns {Function} .refresh - 强制重启协议：立即执行一次数据抓取
- * @returns {Array} .columns - 当前生效的动态列配置（已通过指纹协议校验）
- * @returns {Function} .setDataSource - 物资流手动修改句柄（用于行内编辑等乐观更新）
- *
- * @example
- * const { dataSource, loading, refresh } = useTableQuery({
- *   api:async params=>await fetchUsers(params),
- *   initialParams: { pageNo: 1, pageSize: 10 },
- *   formatResponse: (res) => ({ data: res.list, total: res.total })
- * });
- */
-export const useTableQuery = ({ api, cols = [], initialParams = {}, formatResponse, isLocalPaging = false }) => {
+const getColumnSchema = cols => cols.map(col => `${col.title}-${col.dataIndex}-${col.sortOrder}`).join('|')
+
+export const useTableQuery = ({ api, cols = [], initialParams = {}, formatResponse }) => {
 
     const [total, setTotal] = useState(0)
     const [columns, setColumns] = useState(cols)
@@ -37,13 +10,8 @@ export const useTableQuery = ({ api, cols = [], initialParams = {}, formatRespon
     const [dataSource, setDataSource] = useState([])
     const [search, setSearch] = useState(initialParams)
 
-    // 💡 引用锁定协议：确保异步回调中永远能指向最新的指令地址
     const apiRef = useRef(api)
-    // 💡 [核心防御] 信号 ID 计数器：用于物理拦截由于网络时延导致的“竞态病毒（Race Condition）”
     const fetchIdRef = useRef(0)
-    // 💡 物理记录仪：记录上一次“真正”的过滤参数（不含分页）
-    const lastFilterRef = useRef('')
-    // 💡 [核心防御] 数据解码协议引用：确保异步回调中永远能指向最新的指令地址
     const formatResponseRef = useRef(formatResponse)
 
     useEffect(() => {
@@ -54,43 +22,15 @@ export const useTableQuery = ({ api, cols = [], initialParams = {}, formatRespon
         formatResponseRef.current = formatResponse
     }, [formatResponse])
 
-    /**
-     * @function getColumnSchema
-     * @description [指纹识别协议] 对列配置执行“结构化脱水”。
-     * 通过提取标题、字段和排序状态生成物理指纹，用于判定列结构是否发生“基因变异”。
-     * @param {Array} cols - 待扫描的列配置
-     * @returns {string} 物理指纹字符串
-     */
-    const getColumnSchema = cols => cols.map(col => `${col.title}-${col.dataIndex}-${col.sortOrder}`).join('|')
-
-    /**
-     * @async
-     * @function fetchData
-     * @description [数据装配任务] 执行核心的数据抓取与物理封存逻辑。
-     * 具备信号溯源能力，确保只有最后一次发出的指令能修改地堡状态。
-     */
     const fetchData = useCallback(async () => {
         if (!apiRef.current) return
-
-        if (isLocalPaging) {
-            const currentFilter = JSON.stringify(Object.fromEntries(Object.entries(search).filter(([k]) => !['pageNo', 'pageSize'].includes(k))))
-            if (lastFilterRef.current === currentFilter && dataSource.length > 0) {
-                return
-            }
-            lastFilterRef.current = currentFilter
-        }
-
         setLoading(true)
-        // 💡 信号加标：为本次请求分配唯一的物理 ID
         const currentFetchId = ++fetchIdRef.current
         try {
             const response = await apiRef.current(search)
-            // 💡 [物理拦截] 信号校准：若当前 ID 不是最新 ID，说明该信号已过期，执行丢弃协议
             if (currentFetchId !== fetchIdRef.current) return
             const { data, total, columns: newCols } = formatResponseRef.current?.(response ?? {}) || {}
-            // 💡 [性能装甲] 只有当列指纹发生变化时，才触发 React 的重绘逻辑
             if (newCols) {
-                // 使用函数式状态更新，既能拿到最新的 prevCols，又无需将 columns 作为 useCallback 的依赖！
                 setColumns(prevCols => {
                     if (getColumnSchema(newCols) !== getColumnSchema(prevCols)) {
                         return newCols
@@ -103,12 +43,11 @@ export const useTableQuery = ({ api, cols = [], initialParams = {}, formatRespon
         } catch (error) {
             console.error('查询失败', error)
         } finally {
-            // 💡 状态闭环：确保只有最新的信号能解除 Loading 锁定
             if (currentFetchId === fetchIdRef.current) {
                 setLoading(false)
             }
         }
-    }, [search, isLocalPaging])
+    }, [search])
 
     useEffect(() => {
         fetchData()

package/src/workshop/react/kit/utils.js

@@ -1,19 +1,6 @@
 import dayjs from 'dayjs'
 import { request } from './request'
 
-/**
- * @namespace BunkerUtils
- * @description 地堡核心工具集：包含文件处理、数据脱水、视觉渲染及后勤传输协议；使用前确保已安装对应模块（如：xlsx、ali-oss、crypto-js）
- * */
-
-
-/**
- * @async
- * @function parseExcel
- * @description [后勤部] 本地 Excel 解析协议：将二进制表格物资转化为地堡可读的 JSON 序列。
- * @param {File|Blob} file - 待解析的原始文件对象
- * @returns {Promise<Array[]>} 解析后的二维数组数据
- */
 export const parseExcel = async file => {
     /* const arrayBuffer = await file.arrayBuffer()
     const XLSX = require('xlsx')
@@ -24,14 +11,16 @@ export const parseExcel = async file => {
     return excelData.filter(item => item.length > 0) */
 }
 
-/**
- * @async
- * @function initOSS
- * @description [出口协议] 阿里云 OSS 凭证初始化：从司令部申请 STS 令牌并计算物理传输签名。
- * @param {string} url - 令牌申请地址
- * @param {Object} options - 请求配置参数
- * @returns {Promise<Object>} 包含 OSS 客户端实例、上传策略及 Host 节点的配置包
- */
+export const flattenFormItems = items => {
+    if (!Array.isArray(items)) return []
+    return items.flatMap(item => {
+        if (item.childItems) {
+            return flattenFormItems(item.childItems)
+        }
+        return item
+    })
+}
+
 export const initOSS = async (url, options) => {
     /* const OSS = require('ali-oss')
     const crypto = require('crypto-js')
@@ -48,13 +37,6 @@ export const initOSS = async (url, options) => {
     return { client, policy, signature,host: `https://${bucket}.${endpoint.split('//')[1]}`, ...response?.data } */
 }
 
-/**
- * @function formatQuery
- * @description [数据脱水] 搜索参数校准协议：根据零部件类型（如日期）自动执行类型转换（String -> Number）。
- * @param {Array} formItems - 对应的零部件配置清单
- * @param {Object} params - 原始表单/URL 传感器数据
- * @returns {Object} 经过物理清洗、可直接用于 API 请求的参数包
- */
 export const formatQuery = (params, formItems) => {
     const cleanParams = {}
     Object.keys(params).forEach(key => {
@@ -67,15 +49,6 @@ export const formatQuery = (params, formItems) => {
     return cleanParams
 }
 
-/**
- * @function timeRender
- * @description [视觉渲染] 时间戳格式化：将冷冰冰的数字转化为人类可读的时间字符串。
- * @param {Object} params - 渲染参数
- * @param {number|string} params.time - 原始时间戳
- * @param {boolean} [params.date] - 是否仅保留日期（YYYY-MM-DD）
- * @param {boolean} [params.minute] - 是否精确到分钟（YYYY-MM-DD HH:mm）
- * @returns {string} 格式化后的时间字符串
- */
 export const timeRender = ({ time, date, minute }) => {
     if (!time) {
         return ''
@@ -90,16 +63,6 @@ export const timeRender = ({ time, date, minute }) => {
     }
 }
 
-/**
- * @async
- * @function exportDataToExcel
- * @description [物资外运] 数据表格导出协议：支持复杂的渲染逻辑回溯，将页面数据封存为 .xlsx 格式。
- * @param {string} url - 数据源地址
- * @param {Object} options - 请求参数
- * @param {string} fileName - 导出的文件名
- * @param {Function} [formatter] - 数据预处理回调
- * @param {Array} columns - 表格列配置，支持 exportRender 优先级
- */
 export const exportDataToExcel = async ({ url, options, columns, fileName, formatter }) => {
     /* const response = await request(url, options)
     const result = formatter ? formatter(response) : (response?.data ?? [])
@@ -125,16 +88,47 @@ export const exportDataToExcel = async ({ url, options, columns, fileName, forma
     } */
 }
 
-/**
- * @async
- * @function streamDownload
- * @description [后勤传输] 智能流式下载协议：具备“语义侦察”能力，能自动识别被伪装成二进制流的 JSON 报错信息。
- * @param {Object} params - 传输配置
- * @param {string} params.url - 物资下载地址
- * @param {Object} [params.options] - Fetch 配置
- * @param {Object} [params.headers] - 自定义请求头
- * @param {string} [fileName='下载'] - 预设文件名（支持从 Content-Disposition 自动对齐）
- */
+export const arrayToTree = (list, levels, keys = { title: 'title', value: 'value', children: 'children' }) => {
+    const tree = []
+    const maps = levels.map(() => new Map())
+    list.forEach(item => {
+        let parent = tree
+        levels.forEach(({ code, name }, index) => {
+            const map = maps[index]
+            const id = item[code]
+            if (!map.has(id)) {
+                const node = { [keys.title]: item[name], [keys.value]: id, ...(index < levels.length - 1 ? { [keys.children]: [] } : {}) }
+                map.set(id, node)
+                parent.push(node)
+            }
+            const node = map.get(id)
+            parent = node[keys.children] ?? []
+        })
+    })
+    return tree
+}
+
+export const moneyRender = (value, { decimals = 2, currency = 'CNY', language = 'zh-CN', showSymbol = true } = {}) => {
+    if (value === null || value === undefined || value === '') return '-'
+    const number = Number(value)
+    if (isNaN(number)) return '-'
+    const options = showSymbol
+        ? { style: 'currency', currency, minimumFractionDigits: decimals }
+        : { style: 'decimal', minimumFractionDigits: decimals, maximumFractionDigits: decimals }
+    return new Intl.NumberFormat(language, options).format(number)
+}
+
+export const formatUnit = (value, { k = 1024, units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'], decimals = 2 } = {}) => {
+    if (value === null || value === undefined || isNaN(value) || value === 0) {
+        return `0 ${units[0] ?? ''}`
+    }
+    const absValue = Math.abs(value)
+    const i = absValue < 1 ? 0 : Math.floor(Math.log(absValue) / Math.log(k))
+    const index = Math.min(i, units.length - 1)
+    const result = (value / Math.pow(k, index)).toFixed(decimals)
+    return `${parseFloat(result)} ${units[index]}`
+}
+
 export const streamDownload = async ({ url, options, headers = { 'Content-Type': 'application/json' } }, fileName = '下载') => {
 
     const response = await fetch(url, { ...options, headers })
@@ -151,7 +145,6 @@ export const streamDownload = async ({ url, options, headers = { 'Content-Type':
         return
     }
 
-    // 💡 语义侦察逻辑：检查前 10 个字节，判断是否为 JSON 报错信息
     const slice = blob.slice(0, 10)
     const text = (await slice.text()).trim()
 
@@ -166,7 +159,6 @@ export const streamDownload = async ({ url, options, headers = { 'Content-Type':
         return
     }
 
-    // 物理解析 Content-Disposition 头部，获取指挥官预设的文件名
     const disposition = response.headers.get('content-disposition')
     let name = fileName
 
@@ -188,47 +180,4 @@ export const streamDownload = async ({ url, options, headers = { 'Content-Type':
     link.remove()
 
     setTimeout(() => URL.revokeObjectURL(urlObj), 1000)
-}
-
-/**
- * @function moneyRender
- * @description [视觉渲染] 金额校准渲染：支持多国语境、货币符号及精度控制。
- * @param {number|string} value - 原始金额数值
- * @param {Object} [options] - 配置参数
- * @param {number} [options.decimals=2] - 小数位数
- * @param {string} [options.currency='CNY'] - 货币代号
- * @param {string} [options.language='zh-CN'] - 语言环境
- * @param {boolean} [options.showSymbol=true] - 是否显示货币符号
- * @returns {string} 格式化后的金额文本
- */
-export const moneyRender = (value, { decimals = 2, currency = 'CNY', language = 'zh-CN', showSymbol = true } = {}) => {
-    if (value === null || value === undefined || value === '') return '-'
-    const number = Number(value)
-    if (isNaN(number)) return '-'
-    const options = showSymbol
-        ? { style: 'currency', currency, minimumFractionDigits: decimals }
-        : { style: 'decimal', minimumFractionDigits: decimals, maximumFractionDigits: decimals }
-    return new Intl.NumberFormat(language, options).format(number)
-}
-
-/**
- * @function formatUnit
- * @description [视觉渲染] 单位自动进阶协议：实现 B/KB/MB... 等数据的物理量级自动折算。
- * @param {number} value - 原始字节数值
- * @param {Object} [options] - 配置参数
- * @param {Array} [options.units] - 单位阶梯
- * @param {number} [options.k=1024] - 进位系数
- * @param {number} [options.decimals=2] - 保留小数位
- * @returns {string} 带单位的物理量级文本
- */
-export const formatUnit = (value, { k = 1024, units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'], decimals = 2 } = {}) => {
-    if (value === null || value === undefined || isNaN(value) || value === 0) {
-        return `0 ${units[0] ?? ''}`
-    }
-    const absValue = Math.abs(value)
-    // 💡 安全屏障：小于 1 的数值直接归入初始级单位，不进行对数拆解
-    const i = absValue < 1 ? 0 : Math.floor(Math.log(absValue) / Math.log(k))
-    const index = Math.min(i, units.length - 1)
-    const result = (value / Math.pow(k, index)).toFixed(decimals)
-    return `${parseFloat(result)} ${units[index]}`
 }

package/src/workshop/react/standardParts/AliyunOSSUpload.js

@@ -3,39 +3,12 @@ import { initOSS } from '../utils/utils'
 import { useState, useEffect } from 'react'
 import { UploadOutlined } from '@ant-design/icons'
 
-/**
- * @component AliyunOSSUpload
- * @description [地堡核心传输单元] 阿里云 OSS 高级上传组件。
- * 集成了“物理路径自动重组”、“STS 令牌自动续期”以及“ Antd 属性无损透传”三大核心协议。
- *
- * @param {Object} props - 构筑参数
- * @param {string} [props.path] - 默认存储扇区：定义文件在云端的物理根路径
- * @param {string} [props.url] - 司令部通信地址：用于申请最新的物理传输令牌 (STS)
- * @param {Array} props.value - 传感器当前封存的文件列表 (符合 Antd fileList 规范)
- * @param {Function} props.onChange - 状态反馈协议：当物理文件状态变更时同步至地堡中枢
- * @param {Object} [props.oss] - 外部空投的初始凭证包。若缺失，组件将启动自主初始化流程。
- * @param {Object} [props.options] - 通信加密/配置参数：在申请令牌时透传给 request 的额外负载
- * @param {Object} [props.originUploadProps] - [重要] 无损透传：支持 Antd Upload 的所有原生属性（如 multiple, accept 等）
- *
- * @example
- * // 基本构筑
- * <AliyunOSSUpload path='project/data' url='/api/oss/token' />
- *
- * // 高级装配（限制文件类型并开启多选）
- * <AliyunOSSUpload accept='.pdf' multiple={true} path='docs' url='/api/oss/token' />
- */
 export const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
 
-    // 💡 物理剥离：将地堡专用参数与 Antd 原生属性分离
     const { oss, url, path, options, expireField = 'expire', ...originUploadProps } = restProps
 
     const [OSSData, setOSSData] = useState(oss)
 
-    /**
-     * @async
-     * @function init
-     * @description [信号握手] 执行令牌获取协议，从司令部申请最新的物理上传授权
-     */
     const init = async () => {
         try {
             const result = await initOSS(url, options)
@@ -47,7 +20,6 @@ export const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
     }
 
     useEffect(() => {
-        // 💡 自愈逻辑：如果发现能源包 (OSSData) 为空，则自动触发初始化
         if (!OSSData) {
             init()
         }
@@ -60,11 +32,6 @@ export const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
         onChange?.(files)
     }
 
-    /**
-     * @function getExtraData
-     * @description [数据封装] 将动态生成的物理凭证与目标文件路径压入传输负载
-     * @param {Object} file - 待传输的文件对象
-     */
     const getExtraData = file => ({
         key: file.url,
         policy: OSSData?.policy,
@@ -73,28 +40,16 @@ export const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
         'x-oss-security-token': OSSData?.stsToken,
     })
 
-    /**
-     * @async
-     * @function beforeUpload
-     * @description [生存期侦察] 在传输启动前执行 TTL 检测。
-     * 若令牌已失效（过期），则强行拦截并执行同步刷新协议，同时执行物理路径归一化。
-     */
     const beforeUpload = async file => {
         let currentOSS = OSSData
         const expire = Number(OSSData?.[expireField] ?? 0) * 1000
         if (expire < Date.now()) {
             currentOSS = await init()
         }
-        // 💡 物理路径重组：通过正则清除多余的路径分隔符，确保存储节点坐标唯一
         file.url = `${currentOSS?.dir ?? path}/${file.uid}_${file.name}`.replace(/\/\//g, '/')
         return file
     }
 
-    /**
-     * @constant uploadProps
-     * @description [物理合并] 最终生成的 Antd Upload 指令集：
-     * 自动优先应用 originUploadProps 中的自定义设置。
-     */
     const uploadProps = {
         onRemove,
         name: 'file',

package/src/workshop/react/standardParts/DraggableContainer.js

@@ -1,3 +1,5 @@
+import { useContext } from 'react'
+import { TableContext } from './MyTable'
 import { SortableContainer } from 'react-sortable-hoc'
 
 const SortableBody = SortableContainer(props => <tbody {...props} />)
@@ -9,14 +11,16 @@ const arrayMoveImmutable = (array, oldIndex, newIndex) => {
     return newArray
 }
 
-export const DraggableContainer = ({ props, customSave, setDataSource, dataSourceRef }) => {
+export const DraggableContainer = props => {
+
+    const { customSave, setDataSource, dataSourceRef } = useContext(TableContext)
 
     const onSortEnd = ({ oldIndex, newIndex }) => {
         if (oldIndex !== newIndex) {
             const currentData = dataSourceRef?.current || []
             const sortedDataSource = arrayMoveImmutable(currentData.slice(), oldIndex, newIndex)
             setDataSource(sortedDataSource)
-            customSave?.(sortedDataSource)
+            customSave?.({}, sortedDataSource)
         }
     }
 

package/src/workshop/react/standardParts/EditableCell.js

@@ -1,37 +1,26 @@
 import { SortableElement } from 'react-sortable-hoc'
-import { Form, Input, InputNumber, Select, Checkbox } from 'antd'
-import React, { useRef, useState, useEffect, useContext } from 'react'
+import { Form, Input, InputNumber, Select, Checkbox, TreeSelect } from 'antd'
+import { useRef, useState, useEffect, useContext, createContext } from 'react'
 
-/**
- * @constant EditableContext
- * @description [地堡跨组件通信协议] 用于在行（Row）与单元格（Cell）之间共享 Form 传感器的物理句柄。
- */
-const EditableContext = React.createContext(null)
+const EditableContext = createContext(null)
 
 const SortableItem = SortableElement((props) => <tr {...props} />)
 
-/**
- * @component EditableRow
- * @description [地堡战术行容器] 每一行都是一个独立的逻辑闭环。
- * 负责初始化 Form 实例并执行“行级数据同步”与“变动传感监听”。
- *
- * @param {Object} props - 组件属性
- * @param {number} props.index - 行物理索引
- * @param {Object} props.record - 初始物资包（当前行数据）
- * @param {Function} [props.onValuesChange] - 联动传感：监听行内任何零部件的值变动
- */
-export const EditableRow = ({ index, record, draggable, ...props }) => {
+export const EditableRow = ({ index, record, columns, draggable, ...props }) => {
 
     const [form] = Form.useForm()
 
-    /**
-     * @description [数据热更协议] 当外部记录发生变化时，物理同步至内部表单传感器。
-     */
     useEffect(() => {
         if (record) {
-            form.setFieldsValue(record)
+            const extra = {}
+            columns.forEach(col => {
+                if (col.dataIndex in record && col.mode) {
+                    extra[col.dataIndex] = record[col.dataIndex]?.toString()?.split(',') || []
+                }
+            })
+            form.setFieldsValue({ ...record, ...extra })
         }
-    }, [record])
+    }, [record, columns, form])
 
     return (
         <Form form={form} component={false} onValuesChange={(changedValue, allValue) => props?.onValuesChange?.({ changedValue, allValue, form })}>
@@ -42,34 +31,14 @@ export const EditableRow = ({ index, record, draggable, ...props }) => {
     )
 }
 
-/**
- * @component EditableCell
- * @description [地堡精密编辑单元] 最小物理作战单位。
- * 支持多种装配模式（text/number/select/checkbox），并具备“自动对焦”与“失焦自愈（自动保存）”功能。
- *
- * @param {Object} props - 构筑参数
- * @param {Array} [props.rules=[]] - 逻辑校验准则
- * @param {Object} props.record - 当前行原始物资数据
- * @param {boolean} props.disabled - 物理锁定：是否禁止修改
- * @param {string} props.title - 零部件视觉标题，兼作占位符使用
- * @param {React.ReactNode} props.children - 默认展示的视觉节点
- * @param {boolean} props.editable - 权限协议：是否允许开启编辑模式
- * @param {string} props.dataIndex - 逻辑寻址地址：对应后端数据的字段名
- * @param {Array} [props.options=[]] - 数据字典（仅用于 select/checkbox）
- * @param {Function} props.handleSave - 物理封存协议：数据校验通过后的保存回调
- * @param {boolean} [props.defaultEdit] - 持久化模式：是否默认始终开启编辑状态
- * @param {string} [props.editType='text'] - 零部件型号（text/number/select/checkbox）
- */
-export const EditableCell = ({ title, record, editable, disabled, children, dataIndex, placeholder, handleSave, defaultEdit, editRender, rules = [], options = [], editType = 'text', ...restProps }) => {
+export const EditableCell = ({ mode, title, record, rowKey, editMode, editable, disabled, children, dataIndex, editingKey, dependencies, placeholder, handleSave, defaultEdit, editRender, rules = [], options = [], editType = 'text', ...restProps }) => {
 
     const inputRef = useRef(null)
+    const editingKeyRef = useRef(editingKey)
     const form = useContext(EditableContext)
 
     const [editing, setEditing] = useState(false)
 
-    /**
-     * @description [自动对焦协议] 当单元格进入“骇入模式”时，光标自动锁定，提升作战效率。
-     */
     useEffect(() => {
         if (editing) {
             if (inputRef.current && typeof inputRef.current.focus === 'function') {
@@ -78,23 +47,24 @@ export const EditableCell = ({ title, record, editable, disabled, children, data
         }
     }, [editing])
 
-    /**
-     * @function toggleEdit
-     * @description 切换“观察/骇入”模式，并执行初始信号同步。
-     */
+    useEffect(() => {
+        if (editingKeyRef.current !== editingKey) {
+            editingKeyRef.current = editingKey
+            inputRef.current?.blur()
+        }
+    }, [editingKey])
+
     const toggleEdit = () => {
-        setEditing(!editing)
-        form.setFieldsValue({ [dataIndex]: record[dataIndex] })
+        setEditing(prev => !prev)
+        form.setFieldsValue({ [dataIndex]: mode ? record[dataIndex]?.toString()?.split(',') || [] : record[dataIndex] })
     }
 
-    /**
-     * @async
-     * @function save
-     * @description 执行“物理封存协议”：触发表单校验，通过后自动关闭编辑状态并向中枢发送保存请求。
-     */
     const save = async () => {
         try {
             const values = await form.validateFields()
+            if (mode) {
+                values[dataIndex] = values[dataIndex]?.join(',')
+            }
             if (!defaultEdit) {
                 toggleEdit()
             }
@@ -108,6 +78,7 @@ export const EditableCell = ({ title, record, editable, disabled, children, data
 
     const formProps = {
         rules,
+        dependencies,
         name: dataIndex,
         style: { margin: 0 },
     }
@@ -119,22 +90,21 @@ export const EditableCell = ({ title, record, editable, disabled, children, data
     }
 
     switch (editType) {
-        case 'select':
-            inputNode = <Select ref={inputRef} options={options} {...commonProps} />
-            break;
         case 'number':
             inputNode = <InputNumber ref={inputRef} onPressEnter={save} {...commonProps} />
             break
+        case 'select':
+            inputNode = <Select ref={inputRef} mode={mode} options={options} {...commonProps} />
+            break;
+        case 'treeSelect':
+            inputNode = <TreeSelect ref={inputRef} treeData={options} {...commonProps} />
+            break;
         case 'custom':
             inputNode = editRender({ form, record, save, dataIndex, disabled, toggleEdit, commonProps })
             break
         case 'checkbox':
             inputNode = (
                 <div tabIndex={-1} onBlur={e => {
-                    /**
-                     * 💡 [地堡特有防御逻辑]：解决 Checkbox.Group 内部焦点切换导致误触发 save 的问题。
-                     * 通过 contains 判定焦点是否真正离开了当前作战区域。
-                     */
                     if (!e.currentTarget.contains(e.relatedTarget)) {
                         save()
                     }
@@ -152,17 +122,9 @@ export const EditableCell = ({ title, record, editable, disabled, children, data
     return (
         <td {...restProps}>
             {editable ? (
-                editing || defaultEdit ? (
-                    // 骇入模式：渲染输入零件
-                    <Form.Item {...(['custom', 'checkbox'].includes(editType) ? { style: formProps.style } : formProps)}>
-                        {inputNode}
-                    </Form.Item>
-                ) : (
-                    // 观察模式：渲染静态内容，点击开启骇入
-                    <div onClick={toggleEdit} className='editable-cell-value-wrap' style={{ paddingRight: 24, minHeight: 32, cursor: 'pointer' }}>
-                        {children}
-                    </div>
-                )
+                editing || defaultEdit || record[rowKey] === editingKey ?
+                    <Form.Item {...(['custom', 'checkbox'].includes(editType) ? { style: formProps.style } : formProps)}>{inputNode}</Form.Item> :
+                    <div {...(editMode === 'cellEdit' ? { onClick: toggleEdit, className: 'editable-cell-value-wrap' } : {})} style={{ paddingRight: 24, minHeight: 32, cursor: 'pointer' }}>{children}</div>
             ) : (children)}
         </td>
     )