{"version":3,"file":"pro-columns.cjs","sources":["../strategy/utils/index.ts","../strategy/Search.ts","../strategy/Sort.ts","../strategy/Required.ts","../strategy/Placeholder.ts","../strategy/Format.ts","../strategy/Tooltip.ts","../strategy/DefaultValue.ts","../strategy/Width.ts","../strategy/Copy.ts","../strategy/Link.ts","../strategy/Image.ts","../strategy/Enum.ts","../strategy/Validation.ts","../strategy/Permission.ts","../strategy/Transform.ts","../strategy/Editable.ts","../strategy/index.ts","../lib/columns.ts","../lib/component.ts","../adapter/protable.ts","../adapter/proform.ts","../adapter/proDescription.ts","../presets/index.ts","../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.production.min.js","../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.development.js","../node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js","../components/ProColumnsTable/index.tsx","../components/ProColumnsForm/index.tsx","../components/ProColumnsDescription/index.tsx","../index.ts"],"sourcesContent":["import { ProColumnsType } from '../../type'\n\n/**\n * 工具函数：深度合并对象\n * @param target 目标对象\n * @param source 源对象\n * @returns 合并后的对象\n */\nexport function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {\n  const result = { ...target }\n\n  Object.keys(source).forEach((key) => {\n    const sourceValue = source[key as keyof T]\n    const targetValue = result[key as keyof T]\n\n    if (\n      sourceValue &&\n      typeof sourceValue === 'object' &&\n      !Array.isArray(sourceValue) &&\n      targetValue &&\n      typeof targetValue === 'object' &&\n      !Array.isArray(targetValue)\n    ) {\n      result[key as keyof T] = deepMerge(targetValue, sourceValue) as any\n    } else {\n      result[key as keyof T] = sourceValue as any\n    }\n  })\n\n  return result\n}\n\n/**\n * 工具函数：检查字段是否存在\n * @param column\n * @param field 字段名\n * @returns 是否存在\n */\nexport function hasField(column: ProColumnsType.ColumnType, field: string): boolean {\n  return field in column && column[field as keyof ProColumnsType.ColumnType] !== undefined\n}\n\n/**\n * 工具函数：获取字段值\n * @param column\n * @param field 字段名\n * @param defaultValue 默认值\n * @returns 字段值\n */\nexport function getField<T = any>(\n  column: ProColumnsType.ColumnType,\n  field: string,\n  defaultValue?: T\n): T | undefined {\n  return hasField(column, field)\n    ? (column[field as keyof ProColumnsType.ColumnType] as T)\n    : defaultValue\n}\n\n/**\n * 工具函数：设置字段值\n * @param column\n * @param field 字段名\n * @param value 字段值\n * @returns 新的 column\n */\nexport function setField<T = any>(\n  column: ProColumnsType.ColumnType,\n  field: string,\n  value: T\n): ProColumnsType.ColumnType {\n  return {\n    ...column,\n    [field]: value,\n  }\n}\n\n/**\n * 工具函数：判断字段类型\n * @param column\n * @returns 字段类型\n */\nexport function getFieldType(column: ProColumnsType.ColumnType): string {\n  // 优先使用 valueType\n  if (hasField(column, 'valueType')) {\n    return getField<string>(column, 'valueType', 'text') || 'text'\n  }\n\n  // 根据其他字段推断类型\n  if (hasField(column, 'valueEnum')) return 'select'\n  if (hasField(column, 'fieldProps')) {\n    const fieldProps = getField<any>(column, 'fieldProps')\n    if (fieldProps?.mode === 'multiple') return 'select'\n    if (fieldProps?.type === 'password') return 'password'\n  }\n\n  return 'text'\n}\n\n/**\n * 工具函数：生成占位符文本\n * @param column\n * @param action 操作类型：'search' | 'input' | 'select'\n * @returns 占位符文本\n */\nexport function generatePlaceholder(\n  column: ProColumnsType.ColumnType,\n  action: 'search' | 'input' | 'select' = 'input'\n): string {\n  const title = getField<string>(column, 'title', '字段')\n  const fieldType = getFieldType(column)\n\n  const actionText = {\n    search: '搜索',\n    input: '请输入',\n    select: '请选择',\n  }\n\n  // 根据字段类型决定默认操作\n  let defaultAction = action\n  if (['select', 'radio', 'checkbox', 'dateRange', 'timeRange'].includes(fieldType)) {\n    defaultAction = 'select'\n  }\n\n  return `${actionText[defaultAction]}${title}`\n}\n\n/**\n * 工具函数：创建策略函数\n * @param fn 策略处理函数（支持场景参数）\n * @returns 策略函数\n */\nexport function createStrategy(\n  fn: (column: ProColumnsType.ColumnType, scene?: ProColumnsType.Scene) => Partial<ProColumnsType.ColumnType>\n): ProColumnsType.StrategyItem {\n  return (column: ProColumnsType.ColumnType, scene?: ProColumnsType.Scene) => {\n    const updates = fn(column, scene)\n    return deepMerge(column, updates)\n  }\n}\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Search 策略配置\n */\nexport type SearchStrategyOptions = {\n  /**\n   * 是否启用搜索\n   */\n  enable?: boolean\n  /**\n   * 搜索类型映射\n   */\n  searchTypeMap?: Record<string, string>\n}\n\n/**\n * 创建 Search 策略\n * 功能：\n * 1. 为 columns 添加搜索配置\n * 2. 自动根据 valueType 设置 searchType\n * 3. 支持自定义搜索配置\n */\nconst Search = (options: SearchStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, searchTypeMap = {} } = options\n\n  // 默认搜索类型映射\n  const defaultSearchTypeMap: Record<string, string> = {\n    text: 'text',\n    textarea: 'text',\n    password: 'text',\n    digit: 'digit',\n    digitRange: 'digitRange',\n    money: 'digit',\n    date: 'date',\n    dateRange: 'dateRange',\n    dateTime: 'dateTime',\n    dateTimeRange: 'dateTimeRange',\n    time: 'time',\n    timeRange: 'timeRange',\n    select: 'select',\n    radio: 'select',\n    checkbox: 'select',\n    ...searchTypeMap,\n  }\n\n  return createStrategy((column) => {\n    // 如果未启用或字段明确禁用搜索，则跳过\n    if (!enable || (hasField(column, 'search') && !getField(column, 'search'))) {\n      return { search: false }\n    }\n\n    // 如果已有搜索配置，保留原配置\n    if (hasField(column, 'search') && typeof getField(column, 'search') === 'object') {\n      return {}\n    }\n\n    // 获取字段类型\n    const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n\n    // 根据类型设置搜索配置\n    const searchType = defaultSearchTypeMap[valueType] || 'text'\n\n    return {\n      search: true,\n      // 在 fieldProps 中设置搜索相关属性（如果需要）\n      fieldProps: {\n        ...getField<any>(column, 'fieldProps', {}),\n      },\n      // 某些组件可能需要 searchType\n      ...(searchType !== 'text' ? { searchType } : {}),\n    }\n  })\n}\n\nexport default Search","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Sort 策略配置\n */\nexport type SortStrategyOptions = {\n  /**\n   * 是否启用排序\n   */\n  enable?: boolean\n  /**\n   * 默认排序方式\n   */\n  defaultSorter?: 'ascend' | 'descend' | false\n}\n\n/**\n * 创建 Sort 策略\n * 功能：\n * 1. 为 columns 添加排序配置\n * 2. 自动根据字段类型生成排序函数\n * 3. 支持自定义排序配置\n */\nconst Sort = (options: SortStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, defaultSorter = false } = options\n\n  return createStrategy((column) => {\n    // 如果未启用或字段明确禁用排序，则跳过\n    if (!enable || (hasField(column, 'sorter') && getField(column, 'sorter') === false)) {\n      return { sorter: false }\n    }\n\n    // 如果已有排序配置，保留原配置\n    if (hasField(column, 'sorter') && typeof getField(column, 'sorter') === 'function') {\n      return {}\n    }\n\n    // 获取字段的 dataIndex\n    const dataIndex = getField<string>(column, 'dataIndex')\n    if (!dataIndex) {\n      return {}\n    }\n\n    // 获取字段类型\n    const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n\n    // 根据类型生成默认排序函数\n    let sorter: any = true // 使用服务端排序\n\n    // 对于某些类型，提供客户端排序函数\n    if (['digit', 'money', 'percent'].includes(valueType)) {\n      sorter = (a: any, b: any) => {\n        const aVal = a[dataIndex] || 0\n        const bVal = b[dataIndex] || 0\n        return aVal - bVal\n      }\n    } else if (['date', 'dateTime', 'time'].includes(valueType)) {\n      sorter = (a: any, b: any) => {\n        const aVal = new Date(a[dataIndex] || 0).getTime()\n        const bVal = new Date(b[dataIndex] || 0).getTime()\n        return aVal - bVal\n      }\n    } else if (valueType === 'text') {\n      sorter = (a: any, b: any) => {\n        const aVal = String(a[dataIndex] || '')\n        const bVal = String(b[dataIndex] || '')\n        return aVal.localeCompare(bVal)\n      }\n    }\n\n    return {\n      sorter,\n      ...(defaultSorter ? { defaultSortOrder: defaultSorter } : {}),\n    }\n  })\n}\n\nexport default Sort\n","import { ProColumnsType } from '../type'\nimport { createStrategy, getField } from './utils'\n\n/**\n * Required 策略配置\n */\nexport type RequiredStrategyOptions = {\n  /**\n   * 是否启用必填验证\n   */\n  enable?: boolean\n  /**\n   * 自定义必填提示消息\n   */\n  messageTemplate?: string | ((title: string) => string)\n}\n\n/**\n * 创建 Required 策略\n * 功能：\n * 1. 为 columns 添加必填验证规则\n * 2. 自动添加 * 标记（通过 ProForm 的 rules）\n * 3. 支持自定义验证消息\n */\nconst Required = (options: RequiredStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, messageTemplate } = options\n\n  const defaultMessageTemplate = (title: string) => `请输入${title}`\n\n  return createStrategy((column) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 如果已有 required 规则，保留原配置\n    const existingRules = getField<any[]>(column, 'formItemProps.rules', []) || []\n    const hasRequiredRule = existingRules.some((rule: any) => rule.required)\n    if (hasRequiredRule) {\n      return {}\n    }\n\n    // 如果字段明确不是必填，跳过\n    const dataIndex = getField<string>(column, 'dataIndex')\n    if (!dataIndex) {\n      return {}\n    }\n\n    // 获取字段标题\n    const title = getField<string>(column, 'title', '此字段') || '此字段'\n\n    // 生成验证消息\n    const message =\n      typeof messageTemplate === 'function'\n        ? messageTemplate(title)\n        : messageTemplate || defaultMessageTemplate(title)\n\n    // 获取字段类型\n    const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n    const isSelectType = ['select', 'radio', 'checkbox', 'dateRange', 'timeRange'].includes(\n      valueType\n    )\n\n    // 设置消息模板\n    const finalMessage = isSelectType ? message.replace('输入', '选择') : message\n\n    // 返回带验证规则的配置\n    return {\n      formItemProps: {\n        ...getField<any>(column, 'formItemProps', {}),\n        rules: [\n          ...existingRules,\n          {\n            required: true,\n            message: finalMessage,\n          },\n        ],\n      },\n    }\n  })\n}\n\nexport default Required\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField, generatePlaceholder } from './utils'\n\n/**\n * Placeholder 策略配置\n */\nexport type PlaceholderStrategyOptions = {\n  /**\n   * 是否启用占位符\n   */\n  enable?: boolean\n  /**\n   * 自定义占位符模板函数\n   */\n  template?: (column: ProColumnsType.ColumnType, action: 'search' | 'input' | 'select') => string\n  /**\n   * 是否为搜索字段添加占位符\n   */\n  includeSearch?: boolean\n}\n\n/**\n * 创建 Placeholder 策略\n * 功能：\n * 1. 自动为 columns 添加占位符文本\n * 2. 根据字段类型自动生成合适的提示文本\n * 3. 支持自定义占位符模板\n */\nconst Placeholder = (options: PlaceholderStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, template, includeSearch = true } = options\n\n  return createStrategy((column) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 如果已有 placeholder，保留原配置\n    const existingFieldProps = getField<any>(column, 'fieldProps', {})\n    if (existingFieldProps.placeholder) {\n      return {}\n    }\n\n    // 获取字段类型\n    const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n    const isSelectType = ['select', 'radio', 'checkbox', 'dateRange', 'timeRange'].includes(\n      valueType\n    )\n\n    // 确定操作类型\n    const action: 'search' | 'input' | 'select' = isSelectType ? 'select' : 'input'\n\n    // 生成占位符\n    const placeholder = template ? template(column, action) : generatePlaceholder(column, action)\n\n    const updates: any = {\n      fieldProps: {\n        ...existingFieldProps,\n        placeholder,\n      },\n    }\n\n    // 为搜索字段也添加占位符\n    if (includeSearch && hasField(column, 'search')) {\n      const searchValue = getField(column, 'search')\n      if (searchValue === true || (typeof searchValue === 'object' && searchValue !== null)) {\n        const searchPlaceholder = template\n          ? template(column, 'search')\n          : generatePlaceholder(column, 'search')\n\n        updates.fieldProps.placeholder = searchPlaceholder\n      }\n    }\n\n    return updates\n  })\n}\n\nexport default Placeholder\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Format 策略配置\n */\nexport type FormatStrategyOptions = {\n  /**\n   * 是否启用格式化\n   */\n  enable?: boolean\n  /**\n   * 格式化类型\n   */\n  type?: 'money' | 'number' | 'date' | 'percent' | 'custom'\n  /**\n   * 数字精度（小数位数）\n   */\n  precision?: number\n  /**\n   * 货币符号\n   */\n  symbol?: string\n  /**\n   * 是否使用千分位分隔\n   */\n  useGrouping?: boolean\n  /**\n   * 日期格式\n   */\n  dateFormat?: string\n  /**\n   * 自定义格式化函数\n   */\n  formatter?: (value: any, record: any) => string | React.ReactNode\n}\n\n/**\n * 格式化数字（千分位）\n */\nfunction formatNumber(value: number, precision?: number, useGrouping = true): string {\n  if (value === null || value === undefined || isNaN(value)) return '-'\n\n  const options: Intl.NumberFormatOptions = {\n    minimumFractionDigits: precision,\n    maximumFractionDigits: precision,\n    useGrouping,\n  }\n\n  return new Intl.NumberFormat('zh-CN', options).format(value)\n}\n\n/**\n * 格式化金额\n */\nfunction formatMoney(value: number, precision = 2, symbol = '¥', useGrouping = true): string {\n  if (value === null || value === undefined || isNaN(value)) return '-'\n\n  const formattedNumber = formatNumber(value, precision, useGrouping)\n  return `${symbol}${formattedNumber}`\n}\n\n/**\n * 格式化百分比\n */\nfunction formatPercent(value: number, precision = 2): string {\n  if (value === null || value === undefined || isNaN(value)) return '-'\n\n  return `${formatNumber(value, precision, false)}%`\n}\n\n/**\n * 格式化日期\n */\nfunction formatDate(value: any, format = 'YYYY-MM-DD'): string {\n  if (!value) return '-'\n\n  const date = new Date(value)\n  if (isNaN(date.getTime())) return '-'\n\n  const year = date.getFullYear()\n  const month = String(date.getMonth() + 1).padStart(2, '0')\n  const day = String(date.getDate()).padStart(2, '0')\n  const hours = String(date.getHours()).padStart(2, '0')\n  const minutes = String(date.getMinutes()).padStart(2, '0')\n  const seconds = String(date.getSeconds()).padStart(2, '0')\n\n  return format\n    .replace('YYYY', String(year))\n    .replace('MM', month)\n    .replace('DD', day)\n    .replace('HH', hours)\n    .replace('mm', minutes)\n    .replace('ss', seconds)\n}\n\n/**\n * 创建 Format 策略\n * 功能：\n * 1. 为 columns 添加数据格式化\n * 2. 支持数字、金额、日期、百分比等格式化\n * 3. 支持自定义格式化函数\n */\nconst Format = (options: FormatStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    type,\n    precision,\n    symbol = '¥',\n    useGrouping = true,\n    dateFormat = 'YYYY-MM-DD',\n    formatter,\n  } = options\n\n  return createStrategy((column) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 如果已有自定义 render，保留原配置\n    if (hasField(column, 'render') && !formatter) {\n      return {}\n    }\n\n    // 获取字段类型\n    const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n\n    // 自动推断格式化类型\n    let formatType = type\n    if (!formatType) {\n      if (valueType === 'money') formatType = 'money'\n      else if (valueType === 'digit') formatType = 'number'\n      else if (['date', 'dateTime'].includes(valueType)) formatType = 'date'\n      else if (valueType === 'percent') formatType = 'percent'\n    }\n\n    // 如果没有需要格式化的类型，跳过\n    if (!formatType && !formatter) {\n      return {}\n    }\n\n    // 生成 render 函数\n    let renderFunction: any\n\n    if (formatter) {\n      // 使用自定义格式化函数\n      renderFunction = (text: any, record: any) => formatter(text, record)\n    } else if (formatType === 'money') {\n      renderFunction = (text: any) => formatMoney(text, precision, symbol, useGrouping)\n    } else if (formatType === 'number') {\n      renderFunction = (text: any) => formatNumber(text, precision, useGrouping)\n    } else if (formatType === 'percent') {\n      renderFunction = (text: any) => formatPercent(text, precision)\n    } else if (formatType === 'date') {\n      renderFunction = (text: any) => {\n        const format = valueType === 'dateTime' ? 'YYYY-MM-DD HH:mm:ss' : dateFormat\n        return formatDate(text, format)\n      }\n    }\n\n    if (!renderFunction) {\n      return {}\n    }\n\n    return {\n      render: renderFunction,\n    }\n  })\n}\n\nexport default Format\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Tooltip 策略配置\n */\nexport type TooltipStrategyOptions = {\n  /**\n   * 是否启用提示\n   */\n  enable?: boolean\n  /**\n   * 提示内容\n   */\n  content?: string | ((column: ProColumnsType.ColumnType) => string)\n  /**\n   * 在表单中显示为 tooltip 还是 extra\n   * - tooltip: 显示在标题旁边的问号图标\n   * - extra: 显示在表单项下方的说明文字\n   */\n  formType?: 'tooltip' | 'extra'\n  /**\n   * 在表格中是否显示提示\n   */\n  showInTable?: boolean\n  /**\n   * 在表单中是否显示提示\n   */\n  showInForm?: boolean\n}\n\n/**\n * 创建 Tooltip 策略\n * 功能：\n * 1. 为列标题添加 tooltip\n * 2. 为表单字段添加说明文字（tooltip 或 extra）\n * 3. 支持自定义提示内容\n */\nconst Tooltip = (options: TooltipStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    content,\n    formType = 'tooltip',\n    showInTable = true,\n    showInForm = true,\n  } = options\n\n  return createStrategy((column) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 获取提示内容\n    const tooltipContent = typeof content === 'function' ? content(column) : content\n\n    if (!tooltipContent) {\n      return {}\n    }\n\n    const updates: Partial<ProColumnsType.ColumnType> = {}\n\n    // 为表格添加 tooltip\n    if (showInTable) {\n      // 检查是否已有 tooltip 配置\n      if (!hasField(column, 'tooltip')) {\n        updates.tooltip = tooltipContent\n      }\n    }\n\n    // 为表单添加提示\n    if (showInForm) {\n      const existingFormItemProps = getField<any>(column, 'formItemProps', {})\n\n      if (formType === 'tooltip') {\n        // 使用 tooltip 方式（显示在标题旁）\n        if (!existingFormItemProps.tooltip) {\n          updates.formItemProps = {\n            ...existingFormItemProps,\n            tooltip: tooltipContent,\n          }\n        }\n      } else {\n        // 使用 extra 方式（显示在下方）\n        if (!existingFormItemProps.extra) {\n          updates.formItemProps = {\n            ...existingFormItemProps,\n            extra: tooltipContent,\n          }\n        }\n      }\n    }\n\n    return updates\n  })\n}\n\nexport default Tooltip\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * DefaultValue 策略配置\n */\nexport type DefaultValueStrategyOptions = {\n  /**\n   * 是否启用默认值\n   */\n  enable?: boolean\n  /**\n   * 默认值（静态值或动态函数）\n   */\n  value?: any | (() => any)\n  /**\n   * 是否使用智能默认值\n   * 根据字段类型自动推断合理的默认值\n   */\n  autoInfer?: boolean\n}\n\n/**\n * 根据字段类型推断默认值\n */\nfunction inferDefaultValue(column: ProColumnsType.ColumnType): any {\n  const valueType = getField<string>(column, 'valueType', 'text')\n\n  switch (valueType) {\n    case 'digit':\n    case 'money':\n    case 'percent':\n      return 0\n\n    case 'switch':\n      return false\n\n    case 'checkbox':\n      return []\n\n    case 'date':\n    case 'dateTime':\n      // 返回 null，让用户自己选择，或者可以返回当前日期\n      return null\n\n    case 'dateRange':\n    case 'dateTimeRange':\n    case 'timeRange':\n      return []\n\n    case 'select':\n    case 'radio':\n      // 如果有 valueEnum，可以尝试获取第一个选项\n      const valueEnum = getField<any>(column, 'valueEnum')\n      if (valueEnum && typeof valueEnum === 'object') {\n        const firstKey = Object.keys(valueEnum)[0]\n        return firstKey || null\n      }\n      return null\n\n    case 'textarea':\n    case 'text':\n    case 'password':\n    default:\n      return ''\n  }\n}\n\n/**\n * 创建 DefaultValue 策略\n * 功能：\n * 1. 为表单字段设置默认值\n * 2. 支持静态值和动态函数\n * 3. 支持根据字段类型自动推断默认值\n */\nconst DefaultValue = (options: DefaultValueStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, value, autoInfer = false } = options\n\n  return createStrategy((column) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 如果已有默认值配置，保留原配置\n    if (hasField(column, 'initialValue')) {\n      return {}\n    }\n\n    // 确定要使用的默认值\n    let defaultValue: any\n\n    if (value !== undefined) {\n      // 使用配置的值\n      defaultValue = typeof value === 'function' ? value() : value\n    } else if (autoInfer) {\n      // 自动推断默认值\n      defaultValue = inferDefaultValue(column)\n    } else {\n      // 没有配置值且不自动推断，跳过\n      return {}\n    }\n\n    return {\n      initialValue: defaultValue,\n    }\n  })\n}\n\nexport default DefaultValue\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Width 策略配置\n */\nexport type WidthStrategyOptions = {\n  /**\n   * 是否启用列宽设置\n   */\n  enable?: boolean\n\n  // ========== 全局配置 ==========\n  /**\n   * 固定宽度值（全局默认）\n   */\n  value?: number\n  /**\n   * 是否自动计算宽度（全局默认）\n   */\n  auto?: boolean\n  /**\n   * 最小宽度（全局默认）\n   */\n  min?: number\n  /**\n   * 最大宽度（全局默认）\n   */\n  max?: number\n  /**\n   * 每个字符的宽度（用于计算）\n   */\n  charWidth?: number\n  /**\n   * 额外的padding宽度\n   */\n  padding?: number\n\n  // ========== 场景特定配置 ==========\n  /**\n   * ProTable 场景的宽度配置（数字，单位px）\n   */\n  table?: number | {\n    value?: number\n    auto?: boolean\n    min?: number\n    max?: number\n  }\n  /**\n   * ProForm 场景的宽度配置（ProForm 支持的字符串宽度）\n   */\n  form?: 'sm' | 'md' | 'lg' | 'xl' | null  // null 表示不应用\n  /**\n   * ProDescription 场景的宽度配置（数字，单位px）\n   */\n  description?: number | null  // null 表示不应用\n}\n\n/**\n * 根据字段类型推断合适的列宽（用于 table/description）\n */\nfunction inferWidthByType(column: ProColumnsType.ColumnType): number | undefined {\n  const valueType = getField<string>(column, 'valueType', 'text') || 'text'\n\n  const widthMap: Record<string, number | undefined> = {\n    // 数字类型\n    digit: 100,\n    money: 120,\n    percent: 100,\n\n    // 日期时间类型\n    date: 120,\n    dateTime: 180,\n    time: 100,\n    dateRange: 260,\n    dateTimeRange: 360,\n    timeRange: 200,\n\n    // 选择类型\n    select: 120,\n    radio: 120,\n    checkbox: 120,\n\n    // 布尔类型\n    switch: 80,\n\n    // 操作列\n    option: 150,\n\n    // 文本类型（无固定宽度）\n    text: undefined,\n    textarea: undefined,\n    password: undefined,\n  }\n\n  return widthMap[valueType]\n}\n\n/**\n * 根据标题长度计算宽度\n */\nfunction calculateWidthByTitle(\n  column: ProColumnsType.ColumnType,\n  charWidth: number,\n  padding: number\n): number {\n  const title = getField<string>(column, 'title', '')\n\n  if (!title) return 0\n\n  // 计算中文字符和英文字符\n  let chineseCount = 0\n  let englishCount = 0\n\n  for (const char of title) {\n    // 判断是否为中文字符（简单判断）\n    if (/[\\u4e00-\\u9fa5]/.test(char)) {\n      chineseCount++\n    } else {\n      englishCount++\n    }\n  }\n\n  // 中文字符宽度约为英文的 1.5-2 倍\n  const totalWidth = chineseCount * charWidth + englishCount * (charWidth * 0.6) + padding\n\n  return Math.ceil(totalWidth)\n}\n\n/**\n * 计算数字宽度（用于 table/description）\n */\nfunction calculateNumberWidth(\n  column: ProColumnsType.ColumnType,\n  config: {\n    value?: number\n    auto?: boolean\n    min?: number\n    max?: number\n    charWidth?: number\n    padding?: number\n  }\n): number | undefined {\n  const { value, auto, min, max, charWidth = 14, padding = 48 } = config\n\n  let calculatedWidth: number | undefined\n\n  if (value !== undefined) {\n    calculatedWidth = value\n  } else if (auto) {\n    // 首先尝试根据类型推断\n    const typeWidth = inferWidthByType(column)\n    if (typeWidth) {\n      calculatedWidth = typeWidth\n    } else {\n      // 根据标题长度计算\n      const titleWidth = calculateWidthByTitle(column, charWidth, padding)\n      if (titleWidth > 0) {\n        calculatedWidth = titleWidth\n      }\n    }\n  }\n\n  // 应用最小/最大宽度限制\n  if (calculatedWidth !== undefined) {\n    if (min !== undefined && calculatedWidth < min) {\n      calculatedWidth = min\n    }\n    if (max !== undefined && calculatedWidth > max) {\n      calculatedWidth = max\n    }\n  }\n\n  return calculatedWidth\n}\n\n/**\n * 创建 Width 策略\n * 功能：\n * 1. 支持场景化配置：table/form/description\n * 2. table 和 description 使用数字宽度（px）\n * 3. form 使用字符串宽度（sm/md/lg/xl）\n * 4. 支持自动计算宽度和最小/最大宽度限制\n */\nconst Width = (options: WidthStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    value,\n    auto = false,\n    min,\n    max,\n    charWidth = 14,\n    padding = 48,\n    table,\n    form,\n    description,\n  } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 如果已有宽度配置，保留原配置\n    if (hasField(column, 'width')) {\n      return {}\n    }\n\n    // 根据场景决定宽度配置\n    if (scene === 'table') {\n      // ProTable 场景：使用数字宽度\n      if (table === null) {\n        // 明确指定不应用\n        return {}\n      }\n\n      let tableWidth: number | undefined\n\n      if (typeof table === 'number') {\n        tableWidth = table\n      } else if (table && typeof table === 'object') {\n        tableWidth = calculateNumberWidth(column, {\n          ...table,\n          charWidth,\n          padding,\n        })\n      } else {\n        // 使用全局配置\n        tableWidth = calculateNumberWidth(column, {\n          value,\n          auto,\n          min,\n          max,\n          charWidth,\n          padding,\n        })\n      }\n\n      return tableWidth !== undefined ? { width: tableWidth } : {}\n    } else if (scene === 'form') {\n      // ProForm 场景：使用字符串宽度\n      if (form === null) {\n        // 明确指定不应用\n        return {}\n      }\n\n      if (form && ['sm', 'md', 'lg', 'xl'].includes(form)) {\n        return { width: form }\n      }\n\n      // 如果没有指定 form 配置，不应用宽度（让 ProForm adapter 自动处理）\n      return {}\n    } else if (scene === 'description') {\n      // ProDescription 场景：使用数字宽度\n      if (description === null) {\n        // 明确指定不应用\n        return {}\n      }\n\n      if (typeof description === 'number') {\n        return { width: description }\n      }\n\n      // 使用全局配置\n      const descWidth = calculateNumberWidth(column, {\n        value,\n        auto,\n        min,\n        max,\n        charWidth,\n        padding,\n      })\n\n      return descWidth !== undefined ? { width: descWidth } : {}\n    }\n\n    // 没有指定场景，使用全局配置（向后兼容）\n    const calculatedWidth = calculateNumberWidth(column, {\n      value,\n      auto,\n      min,\n      max,\n      charWidth,\n      padding,\n    })\n\n    return calculatedWidth !== undefined ? { width: calculatedWidth } : {}\n  })\n}\n\nexport default Width\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField } from './utils'\n\n/**\n * Copy 策略配置\n */\nexport type CopyStrategyOptions = {\n  /**\n   * 是否启用复制功能\n   */\n  enable?: boolean\n  /**\n   * 复制提示文本\n   */\n  tooltipText?: string\n  /**\n   * 复制成功后的提示文本\n   */\n  successText?: string\n}\n\n/**\n * 创建 Copy 策略\n * 功能：\n * 1. 为 columns 添加一键复制功能\n * 2. 仅在 table 和 description 场景生效\n * 3. 支持自定义提示文本\n */\nconst Copy = (options: CopyStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, tooltipText = '复制', successText = '复制成功' } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 table 和 description 场景应用\n    if (scene === 'form') {\n      return {}\n    }\n\n    // 如果已有 copyable 配置，保留原配置\n    if (hasField(column, 'copyable')) {\n      return {}\n    }\n\n    return {\n      copyable: {\n        text: (text: any) => (text ? String(text) : ''),\n        tooltips: [tooltipText, successText],\n      } as any,\n    }\n  })\n}\n\nexport default Copy\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField } from './utils'\nimport React from 'react'\n\n/**\n * Link 策略配置\n */\nexport type LinkStrategyOptions = {\n  /**\n   * 是否启用链接功能\n   */\n  enable?: boolean\n  /**\n   * 链接地址（支持字符串或函数）\n   */\n  href?: string | ((text: any, record: any) => string)\n  /**\n   * 打开方式\n   */\n  target?: '_blank' | '_self' | '_parent' | '_top'\n  /**\n   * 点击事件（如果提供，将覆盖 href 跳转）\n   */\n  onClick?: (text: any, record: any, event: React.MouseEvent) => void\n  /**\n   * 链接文本（如果不提供，使用字段值）\n   */\n  text?: string | ((text: any, record: any) => string)\n}\n\n/**\n * 创建 Link 策略\n * 功能：\n * 1. 为 columns 添加链接跳转功能\n * 2. 仅在 table 和 description 场景生效\n * 3. 支持动态链接和点击事件\n */\nconst Link = (options: LinkStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, href, target = '_blank', onClick, text } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 table 和 description 场景应用\n    if (scene === 'form') {\n      return {}\n    }\n\n    // 如果已有自定义 render，保留原配置\n    if (hasField(column, 'render') && !href && !onClick) {\n      return {}\n    }\n\n    // 生成 render 函数\n    const renderFunction = (value: any, record: any) => {\n      // 确定显示文本\n      const displayText = text\n        ? typeof text === 'function'\n          ? text(value, record)\n          : text\n        : value || '-'\n\n      // 如果有 onClick 事件\n      if (onClick) {\n        return React.createElement(\n          'a',\n          {\n            style: { cursor: 'pointer' },\n            onClick: (e: React.MouseEvent) => {\n              e.preventDefault()\n              onClick(value, record, e)\n            },\n          },\n          displayText\n        )\n      }\n\n      // 确定链接地址\n      const linkHref = href\n        ? typeof href === 'function'\n          ? href(value, record)\n          : href\n        : value\n\n      if (!linkHref) {\n        return displayText\n      }\n\n      return React.createElement(\n        'a',\n        {\n          href: linkHref,\n          target,\n          rel: target === '_blank' ? 'noopener noreferrer' : undefined,\n        },\n        displayText\n      )\n    }\n\n    return {\n      render: renderFunction,\n    }\n  })\n}\n\nexport default Link\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField } from './utils'\nimport React from 'react'\n\n/**\n * Image 策略配置\n */\nexport type ImageStrategyOptions = {\n  /**\n   * 是否启用图片预览功能\n   */\n  enable?: boolean\n  /**\n   * 图片宽度\n   */\n  width?: number | string\n  /**\n   * 图片高度\n   */\n  height?: number | string\n  /**\n   * 是否支持预览\n   */\n  preview?: boolean\n  /**\n   * 加载失败时的占位图\n   */\n  fallback?: string\n  /**\n   * 多图片时的分隔符（用于字符串分割）\n   */\n  separator?: string\n  /**\n   * 最多显示图片数量\n   */\n  maxCount?: number\n}\n\n/**\n * 创建 Image 策略\n * 功能：\n * 1. 为 columns 添加图片预览功能\n * 2. 仅在 table 和 description 场景生效\n * 3. 支持单图和多图显示\n */\nconst Image = (options: ImageStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    width = 60,\n    height = 60,\n    preview = true,\n    fallback = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNjQiIGhlaWdodD0iNjQiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHJlY3Qgd2lkdGg9IjY0IiBoZWlnaHQ9IjY0IiBmaWxsPSIjZjBmMGYwIi8+PHRleHQgeD0iNTAlIiB5PSI1MCUiIGZvbnQtc2l6ZT0iMTIiIHRleHQtYW5jaG9yPSJtaWRkbGUiIGR5PSIuM2VtIiBmaWxsPSIjOTk5Ij7lm77niYc8L3RleHQ+PC9zdmc+',\n    separator = ',',\n    maxCount = 5,\n  } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 table 和 description 场景应用\n    if (scene === 'form') {\n      return {}\n    }\n\n    // 如果已有自定义 render，保留原配置\n    if (hasField(column, 'render')) {\n      return {}\n    }\n\n    // 生成 render 函数\n    const renderFunction = (value: any) => {\n      if (!value) {\n        return '-'\n      }\n\n      // 处理图片 URL（支持字符串或数组）\n      let imageUrls: string[] = []\n      if (typeof value === 'string') {\n        imageUrls = value.split(separator).filter((url) => url.trim())\n      } else if (Array.isArray(value)) {\n        imageUrls = value\n      } else {\n        imageUrls = [String(value)]\n      }\n\n      // 限制显示数量\n      const displayUrls = imageUrls.slice(0, maxCount)\n      const hasMore = imageUrls.length > maxCount\n\n      // 使用 Antd Image 组件\n      const Image = require('antd').Image\n      const Space = require('antd').Space\n\n      return React.createElement(\n        Space,\n        { size: 8 },\n        ...displayUrls.map((url, index) =>\n          React.createElement(Image, {\n            key: index,\n            src: url,\n            width,\n            height,\n            preview: preview\n              ? {\n                  src: url,\n                }\n              : false,\n            fallback,\n            style: { objectFit: 'cover' },\n          })\n        ),\n        hasMore &&\n          React.createElement(\n            'span',\n            { style: { color: '#999', fontSize: '12px' } },\n            `+${imageUrls.length - maxCount}`\n          )\n      )\n    }\n\n    return {\n      render: renderFunction,\n    }\n  })\n}\n\nexport default Image\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\nimport React from 'react'\n\n/**\n * Enum 策略配置\n */\nexport type EnumStrategyOptions = {\n  /**\n   * 是否启用枚举渲染增强\n   */\n  enable?: boolean\n  /**\n   * 渲染类型\n   */\n  type?: 'badge' | 'tag' | 'text'\n  /**\n   * 颜色映射（key 为枚举值，value 为颜色）\n   */\n  colorMap?: Record<string, string>\n  /**\n   * 默认颜色\n   */\n  defaultColor?: string\n}\n\n/**\n * 创建 Enum 策略\n * 功能：\n * 1. 增强枚举值的渲染效果\n * 2. 支持 badge、tag、text 三种渲染方式\n * 3. 支持自定义颜色映射\n */\nconst Enum = (options: EnumStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, type = 'badge', colorMap = {}, defaultColor = 'default' } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 table 和 description 场景应用\n    if (scene === 'form') {\n      return {}\n    }\n\n    // 必须有 valueEnum 才能应用此策略\n    if (!hasField(column, 'valueEnum') && !hasField(column, 'enumKey')) {\n      return {}\n    }\n\n    // 如果已有自定义 render，保留原配置\n    if (hasField(column, 'render')) {\n      return {}\n    }\n\n    // 如果 type 为 text，不需要特殊渲染\n    if (type === 'text') {\n      return {}\n    }\n\n    // 生成 render 函数\n    const renderFunction = (value: any) => {\n      if (value === null || value === undefined) {\n        return '-'\n      }\n\n      const valueEnum = getField<Record<string, any>>(column, 'valueEnum', {}) || {}\n      const enumItem = valueEnum[value]\n\n      if (!enumItem) {\n        return value\n      }\n\n      const text = enumItem.text || enumItem.label || value\n      const status = enumItem.status || colorMap[value] || defaultColor\n\n      if (type === 'badge') {\n        const Badge = require('antd').Badge\n        return React.createElement(Badge, {\n          status: status as any,\n          text,\n        })\n      }\n\n      if (type === 'tag') {\n        const Tag = require('antd').Tag\n        return React.createElement(Tag, { color: status }, text)\n      }\n\n      return text\n    }\n\n    return {\n      render: renderFunction,\n    }\n  })\n}\n\nexport default Enum\n","import { ProColumnsType } from '../type'\nimport { createStrategy, getField } from './utils'\n\n/**\n * Validation 策略配置\n */\nexport type ValidationStrategyOptions = {\n  /**\n   * 是否启用验证\n   */\n  enable?: boolean\n  /**\n   * 正则表达式验证\n   */\n  pattern?: RegExp\n  /**\n   * 正则验证失败提示\n   */\n  patternMessage?: string\n  /**\n   * 最小值（适用于数字）\n   */\n  min?: number\n  /**\n   * 最小值验证失败提示\n   */\n  minMessage?: string\n  /**\n   * 最大值（适用于数字）\n   */\n  max?: number\n  /**\n   * 最大值验证失败提示\n   */\n  maxMessage?: string\n  /**\n   * 最小长度（适用于字符串）\n   */\n  minLength?: number\n  /**\n   * 最小长度验证失败提示\n   */\n  minLengthMessage?: string\n  /**\n   * 最大长度（适用于字符串）\n   */\n  maxLength?: number\n  /**\n   * 最大长度验证失败提示\n   */\n  maxLengthMessage?: string\n  /**\n   * 自定义验证器\n   */\n  validator?: (\n    rule: any,\n    value: any,\n    callback: (error?: string) => void,\n    allValues?: any\n  ) => Promise<void> | void\n  /**\n   * 依赖字段（当依赖字段变化时重新验证）\n   */\n  dependencies?: string[]\n}\n\n/**\n * 创建 Validation 策略\n * 功能：\n * 1. 为表单字段添加高级验证规则\n * 2. 支持正则、范围、长度、自定义验证\n * 3. 支持字段依赖\n */\nconst Validation = (options: ValidationStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    pattern,\n    patternMessage = '格式不正确',\n    min,\n    minMessage,\n    max,\n    maxMessage,\n    minLength,\n    minLengthMessage,\n    maxLength,\n    maxLengthMessage,\n    validator,\n    dependencies,\n  } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 form 场景应用\n    if (scene !== 'form') {\n      return {}\n    }\n\n    // 获取现有的 rules\n    const existingRules = getField<any[]>(\n      column,\n      'formItemProps.rules',\n      getField<any[]>(column, 'rules', [])\n    ) || []\n\n    // 构建新的验证规则\n    const newRules: any[] = []\n\n    // 正则验证\n    if (pattern) {\n      newRules.push({\n        pattern,\n        message: patternMessage,\n      })\n    }\n\n    // 数值范围验证\n    if (min !== undefined) {\n      newRules.push({\n        type: 'number',\n        min,\n        message: minMessage || `最小值为 ${min}`,\n      })\n    }\n\n    if (max !== undefined) {\n      newRules.push({\n        type: 'number',\n        max,\n        message: maxMessage || `最大值为 ${max}`,\n      })\n    }\n\n    // 字符串长度验证\n    if (minLength !== undefined) {\n      newRules.push({\n        min: minLength,\n        message: minLengthMessage || `最少输入 ${minLength} 个字符`,\n      })\n    }\n\n    if (maxLength !== undefined) {\n      newRules.push({\n        max: maxLength,\n        message: maxLengthMessage || `最多输入 ${maxLength} 个字符`,\n      })\n    }\n\n    // 自定义验证器\n    if (validator) {\n      newRules.push({\n        validator,\n      })\n    }\n\n    // 合并规则\n    const allRules = [...existingRules, ...newRules]\n\n    const result: Partial<ProColumnsType.ColumnType> = {}\n\n    if (allRules.length > 0) {\n      result.formItemProps = {\n        ...getField<any>(column, 'formItemProps', {}),\n        rules: allRules,\n      }\n    }\n\n    // 添加依赖字段\n    if (dependencies && dependencies.length > 0) {\n      result.formItemProps = {\n        ...result.formItemProps,\n        dependencies,\n      }\n    }\n\n    return result\n  })\n}\n\nexport default Validation\n","import { ProColumnsType } from '../type'\nimport { createStrategy } from './utils'\n\n/**\n * 权限检查函数类型\n */\nexport type PermissionChecker = (context: {\n  roles?: string[]\n  permissions?: string[]\n  userRoles?: string[]\n  userPermissions?: string[]\n}) => boolean\n\n/**\n * Permission 策略配置\n */\nexport type PermissionStrategyOptions = {\n  /**\n   * 是否启用权限控制\n   */\n  enable?: boolean\n  /**\n   * 需要的角色列表（满足任一即可）\n   */\n  roles?: string[]\n  /**\n   * 需要的权限列表（满足任一即可）\n   */\n  permissions?: string[]\n  /**\n   * 当前用户的角色\n   */\n  userRoles?: string[]\n  /**\n   * 当前用户的权限\n   */\n  userPermissions?: string[]\n  /**\n   * 无权限时是否隐藏字段\n   */\n  hideWhenNoPermission?: boolean\n  /**\n   * 无权限时是否禁用字段（仅在 form 场景有效）\n   */\n  disableWhenNoPermission?: boolean\n  /**\n   * 自定义权限检查函数\n   */\n  checker?: PermissionChecker\n}\n\n/**\n * 默认权限检查函数\n */\nfunction defaultPermissionChecker(context: {\n  roles?: string[]\n  permissions?: string[]\n  userRoles?: string[]\n  userPermissions?: string[]\n}): boolean {\n  const { roles, permissions, userRoles = [], userPermissions = [] } = context\n\n  // 如果没有配置权限要求，默认有权限\n  if ((!roles || roles.length === 0) && (!permissions || permissions.length === 0)) {\n    return true\n  }\n\n  // 检查角色\n  if (roles && roles.length > 0) {\n    const hasRole = roles.some((role) => userRoles.includes(role))\n    if (hasRole) return true\n  }\n\n  // 检查权限\n  if (permissions && permissions.length > 0) {\n    const hasPermission = permissions.some((permission) => userPermissions.includes(permission))\n    if (hasPermission) return true\n  }\n\n  return false\n}\n\n/**\n * 创建 Permission 策略\n * 功能：\n * 1. 为字段添加权限控制\n * 2. 支持角色和权限检查\n * 3. 支持隐藏或禁用\n */\nconst Permission = (options: PermissionStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const {\n    enable = true,\n    roles,\n    permissions,\n    userRoles,\n    userPermissions,\n    hideWhenNoPermission = true,\n    disableWhenNoPermission = false,\n    checker,\n  } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 检查权限\n    const hasPermission = checker\n      ? checker({ roles, permissions, userRoles, userPermissions })\n      : defaultPermissionChecker({ roles, permissions, userRoles, userPermissions })\n\n    // 如果有权限，不做任何修改\n    if (hasPermission) {\n      return {}\n    }\n\n    // 无权限时的处理\n    const result: Partial<ProColumnsType.ColumnType> = {}\n\n    // 隐藏字段\n    if (hideWhenNoPermission) {\n      if (scene === 'table') {\n        result.hideInTable = true\n      } else if (scene === 'form') {\n        result.hideInForm = true\n      } else if (scene === 'description') {\n        result.hideInDescriptions = true\n      }\n    }\n\n    // 禁用字段（仅在 form 场景）\n    if (disableWhenNoPermission && scene === 'form' && !hideWhenNoPermission) {\n      result.fieldProps = {\n        disabled: true,\n      }\n      result.editable = false\n    }\n\n    return result\n  })\n}\n\nexport default Permission\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Transform 策略配置\n */\nexport type TransformStrategyOptions = {\n  /**\n   * 是否启用数据转换\n   */\n  enable?: boolean\n  /**\n   * 输入转换（表单输入时）\n   * 用于将用户输入的值转换为需要的格式\n   */\n  input?: (value: any, record?: any) => any\n  /**\n   * 输出转换（表单提交时）\n   * 用于将表单值转换为提交给后端的格式\n   */\n  output?: (value: any, record?: any) => any\n  /**\n   * 显示转换（仅用于展示）\n   * 用于将数据转换为显示格式\n   */\n  display?: (value: any, record?: any) => any\n}\n\n/**\n * 创建 Transform 策略\n * 功能：\n * 1. 为字段添加数据转换功能\n * 2. 支持输入、输出、显示三个转换点\n * 3. 适用于不同场景的数据格式转换\n */\nconst Transform = (options: TransformStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, input, output, display } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    const result: Partial<ProColumnsType.ColumnType> = {}\n\n    // 在 table 和 description 场景应用显示转换\n    if ((scene === 'table' || scene === 'description') && display) {\n      // 如果已有自定义 render，保留原配置\n      if (!hasField(column, 'render')) {\n        result.render = (value: any, record: any) => {\n          const transformed = display(value, record)\n          return transformed ?? value ?? '-'\n        }\n      }\n    }\n\n    // 在 form 场景应用输入和输出转换\n    if (scene === 'form') {\n      const existingFieldProps = getField<any>(column, 'fieldProps', {})\n      const existingConvertValue = getField<any>(column, 'convertValue')\n      const existingTransform = getField<any>(column, 'transform')\n\n      // 输入转换（getValueFromEvent）\n      if (input) {\n        result.fieldProps = {\n          ...existingFieldProps,\n          // 保留原有的 getValueFromEvent，如果有的话\n          ...(existingFieldProps.getValueFromEvent\n            ? {\n                getValueFromEvent: (...args: any[]) => {\n                  const originalValue = existingFieldProps.getValueFromEvent(...args)\n                  return input(originalValue)\n                },\n              }\n            : {\n                getValueFromEvent: (value: any) => input(value),\n              }),\n        }\n      }\n\n      // 输出转换（convertValue 或 transform）\n      if (output) {\n        // 优先使用 convertValue（ProForm 推荐）\n        if (!existingConvertValue) {\n          ;(result as any).convertValue = (value: any, record: any) => output(value, record)\n        }\n\n        // 也支持 transform（某些场景可能需要）\n        if (!existingTransform) {\n          ;(result as any).transform = (value: any) => output(value)\n        }\n      }\n    }\n\n    return result\n  })\n}\n\nexport default Transform\n","import { ProColumnsType } from '../type'\nimport { createStrategy, hasField, getField } from './utils'\n\n/**\n * Editable 策略配置\n */\nexport type EditableStrategyOptions = {\n  /**\n   * 是否启用可编辑功能\n   */\n  enable?: boolean\n  /**\n   * 编辑类型\n   */\n  type?: 'text' | 'select' | 'date' | 'dateTime' | 'digit' | 'textarea'\n  /**\n   * 编辑时的配置\n   */\n  editableConfig?: {\n    /**\n     * 保存回调\n     */\n    onSave?: (key: any, record: any, newValue: any) => Promise<any>\n    /**\n     * 取消回调\n     */\n    onCancel?: (key: any, record: any) => void\n    /**\n     * 是否在编辑状态下才显示\n     */\n    editOnly?: boolean\n    /**\n     * 额外的表单配置\n     */\n    formItemProps?: any\n    /**\n     * 额外的字段配置\n     */\n    fieldProps?: any\n  }\n}\n\n/**\n * 创建 Editable 策略\n * 功能：\n * 1. 为表格单元格添加可编辑功能\n * 2. 仅在 table 场景生效\n * 3. 支持多种编辑类型\n */\nconst Editable = (options: EditableStrategyOptions = {}): ProColumnsType.StrategyItem => {\n  const { enable = true, type, editableConfig = {} } = options\n\n  return createStrategy((column, scene) => {\n    // 如果未启用，则跳过\n    if (!enable) {\n      return {}\n    }\n\n    // 仅在 table 场景应用\n    if (scene !== 'table') {\n      return {}\n    }\n\n    // 如果已有 editable 配置，保留原配置\n    if (hasField(column, 'editable')) {\n      return {}\n    }\n\n    // 获取字段类型\n    const valueType = type || getField<string>(column, 'valueType', 'text')\n\n    // 构建 editable 配置\n    const editableOptions: any = {\n      type: valueType,\n    }\n\n    // 添加保存回调\n    if (editableConfig.onSave) {\n      editableOptions.onSave = async (key: any, record: any, originRow: any, newLineConfig: any) => {\n        const dataIndex = getField<string>(column, 'dataIndex')\n        const newValue = dataIndex ? record[dataIndex] : undefined\n        return editableConfig.onSave!(key, record, newValue)\n      }\n    }\n\n    // 添加取消回调\n    if (editableConfig.onCancel) {\n      editableOptions.onCancel = (key: any, record: any) => {\n        editableConfig.onCancel!(key, record)\n      }\n    }\n\n    // 添加额外配置\n    if (editableConfig.formItemProps) {\n      editableOptions.formItemProps = editableConfig.formItemProps\n    }\n\n    if (editableConfig.fieldProps) {\n      editableOptions.fieldProps = editableConfig.fieldProps\n    }\n\n    return {\n      editable: () => editableOptions,\n    }\n  })\n}\n\nexport default Editable\n","import { ProColumnsType } from \"../type\";\n\n// 策略合并\nconst merge = (ori: ProColumnsType.ColumnType, cur: ProColumnsType.Strategy): ProColumnsType.Strategy => {\n    // 如果原始 column 没有策略，直接返回当前策略\n    if (!ori.strategys || ori.strategys.length === 0) {\n        return cur\n    }\n\n    // 根据模式处理\n    if (cur.mode === 'replace') {\n        // replace 模式：直接返回当前策略\n        return cur\n    } else {\n        // merge 模式：合并所有策略函数\n        const mergedStrategies: ProColumnsType.StrategyItem[] = []\n\n        // 收集所有已存在的策略函数\n        ori.strategys.forEach(s => {\n            mergedStrategies.push(...s.strategy)\n        })\n\n        // 添加当前策略函数\n        mergedStrategies.push(...cur.strategy)\n\n        return {\n            mode: 'merge',\n            strategy: mergedStrategies\n        }\n    }\n}\n\n// 策略执行\nconst execute = (\n    column: ProColumnsType.ColumnType,\n    strategys: ProColumnsType.Strategy[],\n    scene?: ProColumnsType.Scene\n): ProColumnsType.ColumnType => {\n    let result = { ...column }\n\n    // 遍历所有策略配置\n    strategys.forEach(strategyConfig => {\n        // 检查策略是否适用于当前场景\n        if (strategyConfig.scene) {\n            const allowedScenes = Array.isArray(strategyConfig.scene)\n                ? strategyConfig.scene\n                : [strategyConfig.scene]\n\n            // 如果指定了场景，但当前场景不在列表中，则跳过\n            if (scene && !allowedScenes.includes(scene)) {\n                return\n            }\n        }\n\n        // 执行该策略配置中的所有策略函数\n        strategyConfig.strategy.forEach(strategyFn => {\n            // 每个策略函数接收当前 column 和场景，返回处理后的 column\n            const processed = strategyFn(result, scene)\n            // 合并处理结果\n            result = { ...result, ...processed }\n        })\n    })\n\n    // 清除策略配置，避免输出时包含\n    delete result.strategys\n\n    return result\n}\n\n// 策略类\nconst Strategy = (\n    columns: ProColumnsType.ColumnType[],\n    scene?: ProColumnsType.Scene\n): ProColumnsType.ColumnType[] => {\n    // 复制一份数据\n    const copyColumns = columns.map(column => ({ ...column }))\n    return copyColumns.map(column => {\n        if (column.strategys) {\n            column.strategys = column.strategys.map(strategy => {\n                return merge(column, strategy)\n            })\n            return execute(column, column.strategys, scene)\n        }\n        return column\n    })\n}\n\nexport default Strategy\n\n// 导出所有策略\nexport { default as Search } from './Search'\nexport { default as Sort } from './Sort'\nexport { default as Required } from './Required'\nexport { default as Placeholder } from './Placeholder'\nexport { default as Format } from './Format'\nexport { default as Tooltip } from './Tooltip'\nexport { default as DefaultValue } from './DefaultValue'\nexport { default as Width } from './Width'\nexport { default as Copy } from './Copy'\nexport { default as Link } from './Link'\nexport { default as Image } from './Image'\nexport { default as Enum } from './Enum'\nexport { default as Validation } from './Validation'\nexport { default as Permission } from './Permission'\nexport { default as Transform } from './Transform'\nexport { default as Editable } from './Editable'\n\n// 导出策略工具函数\nexport * from './utils'","import Strategy from '../strategy'\nimport { ProColumnsType } from '../type'\n\nexport type ColumnsProps = {\n  columns: ProColumnsType.ColumnType[]\n  enums?: Record<string, any>\n  scene?: ProColumnsType.Scene // 可选场景参数\n  /** 运行时应用的策略（会添加到每个 column 的策略列表中） */\n  applyStrategies?: ProColumnsType.StrategyItem[]\n  /** 是否使用 merge 模式合并策略（默认 true）。true=合并策略，false=替换策略 */\n  mergeMode?: boolean\n  /** 针对特定 column 的策略配置 */\n  columnStrategies?: Array<{\n    /** 目标 column 的 dataIndex */\n    dataIndex: string\n    /** 要应用的策略列表 */\n    strategies: ProColumnsType.StrategyItem[]\n    /** 是否使用 merge 模式（默认 true）。true=合并，false=替换该 column 的所有策略 */\n    mergeMode?: boolean\n  }>\n}\n\n/**\n * Columns 处理器\n * 功能：\n * 1. 处理 enums 映射：将字段中的 enumKey 转换为实际的 valueEnum\n * 2. 应用全局运行时策略：将 applyStrategies 合并到每个 column 的策略列表中\n * 3. 应用针对性策略：将 columnStrategies 应用到指定的 column\n * 4. 应用策略处理：通过 Strategy 处理器应用所有配置的策略（支持场景）\n * 5. 返回处理后的 columns\n */\nconst Columns = (props: ColumnsProps): ProColumnsType.ColumnType[] => {\n  const {\n    columns,\n    enums = {},\n    scene,\n    applyStrategies,\n    mergeMode = true,\n    columnStrategies,\n  } = props\n\n  // 1. 处理 enums 映射\n  const columnsWithEnums = columns.map((column) => {\n    const processedColumn = { ...column }\n\n    // 如果 column 中有 enumKey，则从 enums 中查找对应的枚举值\n    if ('enumKey' in processedColumn && processedColumn.enumKey) {\n      const enumKey = processedColumn.enumKey as string\n      if (enums[enumKey]) {\n        processedColumn.valueEnum = enums[enumKey]\n      }\n      // 删除 enumKey，避免传递给组件\n      delete (processedColumn as any).enumKey\n    }\n\n    return processedColumn\n  })\n\n  // 2. 应用全局运行时策略\n  const columnsWithGlobalStrategies = columnsWithEnums.map((column) => {\n    // 如果没有全局运行时策略，直接返回\n    if (!applyStrategies || applyStrategies.length === 0) {\n      return column\n    }\n\n    const processedColumn = { ...column }\n\n    // 创建运行时策略配置\n    const runtimeStrategyConfig: ProColumnsType.Strategy = {\n      mode: 'merge',\n      strategy: applyStrategies,\n    }\n\n    // 根据 mergeMode 决定如何应用运行时策略\n    if (mergeMode) {\n      // merge 模式：将运行时策略添加到现有策略列表的末尾\n      processedColumn.strategys = [...(column.strategys || []), runtimeStrategyConfig]\n    } else {\n      // replace 模式：用运行时策略替换现有策略\n      processedColumn.strategys = [runtimeStrategyConfig]\n    }\n\n    return processedColumn\n  })\n\n  // 3. 应用针对性策略\n  const columnsWithColumnStrategies = columnsWithGlobalStrategies.map((column) => {\n    // 如果没有针对性策略配置，直接返回\n    if (!columnStrategies || columnStrategies.length === 0) {\n      return column\n    }\n\n    // 查找是否有针对该 column 的策略配置\n    const columnStrategy = columnStrategies.find(\n      (cs) => cs.dataIndex === (column.dataIndex as string)\n    )\n\n    // 如果没有找到针对该 column 的配置，直接返回\n    if (!columnStrategy) {\n      return column\n    }\n\n    const processedColumn = { ...column }\n\n    // 创建针对性策略配置\n    const targetStrategyConfig: ProColumnsType.Strategy = {\n      mode: 'merge',\n      strategy: columnStrategy.strategies,\n    }\n\n    // 根据该 column 的 mergeMode 决定如何应用针对性策略\n    const columnMergeMode = columnStrategy.mergeMode !== undefined ? columnStrategy.mergeMode : true\n\n    if (columnMergeMode) {\n      // merge 模式：将针对性策略添加到现有策略列表的末尾\n      processedColumn.strategys = [...(processedColumn.strategys || []), targetStrategyConfig]\n    } else {\n      // replace 模式：用针对性策略替换该 column 的所有策略（包括全局运行时策略）\n      processedColumn.strategys = [targetStrategyConfig]\n    }\n\n    return processedColumn\n  })\n\n  // 4. 应用策略处理（传入场景参数）\n  const processedColumns = Strategy(columnsWithColumnStrategies, scene)\n\n  return processedColumns\n}\n\nexport default Columns","import { ProColumnsType } from '../type'\nimport Columns from './columns'\n\n/**\n * 组件适配器类型\n * 每个组件适配器需要实现 transform 方法，将通用的 columns 转换为特定组件的 columns 格式\n */\nexport type ComponentAdapter<T = any> = {\n  /**\n   * 组件名称\n   */\n  name: string\n  /**\n   * 对应的场景（用于自动推断）\n   */\n  scene?: ProColumnsType.Scene\n  /**\n   * 转换函数：将通用 columns 转换为组件特定的 columns\n   */\n  transform: (columns: ProColumnsType.ColumnType[]) => T[]\n}\n\n/**\n * 组件适配器注册表\n */\nconst adapters: Map<string, ComponentAdapter> = new Map()\n\n/**\n * 组件名称到场景的默认映射\n */\nconst sceneMap: Record<string, ProColumnsType.Scene> = {\n  proTable: 'table',\n  proForm: 'form',\n  proDescription: 'description',\n}\n\n/**\n * Component 组件管理器\n */\nconst Component = {\n  /**\n   * 注册组件适配器\n   * @param adapter 组件适配器\n   */\n  register(adapter: ComponentAdapter) {\n    adapters.set(adapter.name, adapter)\n  },\n\n  /**\n   * 获取组件适配器\n   * @param name 组件名称\n   */\n  getAdapter(name: string): ComponentAdapter | undefined {\n    return adapters.get(name)\n  },\n\n  /**\n   * 转换 columns 为指定组件的格式\n   * @param name 组件名称\n   * @param columns 原始 columns\n   * @param options 配置选项\n   */\n  transform<T = any>(\n    name: string,\n    columns: ProColumnsType.ColumnType[],\n    options?: {\n      /** 枚举字典 */\n      enums?: Record<string, any>\n      /** 场景（如不提供则自动推断） */\n      scene?: ProColumnsType.Scene\n      /** 运行时应用的策略（会添加到每个 column 的策略列表中） */\n      applyStrategies?: ProColumnsType.StrategyItem[]\n      /** 是否使用 merge 模式合并策略（默认 true） */\n      mergeMode?: boolean\n      /** 针对特定 column 的策略配置 */\n      columnStrategies?: Array<{\n        /** 目标 column 的 dataIndex */\n        dataIndex: string\n        /** 要应用的策略列表 */\n        strategies: ProColumnsType.StrategyItem[]\n        /** 是否使用 merge 模式（默认 true）。true=合并，false=替换该 column 的所有策略 */\n        mergeMode?: boolean\n      }>\n    }\n  ): T[] {\n    const adapter = this.getAdapter(name)\n    if (!adapter) {\n      console.warn(`Component adapter \"${name}\" not found, returning original columns`)\n      return columns as any\n    }\n\n    const { enums, scene, applyStrategies, mergeMode = true, columnStrategies } = options || {}\n\n    // 推断场景：优先使用传入的 scene，其次使用适配器的 scene，最后使用默认映射\n    const inferredScene = scene || adapter.scene || sceneMap[name]\n\n    // 先应用策略处理（带场景、枚举和运行时策略）\n    const processedColumns = Columns({\n      columns,\n      enums,\n      scene: inferredScene,\n      applyStrategies,\n      mergeMode,\n      columnStrategies,\n    })\n\n    // 再通过适配器转换格式\n    return adapter.transform(processedColumns)\n  },\n\n  /**\n   * 获取所有已注册的适配器名称\n   */\n  getAdapterNames(): string[] {\n    return Array.from(adapters.keys())\n  },\n\n  /**\n   * 清空所有适配器（主要用于测试）\n   */\n  clear() {\n    adapters.clear()\n  },\n}\n\nexport default Component","import { ProColumnsType } from '../type'\nimport { ComponentAdapter } from '../lib/component'\n\n/**\n * ProTable Column 类型\n * 扩展 ProColumns，添加 ProTable 专用字段\n */\nexport type ProTableColumn = ProColumnsType.ColumnType & {\n  /**\n   * 在设置中隐藏\n   */\n  hideInSetting?: boolean\n  /**\n   * 在表格中隐藏\n   */\n  hideInTable?: boolean\n  /**\n   * 默认隐藏（通过 columnsState控制）\n   */\n  defaultHidden?: boolean\n}\n\n/**\n * ProTable 适配器\n * 功能：\n * 1. 转换 columns 为 ProTable 的 columns 格式\n * 2. 处理默认配置：ellipsis、copyable、tooltip 等\n * 3. 适配搜索、隐藏等配置\n */\nconst ProTableAdapter: ComponentAdapter<ProTableColumn> = {\n  name: 'proTable',\n  scene: 'table',\n  transform: (columns: ProColumnsType.ColumnType[]): ProTableColumn[] => {\n    return columns.map((column) => {\n      const tableColumn: ProTableColumn = { ...column }\n\n      // 默认启用省略号\n      if (!('ellipsis' in tableColumn)) {\n        tableColumn.ellipsis = true\n      }\n\n      // 搜索配置适配\n      if ('search' in tableColumn && tableColumn.search === false) {\n        tableColumn.hideInSearch = true\n        delete tableColumn.search\n      }\n\n      // 保留表格专用配置\n      if ('hideInTable' in tableColumn && tableColumn.hideInTable) {\n        tableColumn.hideInTable = true\n      }\n\n      // 默认隐藏配置（通过 columnsState 控制）\n      if ('defaultHidden' in tableColumn && tableColumn.defaultHidden) {\n        // ProTable 的 columnsState 默认隐藏配置\n        // 具体适配需要根据 ProTable 的实际需求调整\n        delete tableColumn.defaultHidden\n      }\n\n      return tableColumn\n    })\n  },\n}\n\nexport default ProTableAdapter\n","import { ProColumnsType } from '../type'\nimport { ComponentAdapter } from '../lib/component'\n\nexport type ProFormField = ProColumnsType.ColumnType & {\n  hideInForm?: boolean\n  width?: 'sm' | 'md' | 'lg' | 'xl' | number\n  colProps?: {\n    span?: number\n    offset?: number\n  }\n}\n\nconst ProFormAdapter: ComponentAdapter<ProFormField> = {\n  name: 'proForm',\n  scene: 'form',\n  transform: (columns: ProColumnsType.ColumnType[]): ProFormField[] => {\n    return columns\n      .filter((column) => !(column as any).hideInForm)\n      .map((column) => {\n        const formField: any = { ...column }\n\n        // 删除表格专用属性\n        delete formField.hideInTable\n        delete formField.ellipsis\n        delete formField.copyable\n        delete formField.sorter\n        delete formField.search\n        delete formField.hideInSearch\n\n        if (!formField.name && formField.dataIndex) {\n          formField.name = formField.dataIndex\n        }\n\n        // 根据 valueType 设置合适的表单宽度（如果策略没有设置）\n        if (!formField.width) {\n          const valueType = (formField.valueType as string) || 'text'\n          if (['textarea'].includes(valueType)) {\n            formField.width = 'xl'\n          } else if (['dateRange', 'dateTimeRange', 'timeRange'].includes(valueType)) {\n            formField.width = 'lg'\n          } else {\n            formField.width = 'md'\n          }\n        }\n\n        return formField as ProFormField\n      })\n  },\n}\n\nexport default ProFormAdapter\n","import { ProColumnsType } from '../type'\nimport { ComponentAdapter } from '../lib/component'\nimport React from 'react'\n\nexport type ProDescriptionColumn = ProColumnsType.ColumnType & {\n  hideInDescriptions?: boolean\n  span?: number\n  contentStyle?: React.CSSProperties\n  labelStyle?: React.CSSProperties\n}\n\nconst ProDescriptionAdapter: ComponentAdapter<ProDescriptionColumn> = {\n  name: 'proDescription',\n  scene: 'description',\n  transform: (columns: ProColumnsType.ColumnType[]): ProDescriptionColumn[] => {\n    return columns\n      .filter((column) => !(column as any).hideInDescriptions)\n      .map((column) => {\n        const descColumn: any = { ...column }\n\n        // 删除表格和表单专用属性\n        delete descColumn.hideInTable\n        delete descColumn.sorter\n        delete descColumn.filters\n        delete descColumn.hideInForm\n        delete descColumn.formItemProps\n        delete descColumn.search\n        delete descColumn.hideInSearch\n        delete descColumn.fieldProps\n\n        // 保留 width（可能由 Width 策略设置）\n\n        // 根据 valueType 设置合适的 span（如果没有设置）\n        if (!descColumn.span) {\n          const valueType = (descColumn.valueType as string) || 'text'\n          if (['textarea', 'jsonCode', 'code'].includes(valueType)) {\n            descColumn.span = 3\n          } else {\n            descColumn.span = 1\n          }\n        }\n\n        return descColumn as ProDescriptionColumn\n      })\n  },\n}\n\nexport default ProDescriptionAdapter\n","import { ProColumnsType } from '../type'\nimport {\n  Search,\n  Sort,\n  Required,\n  Placeholder,\n  Format,\n  Width,\n  Copy,\n  Link,\n  Image,\n  Enum,\n} from '../strategy'\n\n/**\n * 预设类型\n */\nexport type PresetFunction = () => ProColumnsType.StrategyItem[]\n\n/**\n * 预设注册表\n */\nconst presetRegistry: Record<string, PresetFunction> = {}\n\n/**\n * 预设管理类\n */\nclass Presets {\n  /**\n   * 注册自定义预设\n   * @param name 预设名称\n   * @param preset 预设函数\n   */\n  static register(name: string, preset: PresetFunction): void {\n    if (presetRegistry[name]) {\n      console.warn(`[Pro-Columns] Preset \"${name}\" already exists and will be overwritten.`)\n    }\n    presetRegistry[name] = preset\n  }\n\n  /**\n   * 获取预设\n   * @param name 预设名称\n   * @returns 预设函数\n   */\n  static get(name: string): PresetFunction | undefined {\n    return presetRegistry[name]\n  }\n\n  /**\n   * 获取所有预设名称\n   * @returns 预设名称列表\n   */\n  static list(): string[] {\n    return Object.keys(presetRegistry)\n  }\n\n  /**\n   * 清空所有预设（主要用于测试）\n   */\n  static clear(): void {\n    Object.keys(presetRegistry).forEach((key) => {\n      delete presetRegistry[key]\n    })\n  }\n\n  // ==================== 内置预设 ====================\n\n  /**\n   * 可搜索字段\n   * 包含：搜索、排序、占位符\n   */\n  static searchableField(): ProColumnsType.StrategyItem[] {\n    return [Search(), Sort(), Placeholder({ includeSearch: true })]\n  }\n\n  /**\n   * 必填字段\n   * 包含：必填、占位符\n   */\n  static requiredField(): ProColumnsType.StrategyItem[] {\n    return [Required(), Placeholder()]\n  }\n\n  /**\n   * 金额字段\n   * 包含：金额格式化、宽度配置、排序\n   */\n  static moneyField(options?: { precision?: number }): ProColumnsType.StrategyItem[] {\n    const { precision = 2 } = options || {}\n    return [\n      Format({ type: 'money', precision }),\n      Width({ table: 120, form: 'lg' }),\n      Sort(),\n      Copy(),\n    ]\n  }\n\n  /**\n   * 日期字段\n   * 包含：日期格式化、排序、宽度配置\n   */\n  static dateField(options?: { format?: string }): ProColumnsType.StrategyItem[] {\n    const { format = 'YYYY-MM-DD' } = options || {}\n    return [Format({ type: 'date', dateFormat: format }), Sort(), Width({ table: 180, form: 'md' })]\n  }\n\n  /**\n   * 日期时间字段\n   * 包含：日期时间格式化、排序、宽度配置\n   */\n  static dateTimeField(): ProColumnsType.StrategyItem[] {\n    return [\n      Format({ type: 'date', dateFormat: 'YYYY-MM-DD HH:mm:ss' }),\n      Sort(),\n      Width({ table: 200, form: 'lg' }),\n    ]\n  }\n\n  /**\n   * 枚举字段\n   * 包含：枚举渲染、搜索、必填、占位符\n   */\n  static enumField(options?: { type?: 'badge' | 'tag' | 'text' }): ProColumnsType.StrategyItem[] {\n    const { type = 'badge' } = options || {}\n    return [Enum({ type }), Search(), Required(), Placeholder()]\n  }\n\n  /**\n   * 只读字段\n   * 包含：禁用表单输入\n   */\n  static readonlyField(): ProColumnsType.StrategyItem[] {\n    return [\n      {\n        fieldProps: { disabled: true },\n        editable: false,\n      } as any,\n    ]\n  }\n\n  /**\n   * 图片字段\n   * 包含：图片预览、宽度配置\n   */\n  static imageField(options?: {\n    width?: number\n    height?: number\n    maxCount?: number\n  }): ProColumnsType.StrategyItem[] {\n    const { width = 60, height = 60, maxCount = 5 } = options || {}\n    return [Image({ width, height, maxCount }), Width({ table: 100, form: 'lg' })]\n  }\n\n  /**\n   * 链接字段\n   * 包含：链接跳转、宽度配置、复制\n   */\n  static linkField(options?: {\n    target?: '_blank' | '_self'\n  }): ProColumnsType.StrategyItem[] {\n    const { target = '_blank' } = options || {}\n    return [Link({ target }), Copy(), Width({ table: 200 })]\n  }\n\n  /**\n   * 数字字段\n   * 包含：数字格式化、排序、宽度配置\n   */\n  static numberField(options?: { precision?: number }): ProColumnsType.StrategyItem[] {\n    const { precision = 0 } = options || {}\n    return [Format({ type: 'number', precision }), Sort(), Width({ table: 100, form: 'md' })]\n  }\n\n  /**\n   * 百分比字段\n   * 包含：百分比格式化、排序、宽度配置\n   */\n  static percentField(options?: { precision?: number }): ProColumnsType.StrategyItem[] {\n    const { precision = 2 } = options || {}\n    return [Format({ type: 'percent', precision }), Sort(), Width({ table: 100, form: 'md' })]\n  }\n\n  /**\n   * 可编辑字段（表格内编辑）\n   * 包含：可编辑配置、排序\n   */\n  static editableField(options?: {\n    type?: 'text' | 'select' | 'date' | 'dateTime' | 'digit'\n    onSave?: (key: any, record: any, newValue: any) => Promise<any>\n  }): ProColumnsType.StrategyItem[] {\n    const { type = 'text', onSave } = options || {}\n    return [\n      {\n        editable: () => ({\n          type,\n          onSave,\n        }),\n      } as any,\n      Sort(),\n    ]\n  }\n\n  /**\n   * 完整 CRUD 字段\n   * 包含：搜索、排序、必填、占位符、复制\n   * 适用于常规文本字段\n   */\n  static fullField(): ProColumnsType.StrategyItem[] {\n    return [Search(), Sort(), Required(), Placeholder({ includeSearch: true }), Copy()]\n  }\n}\n\nexport default Presets\n","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","/**\n * @license React\n * react-jsx-runtime.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n  (function() {\n'use strict';\n\nvar React = require('react');\n\n// ATTENTION\n// When adding new symbols to this file,\n// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'\n// The Symbol used to tag the ReactElement-like types.\nvar REACT_ELEMENT_TYPE = Symbol.for('react.element');\nvar REACT_PORTAL_TYPE = Symbol.for('react.portal');\nvar REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');\nvar REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');\nvar REACT_PROFILER_TYPE = Symbol.for('react.profiler');\nvar REACT_PROVIDER_TYPE = Symbol.for('react.provider');\nvar REACT_CONTEXT_TYPE = Symbol.for('react.context');\nvar REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');\nvar REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');\nvar REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');\nvar REACT_MEMO_TYPE = Symbol.for('react.memo');\nvar REACT_LAZY_TYPE = Symbol.for('react.lazy');\nvar REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');\nvar MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\nfunction getIteratorFn(maybeIterable) {\n  if (maybeIterable === null || typeof maybeIterable !== 'object') {\n    return null;\n  }\n\n  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n\n  if (typeof maybeIterator === 'function') {\n    return maybeIterator;\n  }\n\n  return null;\n}\n\nvar ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n\nfunction error(format) {\n  {\n    {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n\n      printWarning('error', format, args);\n    }\n  }\n}\n\nfunction printWarning(level, format, args) {\n  // When changing this logic, you might want to also\n  // update consoleWithStackDev.www.js as well.\n  {\n    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\n    var stack = ReactDebugCurrentFrame.getStackAddendum();\n\n    if (stack !== '') {\n      format += '%s';\n      args = args.concat([stack]);\n    } // eslint-disable-next-line react-internal/safe-string-coercion\n\n\n    var argsWithFormat = args.map(function (item) {\n      return String(item);\n    }); // Careful: RN currently depends on this prefix\n\n    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it\n    // breaks IE9: https://github.com/facebook/react/issues/13610\n    // eslint-disable-next-line react-internal/no-production-logging\n\n    Function.prototype.apply.call(console[level], console, argsWithFormat);\n  }\n}\n\n// -----------------------------------------------------------------------------\n\nvar enableScopeAPI = false; // Experimental Create Event Handle API.\nvar enableCacheElement = false;\nvar enableTransitionTracing = false; // No known bugs, but needs performance testing\n\nvar enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber\n// stuff. Intended to enable React core members to more easily debug scheduling\n// issues in DEV builds.\n\nvar enableDebugTracing = false; // Track which Fiber(s) schedule render work.\n\nvar REACT_MODULE_REFERENCE;\n\n{\n  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');\n}\n\nfunction isValidElementType(type) {\n  if (typeof type === 'string' || typeof type === 'function') {\n    return true;\n  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).\n\n\n  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {\n    return true;\n  }\n\n  if (typeof type === 'object' && type !== null) {\n    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object\n    // types supported by any Flight configuration anywhere since\n    // we don't know which Flight build this will end up being used\n    // with.\n    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction getWrappedName(outerType, innerType, wrapperName) {\n  var displayName = outerType.displayName;\n\n  if (displayName) {\n    return displayName;\n  }\n\n  var functionName = innerType.displayName || innerType.name || '';\n  return functionName !== '' ? wrapperName + \"(\" + functionName + \")\" : wrapperName;\n} // Keep in sync with react-reconciler/getComponentNameFromFiber\n\n\nfunction getContextName(type) {\n  return type.displayName || 'Context';\n} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.\n\n\nfunction getComponentNameFromType(type) {\n  if (type == null) {\n    // Host root, text node or just invalid type.\n    return null;\n  }\n\n  {\n    if (typeof type.tag === 'number') {\n      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');\n    }\n  }\n\n  if (typeof type === 'function') {\n    return type.displayName || type.name || null;\n  }\n\n  if (typeof type === 'string') {\n    return type;\n  }\n\n  switch (type) {\n    case REACT_FRAGMENT_TYPE:\n      return 'Fragment';\n\n    case REACT_PORTAL_TYPE:\n      return 'Portal';\n\n    case REACT_PROFILER_TYPE:\n      return 'Profiler';\n\n    case REACT_STRICT_MODE_TYPE:\n      return 'StrictMode';\n\n    case REACT_SUSPENSE_TYPE:\n      return 'Suspense';\n\n    case REACT_SUSPENSE_LIST_TYPE:\n      return 'SuspenseList';\n\n  }\n\n  if (typeof type === 'object') {\n    switch (type.$$typeof) {\n      case REACT_CONTEXT_TYPE:\n        var context = type;\n        return getContextName(context) + '.Consumer';\n\n      case REACT_PROVIDER_TYPE:\n        var provider = type;\n        return getContextName(provider._context) + '.Provider';\n\n      case REACT_FORWARD_REF_TYPE:\n        return getWrappedName(type, type.render, 'ForwardRef');\n\n      case REACT_MEMO_TYPE:\n        var outerName = type.displayName || null;\n\n        if (outerName !== null) {\n          return outerName;\n        }\n\n        return getComponentNameFromType(type.type) || 'Memo';\n\n      case REACT_LAZY_TYPE:\n        {\n          var lazyComponent = type;\n          var payload = lazyComponent._payload;\n          var init = lazyComponent._init;\n\n          try {\n            return getComponentNameFromType(init(payload));\n          } catch (x) {\n            return null;\n          }\n        }\n\n      // eslint-disable-next-line no-fallthrough\n    }\n  }\n\n  return null;\n}\n\nvar assign = Object.assign;\n\n// Helpers to patch console.logs to avoid logging during side-effect free\n// replaying on render function. This currently only patches the object\n// lazily which won't cover if the log function was extracted eagerly.\n// We could also eagerly patch the method.\nvar disabledDepth = 0;\nvar prevLog;\nvar prevInfo;\nvar prevWarn;\nvar prevError;\nvar prevGroup;\nvar prevGroupCollapsed;\nvar prevGroupEnd;\n\nfunction disabledLog() {}\n\ndisabledLog.__reactDisabledLog = true;\nfunction disableLogs() {\n  {\n    if (disabledDepth === 0) {\n      /* eslint-disable react-internal/no-production-logging */\n      prevLog = console.log;\n      prevInfo = console.info;\n      prevWarn = console.warn;\n      prevError = console.error;\n      prevGroup = console.group;\n      prevGroupCollapsed = console.groupCollapsed;\n      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099\n\n      var props = {\n        configurable: true,\n        enumerable: true,\n        value: disabledLog,\n        writable: true\n      }; // $FlowFixMe Flow thinks console is immutable.\n\n      Object.defineProperties(console, {\n        info: props,\n        log: props,\n        warn: props,\n        error: props,\n        group: props,\n        groupCollapsed: props,\n        groupEnd: props\n      });\n      /* eslint-enable react-internal/no-production-logging */\n    }\n\n    disabledDepth++;\n  }\n}\nfunction reenableLogs() {\n  {\n    disabledDepth--;\n\n    if (disabledDepth === 0) {\n      /* eslint-disable react-internal/no-production-logging */\n      var props = {\n        configurable: true,\n        enumerable: true,\n        writable: true\n      }; // $FlowFixMe Flow thinks console is immutable.\n\n      Object.defineProperties(console, {\n        log: assign({}, props, {\n          value: prevLog\n        }),\n        info: assign({}, props, {\n          value: prevInfo\n        }),\n        warn: assign({}, props, {\n          value: prevWarn\n        }),\n        error: assign({}, props, {\n          value: prevError\n        }),\n        group: assign({}, props, {\n          value: prevGroup\n        }),\n        groupCollapsed: assign({}, props, {\n          value: prevGroupCollapsed\n        }),\n        groupEnd: assign({}, props, {\n          value: prevGroupEnd\n        })\n      });\n      /* eslint-enable react-internal/no-production-logging */\n    }\n\n    if (disabledDepth < 0) {\n      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');\n    }\n  }\n}\n\nvar ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;\nvar prefix;\nfunction describeBuiltInComponentFrame(name, source, ownerFn) {\n  {\n    if (prefix === undefined) {\n      // Extract the VM specific prefix used by each line.\n      try {\n        throw Error();\n      } catch (x) {\n        var match = x.stack.trim().match(/\\n( *(at )?)/);\n        prefix = match && match[1] || '';\n      }\n    } // We use the prefix to ensure our stacks line up with native stack frames.\n\n\n    return '\\n' + prefix + name;\n  }\n}\nvar reentry = false;\nvar componentFrameCache;\n\n{\n  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;\n  componentFrameCache = new PossiblyWeakMap();\n}\n\nfunction describeNativeComponentFrame(fn, construct) {\n  // If something asked for a stack inside a fake render, it should get ignored.\n  if ( !fn || reentry) {\n    return '';\n  }\n\n  {\n    var frame = componentFrameCache.get(fn);\n\n    if (frame !== undefined) {\n      return frame;\n    }\n  }\n\n  var control;\n  reentry = true;\n  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.\n\n  Error.prepareStackTrace = undefined;\n  var previousDispatcher;\n\n  {\n    previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function\n    // for warnings.\n\n    ReactCurrentDispatcher.current = null;\n    disableLogs();\n  }\n\n  try {\n    // This should throw.\n    if (construct) {\n      // Something should be setting the props in the constructor.\n      var Fake = function () {\n        throw Error();\n      }; // $FlowFixMe\n\n\n      Object.defineProperty(Fake.prototype, 'props', {\n        set: function () {\n          // We use a throwing setter instead of frozen or non-writable props\n          // because that won't throw in a non-strict mode function.\n          throw Error();\n        }\n      });\n\n      if (typeof Reflect === 'object' && Reflect.construct) {\n        // We construct a different control for this case to include any extra\n        // frames added by the construct call.\n        try {\n          Reflect.construct(Fake, []);\n        } catch (x) {\n          control = x;\n        }\n\n        Reflect.construct(fn, [], Fake);\n      } else {\n        try {\n          Fake.call();\n        } catch (x) {\n          control = x;\n        }\n\n        fn.call(Fake.prototype);\n      }\n    } else {\n      try {\n        throw Error();\n      } catch (x) {\n        control = x;\n      }\n\n      fn();\n    }\n  } catch (sample) {\n    // This is inlined manually because closure doesn't do it for us.\n    if (sample && control && typeof sample.stack === 'string') {\n      // This extracts the first frame from the sample that isn't also in the control.\n      // Skipping one frame that we assume is the frame that calls the two.\n      var sampleLines = sample.stack.split('\\n');\n      var controlLines = control.stack.split('\\n');\n      var s = sampleLines.length - 1;\n      var c = controlLines.length - 1;\n\n      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {\n        // We expect at least one stack frame to be shared.\n        // Typically this will be the root most one. However, stack frames may be\n        // cut off due to maximum stack limits. In this case, one maybe cut off\n        // earlier than the other. We assume that the sample is longer or the same\n        // and there for cut off earlier. So we should find the root most frame in\n        // the sample somewhere in the control.\n        c--;\n      }\n\n      for (; s >= 1 && c >= 0; s--, c--) {\n        // Next we find the first one that isn't the same which should be the\n        // frame that called our sample function and the control.\n        if (sampleLines[s] !== controlLines[c]) {\n          // In V8, the first line is describing the message but other VMs don't.\n          // If we're about to return the first line, and the control is also on the same\n          // line, that's a pretty good indicator that our sample threw at same line as\n          // the control. I.e. before we entered the sample frame. So we ignore this result.\n          // This can happen if you passed a class to function component, or non-function.\n          if (s !== 1 || c !== 1) {\n            do {\n              s--;\n              c--; // We may still have similar intermediate frames from the construct call.\n              // The next one that isn't the same should be our match though.\n\n              if (c < 0 || sampleLines[s] !== controlLines[c]) {\n                // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n                var _frame = '\\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled \"<anonymous>\"\n                // but we have a user-provided \"displayName\"\n                // splice it in to make the stack more readable.\n\n\n                if (fn.displayName && _frame.includes('<anonymous>')) {\n                  _frame = _frame.replace('<anonymous>', fn.displayName);\n                }\n\n                {\n                  if (typeof fn === 'function') {\n                    componentFrameCache.set(fn, _frame);\n                  }\n                } // Return the line we found.\n\n\n                return _frame;\n              }\n            } while (s >= 1 && c >= 0);\n          }\n\n          break;\n        }\n      }\n    }\n  } finally {\n    reentry = false;\n\n    {\n      ReactCurrentDispatcher.current = previousDispatcher;\n      reenableLogs();\n    }\n\n    Error.prepareStackTrace = previousPrepareStackTrace;\n  } // Fallback to just using the name if we couldn't make it throw.\n\n\n  var name = fn ? fn.displayName || fn.name : '';\n  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';\n\n  {\n    if (typeof fn === 'function') {\n      componentFrameCache.set(fn, syntheticFrame);\n    }\n  }\n\n  return syntheticFrame;\n}\nfunction describeFunctionComponentFrame(fn, source, ownerFn) {\n  {\n    return describeNativeComponentFrame(fn, false);\n  }\n}\n\nfunction shouldConstruct(Component) {\n  var prototype = Component.prototype;\n  return !!(prototype && prototype.isReactComponent);\n}\n\nfunction describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {\n\n  if (type == null) {\n    return '';\n  }\n\n  if (typeof type === 'function') {\n    {\n      return describeNativeComponentFrame(type, shouldConstruct(type));\n    }\n  }\n\n  if (typeof type === 'string') {\n    return describeBuiltInComponentFrame(type);\n  }\n\n  switch (type) {\n    case REACT_SUSPENSE_TYPE:\n      return describeBuiltInComponentFrame('Suspense');\n\n    case REACT_SUSPENSE_LIST_TYPE:\n      return describeBuiltInComponentFrame('SuspenseList');\n  }\n\n  if (typeof type === 'object') {\n    switch (type.$$typeof) {\n      case REACT_FORWARD_REF_TYPE:\n        return describeFunctionComponentFrame(type.render);\n\n      case REACT_MEMO_TYPE:\n        // Memo may contain any component type so we recursively resolve it.\n        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);\n\n      case REACT_LAZY_TYPE:\n        {\n          var lazyComponent = type;\n          var payload = lazyComponent._payload;\n          var init = lazyComponent._init;\n\n          try {\n            // Lazy may contain any component type so we recursively resolve it.\n            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);\n          } catch (x) {}\n        }\n    }\n  }\n\n  return '';\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar loggedTypeFailures = {};\nvar ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\n\nfunction setCurrentlyValidatingElement(element) {\n  {\n    if (element) {\n      var owner = element._owner;\n      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);\n      ReactDebugCurrentFrame.setExtraStackFrame(stack);\n    } else {\n      ReactDebugCurrentFrame.setExtraStackFrame(null);\n    }\n  }\n}\n\nfunction checkPropTypes(typeSpecs, values, location, componentName, element) {\n  {\n    // $FlowFixMe This is okay but Flow doesn't know it.\n    var has = Function.call.bind(hasOwnProperty);\n\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            // eslint-disable-next-line react-internal/prod-error-codes\n            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n\n          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');\n        } catch (ex) {\n          error$1 = ex;\n        }\n\n        if (error$1 && !(error$1 instanceof Error)) {\n          setCurrentlyValidatingElement(element);\n\n          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);\n\n          setCurrentlyValidatingElement(null);\n        }\n\n        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error$1.message] = true;\n          setCurrentlyValidatingElement(element);\n\n          error('Failed %s type: %s', location, error$1.message);\n\n          setCurrentlyValidatingElement(null);\n        }\n      }\n    }\n  }\n}\n\nvar isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare\n\nfunction isArray(a) {\n  return isArrayImpl(a);\n}\n\n/*\n * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol\n * and Temporal.* types. See https://github.com/facebook/react/pull/22064.\n *\n * The functions in this module will throw an easier-to-understand,\n * easier-to-debug exception with a clear errors message message explaining the\n * problem. (Instead of a confusing exception thrown inside the implementation\n * of the `value` object).\n */\n// $FlowFixMe only called in DEV, so void return is not possible.\nfunction typeName(value) {\n  {\n    // toStringTag is needed for namespaced types like Temporal.Instant\n    var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;\n    var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';\n    return type;\n  }\n} // $FlowFixMe only called in DEV, so void return is not possible.\n\n\nfunction willCoercionThrow(value) {\n  {\n    try {\n      testStringCoercion(value);\n      return false;\n    } catch (e) {\n      return true;\n    }\n  }\n}\n\nfunction testStringCoercion(value) {\n  // If you ended up here by following an exception call stack, here's what's\n  // happened: you supplied an object or symbol value to React (as a prop, key,\n  // DOM attribute, CSS property, string ref, etc.) and when React tried to\n  // coerce it to a string using `'' + value`, an exception was thrown.\n  //\n  // The most common types that will cause this exception are `Symbol` instances\n  // and Temporal objects like `Temporal.Instant`. But any object that has a\n  // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this\n  // exception. (Library authors do this to prevent users from using built-in\n  // numeric operators like `+` or comparison operators like `>=` because custom\n  // methods are needed to perform accurate arithmetic or comparison.)\n  //\n  // To fix the problem, coerce this object or symbol value to a string before\n  // passing it to React. The most reliable way is usually `String(value)`.\n  //\n  // To find which value is throwing, check the browser or debugger console.\n  // Before this exception was thrown, there should be `console.error` output\n  // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the\n  // problem and how that type was used: key, atrribute, input value prop, etc.\n  // In most cases, this console output also shows the component and its\n  // ancestor components where the exception happened.\n  //\n  // eslint-disable-next-line react-internal/safe-string-coercion\n  return '' + value;\n}\nfunction checkKeyStringCoercion(value) {\n  {\n    if (willCoercionThrow(value)) {\n      error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));\n\n      return testStringCoercion(value); // throw (to help callers find troubleshooting comments)\n    }\n  }\n}\n\nvar ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;\nvar RESERVED_PROPS = {\n  key: true,\n  ref: true,\n  __self: true,\n  __source: true\n};\nvar specialPropKeyWarningShown;\nvar specialPropRefWarningShown;\nvar didWarnAboutStringRefs;\n\n{\n  didWarnAboutStringRefs = {};\n}\n\nfunction hasValidRef(config) {\n  {\n    if (hasOwnProperty.call(config, 'ref')) {\n      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\n\n      if (getter && getter.isReactWarning) {\n        return false;\n      }\n    }\n  }\n\n  return config.ref !== undefined;\n}\n\nfunction hasValidKey(config) {\n  {\n    if (hasOwnProperty.call(config, 'key')) {\n      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\n\n      if (getter && getter.isReactWarning) {\n        return false;\n      }\n    }\n  }\n\n  return config.key !== undefined;\n}\n\nfunction warnIfStringRefCannotBeAutoConverted(config, self) {\n  {\n    if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {\n      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);\n\n      if (!didWarnAboutStringRefs[componentName]) {\n        error('Component \"%s\" contains the string ref \"%s\". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);\n\n        didWarnAboutStringRefs[componentName] = true;\n      }\n    }\n  }\n}\n\nfunction defineKeyPropWarningGetter(props, displayName) {\n  {\n    var warnAboutAccessingKey = function () {\n      if (!specialPropKeyWarningShown) {\n        specialPropKeyWarningShown = true;\n\n        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);\n      }\n    };\n\n    warnAboutAccessingKey.isReactWarning = true;\n    Object.defineProperty(props, 'key', {\n      get: warnAboutAccessingKey,\n      configurable: true\n    });\n  }\n}\n\nfunction defineRefPropWarningGetter(props, displayName) {\n  {\n    var warnAboutAccessingRef = function () {\n      if (!specialPropRefWarningShown) {\n        specialPropRefWarningShown = true;\n\n        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);\n      }\n    };\n\n    warnAboutAccessingRef.isReactWarning = true;\n    Object.defineProperty(props, 'ref', {\n      get: warnAboutAccessingRef,\n      configurable: true\n    });\n  }\n}\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, instanceof check\n * will not work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} props\n * @param {*} key\n * @param {string|object} ref\n * @param {*} owner\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @internal\n */\n\n\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\n  var element = {\n    // This tag allows us to uniquely identify this as a React Element\n    $$typeof: REACT_ELEMENT_TYPE,\n    // Built-in properties that belong on the element\n    type: type,\n    key: key,\n    ref: ref,\n    props: props,\n    // Record the component responsible for creating this element.\n    _owner: owner\n  };\n\n  {\n    // The validation flag is currently mutative. We put it on\n    // an external backing store so that we can freeze the whole object.\n    // This can be replaced with a WeakMap once they are implemented in\n    // commonly used development environments.\n    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make\n    // the validation flag non-enumerable (where possible, which should\n    // include every environment we run tests in), so the test framework\n    // ignores it.\n\n    Object.defineProperty(element._store, 'validated', {\n      configurable: false,\n      enumerable: false,\n      writable: true,\n      value: false\n    }); // self and source are DEV only properties.\n\n    Object.defineProperty(element, '_self', {\n      configurable: false,\n      enumerable: false,\n      writable: false,\n      value: self\n    }); // Two elements created in two different places should be considered\n    // equal for testing purposes and therefore we hide it from enumeration.\n\n    Object.defineProperty(element, '_source', {\n      configurable: false,\n      enumerable: false,\n      writable: false,\n      value: source\n    });\n\n    if (Object.freeze) {\n      Object.freeze(element.props);\n      Object.freeze(element);\n    }\n  }\n\n  return element;\n};\n/**\n * https://github.com/reactjs/rfcs/pull/107\n * @param {*} type\n * @param {object} props\n * @param {string} key\n */\n\nfunction jsxDEV(type, config, maybeKey, source, self) {\n  {\n    var propName; // Reserved names are extracted\n\n    var props = {};\n    var key = null;\n    var ref = null; // Currently, key can be spread in as a prop. This causes a potential\n    // issue if key is also explicitly declared (ie. <div {...props} key=\"Hi\" />\n    // or <div key=\"Hi\" {...props} /> ). We want to deprecate key spread,\n    // but as an intermediary step, we will use jsxDEV for everything except\n    // <div {...props} key=\"Hi\" />, because we aren't currently able to tell if\n    // key is explicitly declared to be undefined or not.\n\n    if (maybeKey !== undefined) {\n      {\n        checkKeyStringCoercion(maybeKey);\n      }\n\n      key = '' + maybeKey;\n    }\n\n    if (hasValidKey(config)) {\n      {\n        checkKeyStringCoercion(config.key);\n      }\n\n      key = '' + config.key;\n    }\n\n    if (hasValidRef(config)) {\n      ref = config.ref;\n      warnIfStringRefCannotBeAutoConverted(config, self);\n    } // Remaining properties are added to a new props object\n\n\n    for (propName in config) {\n      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        props[propName] = config[propName];\n      }\n    } // Resolve default props\n\n\n    if (type && type.defaultProps) {\n      var defaultProps = type.defaultProps;\n\n      for (propName in defaultProps) {\n        if (props[propName] === undefined) {\n          props[propName] = defaultProps[propName];\n        }\n      }\n    }\n\n    if (key || ref) {\n      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\n\n      if (key) {\n        defineKeyPropWarningGetter(props, displayName);\n      }\n\n      if (ref) {\n        defineRefPropWarningGetter(props, displayName);\n      }\n    }\n\n    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\n  }\n}\n\nvar ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;\nvar ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;\n\nfunction setCurrentlyValidatingElement$1(element) {\n  {\n    if (element) {\n      var owner = element._owner;\n      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);\n      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);\n    } else {\n      ReactDebugCurrentFrame$1.setExtraStackFrame(null);\n    }\n  }\n}\n\nvar propTypesMisspellWarningShown;\n\n{\n  propTypesMisspellWarningShown = false;\n}\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a ReactElement.\n * @final\n */\n\n\nfunction isValidElement(object) {\n  {\n    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n  }\n}\n\nfunction getDeclarationErrorAddendum() {\n  {\n    if (ReactCurrentOwner$1.current) {\n      var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);\n\n      if (name) {\n        return '\\n\\nCheck the render method of `' + name + '`.';\n      }\n    }\n\n    return '';\n  }\n}\n\nfunction getSourceInfoErrorAddendum(source) {\n  {\n    if (source !== undefined) {\n      var fileName = source.fileName.replace(/^.*[\\\\\\/]/, '');\n      var lineNumber = source.lineNumber;\n      return '\\n\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\n    }\n\n    return '';\n  }\n}\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\n\n\nvar ownerHasKeyUseWarning = {};\n\nfunction getCurrentComponentErrorInfo(parentType) {\n  {\n    var info = getDeclarationErrorAddendum();\n\n    if (!info) {\n      var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\n\n      if (parentName) {\n        info = \"\\n\\nCheck the top-level render call using <\" + parentName + \">.\";\n      }\n    }\n\n    return info;\n  }\n}\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it. Error statuses are cached so a warning\n * will only be shown once.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\n\n\nfunction validateExplicitKey(element, parentType) {\n  {\n    if (!element._store || element._store.validated || element.key != null) {\n      return;\n    }\n\n    element._store.validated = true;\n    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\n\n    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\n      return;\n    }\n\n    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a\n    // property, it may be the creator of the child that's responsible for\n    // assigning it a key.\n\n    var childOwner = '';\n\n    if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {\n      // Give the component that originally created this child.\n      childOwner = \" It was passed a child from \" + getComponentNameFromType(element._owner.type) + \".\";\n    }\n\n    setCurrentlyValidatingElement$1(element);\n\n    error('Each child in a list should have a unique \"key\" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);\n\n    setCurrentlyValidatingElement$1(null);\n  }\n}\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\n\n\nfunction validateChildKeys(node, parentType) {\n  {\n    if (typeof node !== 'object') {\n      return;\n    }\n\n    if (isArray(node)) {\n      for (var i = 0; i < node.length; i++) {\n        var child = node[i];\n\n        if (isValidElement(child)) {\n          validateExplicitKey(child, parentType);\n        }\n      }\n    } else if (isValidElement(node)) {\n      // This element was passed in a valid location.\n      if (node._store) {\n        node._store.validated = true;\n      }\n    } else if (node) {\n      var iteratorFn = getIteratorFn(node);\n\n      if (typeof iteratorFn === 'function') {\n        // Entry iterators used to provide implicit keys,\n        // but now we print a separate warning for them later.\n        if (iteratorFn !== node.entries) {\n          var iterator = iteratorFn.call(node);\n          var step;\n\n          while (!(step = iterator.next()).done) {\n            if (isValidElement(step.value)) {\n              validateExplicitKey(step.value, parentType);\n            }\n          }\n        }\n      }\n    }\n  }\n}\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\n\n\nfunction validatePropTypes(element) {\n  {\n    var type = element.type;\n\n    if (type === null || type === undefined || typeof type === 'string') {\n      return;\n    }\n\n    var propTypes;\n\n    if (typeof type === 'function') {\n      propTypes = type.propTypes;\n    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.\n    // Inner props are checked in the reconciler.\n    type.$$typeof === REACT_MEMO_TYPE)) {\n      propTypes = type.propTypes;\n    } else {\n      return;\n    }\n\n    if (propTypes) {\n      // Intentionally inside to avoid triggering lazy initializers:\n      var name = getComponentNameFromType(type);\n      checkPropTypes(propTypes, element.props, 'prop', name, element);\n    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\n      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:\n\n      var _name = getComponentNameFromType(type);\n\n      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');\n    }\n\n    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {\n      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');\n    }\n  }\n}\n/**\n * Given a fragment, validate that it can only be provided with fragment props\n * @param {ReactElement} fragment\n */\n\n\nfunction validateFragmentProps(fragment) {\n  {\n    var keys = Object.keys(fragment.props);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n\n      if (key !== 'children' && key !== 'key') {\n        setCurrentlyValidatingElement$1(fragment);\n\n        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\n\n        setCurrentlyValidatingElement$1(null);\n        break;\n      }\n    }\n\n    if (fragment.ref !== null) {\n      setCurrentlyValidatingElement$1(fragment);\n\n      error('Invalid attribute `ref` supplied to `React.Fragment`.');\n\n      setCurrentlyValidatingElement$1(null);\n    }\n  }\n}\n\nvar didWarnAboutKeySpread = {};\nfunction jsxWithValidation(type, props, key, isStaticChildren, source, self) {\n  {\n    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to\n    // succeed and there will likely be errors in render.\n\n    if (!validType) {\n      var info = '';\n\n      if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n        info += ' You likely forgot to export your component from the file ' + \"it's defined in, or you might have mixed up default and named imports.\";\n      }\n\n      var sourceInfo = getSourceInfoErrorAddendum(source);\n\n      if (sourceInfo) {\n        info += sourceInfo;\n      } else {\n        info += getDeclarationErrorAddendum();\n      }\n\n      var typeString;\n\n      if (type === null) {\n        typeString = 'null';\n      } else if (isArray(type)) {\n        typeString = 'array';\n      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\n        typeString = \"<\" + (getComponentNameFromType(type.type) || 'Unknown') + \" />\";\n        info = ' Did you accidentally export a JSX literal instead of a component?';\n      } else {\n        typeString = typeof type;\n      }\n\n      error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\n    }\n\n    var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.\n    // TODO: Drop this when these are no longer allowed as the type argument.\n\n    if (element == null) {\n      return element;\n    } // Skip key warning if the type isn't valid since our key validation logic\n    // doesn't expect a non-string/function type and can throw confusing errors.\n    // We don't want exception behavior to differ between dev and prod.\n    // (Rendering will throw with a helpful message and as soon as the type is\n    // fixed, the key warnings will appear.)\n\n\n    if (validType) {\n      var children = props.children;\n\n      if (children !== undefined) {\n        if (isStaticChildren) {\n          if (isArray(children)) {\n            for (var i = 0; i < children.length; i++) {\n              validateChildKeys(children[i], type);\n            }\n\n            if (Object.freeze) {\n              Object.freeze(children);\n            }\n          } else {\n            error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');\n          }\n        } else {\n          validateChildKeys(children, type);\n        }\n      }\n    }\n\n    {\n      if (hasOwnProperty.call(props, 'key')) {\n        var componentName = getComponentNameFromType(type);\n        var keys = Object.keys(props).filter(function (k) {\n          return k !== 'key';\n        });\n        var beforeExample = keys.length > 0 ? '{key: someKey, ' + keys.join(': ..., ') + ': ...}' : '{key: someKey}';\n\n        if (!didWarnAboutKeySpread[componentName + beforeExample]) {\n          var afterExample = keys.length > 0 ? '{' + keys.join(': ..., ') + ': ...}' : '{}';\n\n          error('A props object containing a \"key\" prop is being spread into JSX:\\n' + '  let props = %s;\\n' + '  <%s {...props} />\\n' + 'React keys must be passed directly to JSX without using spread:\\n' + '  let props = %s;\\n' + '  <%s key={someKey} {...props} />', beforeExample, componentName, afterExample, componentName);\n\n          didWarnAboutKeySpread[componentName + beforeExample] = true;\n        }\n      }\n    }\n\n    if (type === REACT_FRAGMENT_TYPE) {\n      validateFragmentProps(element);\n    } else {\n      validatePropTypes(element);\n    }\n\n    return element;\n  }\n} // These two functions exist to still get child warnings in dev\n// even with the prod transform. This means that jsxDEV is purely\n// opt-in behavior for better messages but that we won't stop\n// giving you warnings if you use production apis.\n\nfunction jsxWithValidationStatic(type, props, key) {\n  {\n    return jsxWithValidation(type, props, key, true);\n  }\n}\nfunction jsxWithValidationDynamic(type, props, key) {\n  {\n    return jsxWithValidation(type, props, key, false);\n  }\n}\n\nvar jsx =  jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.\n// for now we can ship identical prod functions\n\nvar jsxs =  jsxWithValidationStatic ;\n\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.jsx = jsx;\nexports.jsxs = jsxs;\n  })();\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","import { ProTable } from '@ant-design/pro-components'\nimport type { ProTableProps, ParamsType } from '@ant-design/pro-components'\nimport Component from '../../lib/component'\nimport { ProColumnsType } from '../../type'\nimport type { ProTableColumn } from '../../adapter/protable'\n\n/**\n * ProColumnsTable Props\n * 扩展 ProTable Props，添加 pro-columns 特性\n */\nexport interface ProColumnsTableProps<\n  T extends Record<string, any> = any,\n  U extends ParamsType = ParamsType,\n  ValueType = 'text'\n> extends Omit<ProTableProps<T, U, ValueType>, 'columns'> {\n  /**\n   * columns 配置（支持策略系统）\n   */\n  columns: ProColumnsType.ColumnType[]\n  /**\n   * 枚举字典\n   */\n  enums?: Record<string, any>\n  /**\n   * 运行时应用的策略（会添加到每个 column 的策略列表中）\n   */\n  applyStrategies?: ProColumnsType.StrategyItem[]\n  /**\n   * 是否使用 merge 模式合并策略（默认 true）\n   */\n  mergeMode?: boolean\n  /**\n   * 针对特定 column 的策略配置\n   */\n  columnStrategies?: Array<{\n    /** 目标 column 的 dataIndex */\n    dataIndex: string\n    /** 要应用的策略列表 */\n    strategies: ProColumnsType.StrategyItem[]\n    /** 是否使用 merge 模式（默认 true）。true=合并，false=替换该 column 的所有策略 */\n    mergeMode?: boolean\n  }>\n}\n\n/**\n * ProColumnsTable 组件\n *\n * 基于 ProTable 的封装，集成 pro-columns 策略系统\n *\n * @example\n * ```tsx\n * <ProColumnsTable\n *   columns={columns}\n *   enums={{ statusEnum }}\n *   dataSource={dataSource}\n *   rowKey=\"id\"\n * />\n * ```\n */\nfunction ProColumnsTable<\n  T extends Record<string, any> = any,\n  U extends ParamsType = ParamsType,\n  ValueType = 'text'\n>(props: ProColumnsTableProps<T, U, ValueType>) {\n  const {\n    columns,\n    enums,\n    applyStrategies,\n    mergeMode,\n    columnStrategies,\n    ...tableProps\n  } = props\n\n  return (\n    <ProTable<T, U, ValueType>\n      columns={\n        Component.transform<ProTableColumn>('proTable', columns, {\n          enums,\n          applyStrategies,\n          mergeMode,\n          columnStrategies,\n        }) as any\n      }\n      {...tableProps}\n    />\n  )\n}\n\nexport default ProColumnsTable\n","import { BetaSchemaForm } from '@ant-design/pro-components'\nimport Component from '../../lib/component'\nimport { ProColumnsType } from '../../type'\nimport type { ProFormField } from '../../adapter/proform'\n\n/**\n * ProColumnsForm Props\n * 扩展 BetaSchemaForm Props，添加 pro-columns 特性\n */\nexport interface ProColumnsFormProps extends Record<string, any> {\n  /**\n   * columns 配置（支持策略系统）\n   */\n  columns: ProColumnsType.ColumnType[]\n  /**\n   * 枚举字典\n   */\n  enums?: Record<string, any>\n  /**\n   * 运行时应用的策略（会添加到每个 column 的策略列表中）\n   */\n  applyStrategies?: ProColumnsType.StrategyItem[]\n  /**\n   * 是否使用 merge 模式合并策略（默认 true）\n   */\n  mergeMode?: boolean\n  /**\n   * 针对特定 column 的策略配置\n   */\n  columnStrategies?: Array<{\n    /** 目标 column 的 dataIndex */\n    dataIndex: string\n    /** 要应用的策略列表 */\n    strategies: ProColumnsType.StrategyItem[]\n    /** 是否使用 merge 模式（默认 true）。true=合并，false=替换该 column 的所有策略 */\n    mergeMode?: boolean\n  }>\n}\n\n/**\n * ProColumnsForm 组件\n *\n * 基于 BetaSchemaForm 的封装，集成 pro-columns 策略系统\n *\n * @example\n * ```tsx\n * <ProColumnsForm\n *   columns={columns}\n *   enums={{ statusEnum }}\n *   onFinish={handleSubmit}\n * />\n * ```\n */\nfunction ProColumnsForm<T = any>(props: ProColumnsFormProps) {\n  const {\n    columns,\n    enums,\n    applyStrategies,\n    mergeMode,\n    columnStrategies,\n    ...formProps\n  } = props\n\n  return (\n    <BetaSchemaForm<T>\n      columns={\n        Component.transform<ProFormField>('proForm', columns, {\n          enums,\n          applyStrategies,\n          mergeMode,\n          columnStrategies,\n        }) as any\n      }\n      {...formProps}\n    />\n  )\n}\n\nexport default ProColumnsForm\n","import { ProDescriptions } from '@ant-design/pro-components'\nimport type { ProDescriptionsProps } from '@ant-design/pro-components'\nimport Component from '../../lib/component'\nimport { ProColumnsType } from '../../type'\nimport type { ProDescriptionColumn } from '../../adapter/proDescription'\n\n/**\n * ProColumnsDescription Props\n * 扩展 ProDescriptions Props，添加 pro-columns 特性\n */\nexport interface ProColumnsDescriptionProps<\n  T extends Record<string, any> = any,\n  ValueType = 'text'\n> extends Omit<ProDescriptionsProps<T, ValueType>, 'columns'> {\n  /**\n   * columns 配置（支持策略系统）\n   */\n  columns: ProColumnsType.ColumnType[]\n  /**\n   * 枚举字典\n   */\n  enums?: Record<string, any>\n  /**\n   * 运行时应用的策略（会添加到每个 column 的策略列表中）\n   */\n  applyStrategies?: ProColumnsType.StrategyItem[]\n  /**\n   * 是否使用 merge 模式合并策略（默认 true）\n   */\n  mergeMode?: boolean\n  /**\n   * 针对特定 column 的策略配置\n   */\n  columnStrategies?: Array<{\n    /** 目标 column 的 dataIndex */\n    dataIndex: string\n    /** 要应用的策略列表 */\n    strategies: ProColumnsType.StrategyItem[]\n    /** 是否使用 merge 模式（默认 true）。true=合并，false=替换该 column 的所有策略 */\n    mergeMode?: boolean\n  }>\n}\n\n/**\n * ProColumnsDescription 组件\n *\n * 基于 ProDescriptions 的封装，集成 pro-columns 策略系统\n *\n * @example\n * ```tsx\n * <ProColumnsDescription\n *   columns={columns}\n *   enums={{ statusEnum }}\n *   dataSource={dataSource}\n *   column={3}\n * />\n * ```\n */\nfunction ProColumnsDescription<\n  T extends Record<string, any> = any,\n  ValueType = 'text'\n>(props: ProColumnsDescriptionProps<T, ValueType>) {\n  const {\n    columns,\n    enums,\n    applyStrategies,\n    mergeMode,\n    columnStrategies,\n    ...descriptionProps\n  } = props\n\n  return (\n    <ProDescriptions<T, ValueType>\n      columns={\n        Component.transform<ProDescriptionColumn>('proDescription', columns, {\n          enums,\n          applyStrategies,\n          mergeMode,\n          columnStrategies,\n        }) as any\n      }\n      {...descriptionProps}\n    />\n  )\n}\n\nexport default ProColumnsDescription\n","import Columns from './lib/columns'\nimport Component from './lib/component'\n\n// 导出核心模块\nexport { Columns, Component }\n\n// 自动注册所有适配器\nimport {\n  ProTableAdapter,\n  ProFormAdapter,\n  ProDescriptionAdapter,\n} from './adapter'\n\nComponent.register(ProTableAdapter)\nComponent.register(ProFormAdapter)\nComponent.register(ProDescriptionAdapter)\n\n// 导出所有策略和工具函数\nexport {\n  // 内置策略\n  Search,\n  Sort,\n  Required,\n  Placeholder,\n  Format,\n  Tooltip,\n  DefaultValue,\n  Width,\n  Copy,\n  Link,\n  Image,\n  Enum,\n  Validation,\n  Permission,\n  Transform,\n  Editable,\n  // 工具函数\n  createStrategy,\n  deepMerge,\n  hasField,\n  getField,\n  setField,\n  getFieldType,\n  generatePlaceholder,\n} from './strategy'\n\n// 导出预设系统\nexport { default as Presets } from './presets'\n\n// 导出封装组件\nexport { default as ProColumnsTable } from './components/ProColumnsTable'\nexport { default as ProColumnsForm } from './components/ProColumnsForm'\nexport { default as ProColumnsDescription } from './components/ProColumnsDescription'\n\n// 导出组件类型\nexport type { ProColumnsTableProps } from './components/ProColumnsTable'\nexport type { ProColumnsFormProps } from './components/ProColumnsForm'\nexport type { ProColumnsDescriptionProps } from './components/ProColumnsDescription'\n\n// 导出类型定义\nexport type { ProColumnsType } from './type'"],"names":["deepMerge","target","source","result","key","sourceValue","targetValue","hasField","column","field","getField","defaultValue","setField","value","getFieldType","fieldProps","generatePlaceholder","action","title","fieldType","actionText","defaultAction","createStrategy","fn","scene","updates","Search","options","enable","searchTypeMap","defaultSearchTypeMap","valueType","searchType","Sort","defaultSorter","dataIndex","sorter","a","b","aVal","bVal","Required","messageTemplate","defaultMessageTemplate","existingRules","rule","message","finalMessage","Placeholder","template","includeSearch","existingFieldProps","placeholder","searchValue","searchPlaceholder","formatNumber","precision","useGrouping","formatMoney","symbol","formattedNumber","formatPercent","formatDate","format","date","year","month","day","hours","minutes","seconds","Format","type","dateFormat","formatter","formatType","renderFunction","text","record","Tooltip","content","formType","showInTable","showInForm","tooltipContent","existingFormItemProps","inferDefaultValue","valueEnum","DefaultValue","autoInfer","inferWidthByType","calculateWidthByTitle","charWidth","padding","chineseCount","englishCount","char","totalWidth","calculateNumberWidth","config","auto","min","max","calculatedWidth","typeWidth","titleWidth","Width","table","form","description","tableWidth","descWidth","Copy","tooltipText","successText","Link","href","onClick","displayText","React","e","linkHref","Image","width","height","preview","fallback","separator","maxCount","imageUrls","url","displayUrls","hasMore","Space","index","Enum","colorMap","defaultColor","enumItem","status","Badge","Tag","Validation","pattern","patternMessage","minMessage","maxMessage","minLength","minLengthMessage","maxLength","maxLengthMessage","validator","dependencies","newRules","allRules","defaultPermissionChecker","context","roles","permissions","userRoles","userPermissions","role","permission","Permission","hideWhenNoPermission","disableWhenNoPermission","checker","Transform","input","output","display","existingConvertValue","existingTransform","args","originalValue","Editable","editableConfig","editableOptions","originRow","newLineConfig","newValue","merge","ori","cur","mergedStrategies","s","execute","strategys","strategyConfig","allowedScenes","strategyFn","processed","Strategy","columns","strategy","Columns","props","enums","applyStrategies","mergeMode","columnStrategies","columnsWithColumnStrategies","processedColumn","enumKey","runtimeStrategyConfig","columnStrategy","cs","targetStrategyConfig","adapters","sceneMap","Component","adapter","name","inferredScene","processedColumns","ProTableAdapter","tableColumn","ProFormAdapter","formField","ProDescriptionAdapter","descColumn","presetRegistry","Presets","preset","onSave","f","require$$0","k","l","m","n","p","q","c","d","h","reactJsxRuntime_production_min","REACT_ELEMENT_TYPE","REACT_PORTAL_TYPE","REACT_FRAGMENT_TYPE","REACT_STRICT_MODE_TYPE","REACT_PROFILER_TYPE","REACT_PROVIDER_TYPE","REACT_CONTEXT_TYPE","REACT_FORWARD_REF_TYPE","REACT_SUSPENSE_TYPE","REACT_SUSPENSE_LIST_TYPE","REACT_MEMO_TYPE","REACT_LAZY_TYPE","REACT_OFFSCREEN_TYPE","MAYBE_ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","getIteratorFn","maybeIterable","maybeIterator","ReactSharedInternals","error","_len2","_key2","printWarning","level","ReactDebugCurrentFrame","stack","argsWithFormat","item","enableScopeAPI","enableCacheElement","enableTransitionTracing","enableLegacyHidden","enableDebugTracing","REACT_MODULE_REFERENCE","isValidElementType","getWrappedName","outerType","innerType","wrapperName","displayName","functionName","getContextName","getComponentNameFromType","provider","outerName","lazyComponent","payload","init","assign","disabledDepth","prevLog","prevInfo","prevWarn","prevError","prevGroup","prevGroupCollapsed","prevGroupEnd","disabledLog","disableLogs","reenableLogs","ReactCurrentDispatcher","prefix","describeBuiltInComponentFrame","ownerFn","x","match","reentry","componentFrameCache","PossiblyWeakMap","describeNativeComponentFrame","construct","frame","control","previousPrepareStackTrace","previousDispatcher","Fake","sample","sampleLines","controlLines","_frame","syntheticFrame","describeFunctionComponentFrame","shouldConstruct","prototype","describeUnknownElementTypeFrameInDEV","hasOwnProperty","loggedTypeFailures","setCurrentlyValidatingElement","element","owner","checkPropTypes","typeSpecs","values","location","componentName","has","typeSpecName","error$1","err","ex","isArrayImpl","isArray","typeName","hasToStringTag","willCoercionThrow","testStringCoercion","checkKeyStringCoercion","ReactCurrentOwner","RESERVED_PROPS","specialPropKeyWarningShown","specialPropRefWarningShown","hasValidRef","getter","hasValidKey","warnIfStringRefCannotBeAutoConverted","self","defineKeyPropWarningGetter","warnAboutAccessingKey","defineRefPropWarningGetter","warnAboutAccessingRef","ReactElement","ref","jsxDEV","maybeKey","propName","defaultProps","ReactCurrentOwner$1","ReactDebugCurrentFrame$1","setCurrentlyValidatingElement$1","propTypesMisspellWarningShown","isValidElement","object","getDeclarationErrorAddendum","getSourceInfoErrorAddendum","ownerHasKeyUseWarning","getCurrentComponentErrorInfo","parentType","info","parentName","validateExplicitKey","currentComponentErrorInfo","childOwner","validateChildKeys","node","i","child","iteratorFn","iterator","step","validatePropTypes","propTypes","_name","validateFragmentProps","fragment","keys","didWarnAboutKeySpread","jsxWithValidation","isStaticChildren","validType","sourceInfo","typeString","children","beforeExample","afterExample","jsxWithValidationStatic","jsxWithValidationDynamic","jsx","jsxs","reactJsxRuntime_development","jsxRuntimeModule","require$$1","ProColumnsTable","tableProps","ProTable","ProColumnsForm","formProps","BetaSchemaForm","ProColumnsDescription","descriptionProps","ProDescriptions"],"mappings":"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","x_google_ignoreList":[24,25,26]}