@yorha2b-lab/autodev 7.7.8 → 7.8.0

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

@@ -16,7 +16,7 @@ export const DraggableContainer = ({ props, customSave, setDataSource, dataSourc
             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,35 +1,20 @@
 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 modeCol = columns.find(col => col.dataIndex in record && col.mode)
+            const extra = modeCol ? { [modeCol.dataIndex]: record[modeCol.dataIndex]?.toString()?.split(',') || [] } : {}
+            form.setFieldsValue({ ...record, ...extra })
         }
     }, [record])
 
@@ -42,34 +27,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 +43,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 +74,7 @@ export const EditableCell = ({ title, record, editable, disabled, children, data
 
     const formProps = {
         rules,
+        dependencies,
         name: dataIndex,
         style: { margin: 0 },
     }
@@ -119,22 +86,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 +118,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>
     )

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

@@ -3,13 +3,6 @@ import { formNode } from './index'
 import { Form, Button } from 'antd'
 import { PlusOutlined } from '@ant-design/icons'
 
-/**
- * @function getValueFromEvent
- * @description [数据拦截协议] 专门针对上传类组件的物理补丁。
- * 修正 Antd 默认将 Event 对象存入 Form 的行为，强制提取物理文件列表 (fileList)。
- * @param {Object|Array} e - 原始触发事件或文件数组
- * @returns {Array} 归一化后的文件列表
- */
 const getValueFromEvent = e => {
     if (Array.isArray(e)) {
         return e
@@ -17,24 +10,12 @@ const getValueFromEvent = e => {
     return e?.fileList
 }
 
-/**
- * @function renderFormContent
- * @description [中枢渲染逻辑] 负责装配 Form.Item 的内核。
- * 具备“路径递归”与“单位挂件”两大核心功能。
- *
- * @param {Object} params - 渲染参数
- * @param {Object} params.item - 零部件配置对象
- * @param {Array} [params.prefixName=[]] - 物理路径前缀，用于支持 Form.List 的深层嵌套
- * @returns {React.ReactNode} 装配完成的输入单元
- */
 const renderFormContent = ({ item, prefixName = [] }) => {
 
-    // 💡 物理占位逻辑：若无 name 属性，则直接输出原始 value 文本
     if (!item.name) {
-        return item.value
+        return <span dangerouslySetInnerHTML={{ __html: item.value }} />
     }
 
-    // 💡 路径自动对齐：支持字符串或数组格式的 name，自动合并前缀实现“逻辑寻址”
     const namePath = Array.isArray(prefixName) ? [...prefixName, ...(Array.isArray(item.name) ? item.name : [item.name])] : item.name
 
     const inputNode = (
@@ -43,7 +24,6 @@ const renderFormContent = ({ item, prefixName = [] }) => {
         </Form.Item>
     )
 
-    // 💡 视觉单位挂件逻辑：实现类似“金额(元)”的自动横向排版
     if (item.unit) {
         return (
             <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
@@ -56,43 +36,21 @@ const renderFormContent = ({ item, prefixName = [] }) => {
     return inputNode
 }
 
-/**
- * @component MyBaseForm
- * @description [地堡通用零部件单元] 表单系统的物理外壳。
- * 具备“单兵作战（Item）”与“集群协同（List）”两种模式切换能力。
- *
- * @param {Object} props - 组件属性
- * @param {Object} props.item - 构筑协议对象
- * @param {Object} props.form - Antd Form 实例，用于实现复杂的跨组件联动
- * @param {boolean} [props.item.isList] - 模式切换：是否开启动态增减列表模式
- * @param {Function} [props.item.render] - 逻辑劫持：支持自定义渲染函数，可完全改写渲染行为
- *
- * @example
- * // 模式 A：标准表单项
- * <MyBaseForm item={{ label: '姓名', name: 'name' }} />
- *
- * // 模式 B：动态列表项
- * <MyBaseForm item={{ isList: true, name: 'users', render: (field) => <Input {...field} /> }} />
- */
 export const MyBaseForm = ({ item, form }) => {
     return (
         item.isList ?
-            // 💡 集群模式：处理动态数组类型的表单构筑
             <Form.List name={item.name} initialValue={item.value}>
                 {(fields, { add, remove }) => (
                     <div style={{ display: 'flex', flexDirection: 'column' }}>
                         {fields.map((field, index) => (
                             <Fragment key={field.key}>
-                                {/* 物理映射：将 field 控制器回传给指挥官自定义的 render 逻辑 */}
                                 {item.render(field, index, { add, remove }, form, renderFormContent)}
                             </Fragment>
                         ))}
-                        {/* 零信号兜底：若列表为空，显示添加按钮 */}
                         {fields.length === 0 && <Button type='dashed' onClick={() => add()} block icon={<PlusOutlined />}>添加{item.label || '项'}</Button>}
                     </div>
                 )}
             </Form.List> :
-            // 💡 单兵模式：标准 Form.Item 构筑
             <Form.Item
                 label={item.label}
                 tooltip={item.tooltip}
@@ -102,11 +60,6 @@ export const MyBaseForm = ({ item, form }) => {
                 required={item.required ?? item.rules?.some(v => v.required)}
                 style={{ marginBottom: !item.name ? 0 : undefined, ...item.style }}
             >
-                {/*
-                  逻辑优先级：
-                  1. 优先使用 item.render 执行语义劫持
-                  2. 否则使用 renderFormContent 进行标准构筑
-                */}
                 {item.render ? (typeof item.render === 'function' ? item.render(item, form) : item.render) : renderFormContent({ item })}
             </Form.Item>
     )

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

@@ -1,14 +1,14 @@
 import { Form, Descriptions } from 'antd'
 import { MyBaseForm } from './MyBaseForm'
 
-export const MyDescription = ({ title, column, descriptions, form: externalForm, onValuesChange }) => {
+export const MyDescription = ({ title, column, layout = 'vertical', descriptions, form: externalForm, onValuesChange }) => {
 
     const [internalForm] = Form.useForm()
     const form = externalForm || internalForm
 
     return (
         <Form form={form} preserve={false} component={false} onValuesChange={onValuesChange}>
-            <Descriptions title={title} column={column}>
+            <Descriptions title={title} column={column} layout={layout}>
                 {descriptions.map(item => (
                     <Descriptions.Item key={item.label} label={item.name ? undefined : item.label}>
                         {item.name ? <MyBaseForm item={item} form={form} /> : item.value}