import snippets from './snippets';
import button from '../button/meta';
import {
  fields2Columns,
  genDataSourceValueKey,
  getColumnsDataIndex,
  resetTableProps,
  getFormContent,
  setDefaultOperationAndTitleButtons,
  getJsSlot,
  fields2TableFilterOptions,
  filterTypes,
  setDefaultSearchFilter,
  setDefaultSort,
  getFieldComponent,
} from './utils';
import { getVariable, setBatchVariables } from '../data-source-form/utils';
import { uuid } from '../_utils/utils';
import { IPublicTypeFieldConfig } from '@alilc/lowcode-types';
import { getFormItemGeneralInfoGroup } from '../_utils/defaultSchema';

const getI18n = (
  item:
    | {
        type: string;
        key: string;
        en: string;
        'zh-CN': string;
        'zh-HK': string;
      }
    | string
) => {
  if (typeof item === 'string') {
    return item;
  }
  if (item.type === 'i18n') {
    return item['zh-CN'] || item['zh-HK'] || item['en'];
  }
};

const dataSourceTable = {
  snippets,
  componentName: 'DataSourceTable',
  title: '表格',
  category: '无代码数据展示',
  group: '无代码组件',
  docUrl: '',
  screenshot: '',
  devMode: 'proCode',
  npm: {
    package: '@pisell/materials',
    version: '1.0.1',
    exportName: 'DataSourceTable',
    main: 'src/index.tsx',
    destructuring: true,
    subName: '',
  },
  generalProps: [
    {
      type: 'group',
      title: {
        type: 'i18n',
        'en-US': 'Data',
        'zh-CN': '数据',
      },
      display: 'accordion',
      items: [
        {
          name: 'dataSource',
          title: {
            type: 'i18n',
            'en-US': 'Source',
            'zh-CN': '数据源',
          },
          display: 'block',
          extraProps: {
            setValue(target: any, value: any) {
              // 如果value为空，则清空表格
              if (!value.item) {
                resetTableProps(target);
                return target.getProps().setPropValue('dataSource', '');
              }

              const setBatchVariablesFunc = () => {
                setBatchVariables(target, [
                  {
                    label: 'currentFields',
                    value: value.item.fields,
                  },
                  {
                    label: 'dataSourceVariables',
                    value: [
                      {
                        label: '当前数据表',
                        value: genDataSourceValueKey(target, 'currentDataSource'),
                        item: value.item,
                        isVariable: true,
                      },
                    ],
                  },
                  {
                    label: 'dataSourceTitle',
                    value: value.title,
                  },
                  {
                    label: 'currentValueVariables',
                    value: [
                      {
                        label: '当前行数据',
                        value: genDataSourceValueKey(target, 'currentRecord'),
                      },
                    ],
                  },
                ]);
              }

              setBatchVariablesFunc();

              // 如果重新选择选择数据源，则清空表格
              if (value.isSelect) {
                resetTableProps(target);

                setBatchVariablesFunc();

                const columns = fields2Columns(value.item.fields);

                target.getProps().setPropValue('columns', columns);
                target.getProps().setPropValue('title', value.title);

                // 生成默认操作列和标题行按钮
                setDefaultOperationAndTitleButtons(target);

                if (
                  !['pisell2-api', 'mypisell-api'].includes(
                    value.item.headerDataSource
                  )
                ) {
                  // 生成默认搜索筛选
                  setDefaultSearchFilter(target, value.item.fields);

                  // 生成默认排序
                  setDefaultSort(target, value.item.fields);
                }
              }

              return target.getProps().setPropValue('dataSource', value.item);
            },
          },
          setter: {
            componentName: 'PisellDataSourceSetter',
            props: {
              filters: {
                tables: 'all',
                variables: {},
              },
            },
          },
        },
        {
          name: 'columns',
          title: {
            label: {
              type: 'i18n',
              'en-US': 'Columns',
              'zh-CN': '表格列',
            },
            tip: {
              type: 'i18n',
              'en-US':
                'Table columns configuration description, see below for details',
              'zh-CN': '表格列的配置描述，具体项见下表',
            },
          },
          setter: {
            componentName: 'ArraySetter',
            props: {
              itemSetter: {
                componentName: 'ObjectSetter',
                props: {
                  config: {
                    items: [
                      {
                        name: 'title',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Column Title',
                            'zh-CN': '列标题',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US': 'title | Column Title',
                            'zh-CN': 'title | 列标题',
                          },
                        },
                        propType: {
                          type: 'oneOfType',
                          value: ['string', 'func'],
                        },
                        setter: [
                          'PisellI18nSetter',
                          {
                            componentName: 'SlotSetter',
                            title: '列标题插槽',
                            initialValue: {
                              type: 'JSSlot',
                              params: ['options'],
                              value: [],
                            },
                          },
                        ],
                      },
                      {
                        name: 'width',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Column Width',
                            'zh-CN': '列宽',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US': 'width | Column Width',
                            'zh-CN': 'width | 列宽',
                          },
                        },
                        propType: {
                          type: 'oneOfType',
                          value: ['number', 'string'],
                        },
                        setter: ['NumberSetter', 'StringSetter'],
                      },
                      {
                        name: 'align',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Alignment',
                            'zh-CN': '对齐方式',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US': 'align | Set the alignment of the column',
                            'zh-CN': 'align | 设置列的对齐方式',
                          },
                        },
                        propType: {
                          type: 'oneOf',
                          value: ['left', 'right', 'center'],
                        },
                        defaultValue: 'left',
                        setter: {
                          componentName: 'RadioGroupSetter',
                          props: {
                            options: [
                              { title: '左对齐', value: 'left' },
                              { title: '居中对齐', value: 'center' },
                              { title: '右对齐', value: 'right' },
                            ],
                          },
                        },
                      },
                      {
                        name: 'fixed',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Column Fixed',
                            'zh-CN': '列固定',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US': 'fixed | Whether the column is fixed',
                            'zh-CN': 'fixed | 列是否固定',
                          },
                        },
                        propType: {
                          type: 'oneOf',
                          value: ['left', 'right', false],
                        },
                        defaultValue: false,
                        setter: {
                          componentName: 'RadioGroupSetter',
                          props: {
                            options: [
                              { title: '不固定', value: false },
                              { title: '左固定', value: 'left' },
                              { title: '右固定', value: 'right' },
                            ],
                          },
                        },
                      },
                      {
                        name: 'dataIndex',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Data Field',
                            'zh-CN': '数据字段',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US': 'dataIndex | Data Field',
                            'zh-CN': 'dataIndex | 数据字段',
                          },
                        },
                        setter: [
                          {
                            componentName: 'SelectSetter',
                            condition: (target: any) => {
                              // 获取表单容器组件的currentFields
                              const fields = getVariable(
                                target,
                                'currentFields'
                              );
                              // 如果fields存在且长度大于0，则显示选择器
                              return fields && fields.length > 0;
                            },
                            props: (target: any) => {
                              // 获取表单容器组件的currentFields
                              const fields = getVariable(
                                target,
                                'currentFields'
                              );
                              // 已有字段key
                              const usedFields = getColumnsDataIndex(target);

                              const options = fields?.map?.((item: any) => ({
                                title: item.uiSchema.title,
                                value: item.name,
                                disabled: usedFields.includes(item.name),
                              }));

                              return {
                                mode: 'single',
                                options: options || [],
                              };
                            },
                          },
                          'StringSetter',
                        ],
                        extraProps: {
                          setValue(target: any, value: string | any) {
                            // 获取表单容器组件的currentFields
                            const fields = getVariable(target, 'currentFields');
                            // 根据value值找到对应的label
                            const field = fields.find(
                              (item: any) => item.name === value
                            );
                            // 设置label
                            if (field) {
                              target.parent.setPropValue(
                                'title',
                                field.uiSchema.title
                              );
                              target.parent.setPropValue(
                                'fieldComponent',
                                getFieldComponent(field)
                              );
                              // target.node.children.importSchema([createFormItemChildren(field)])
                              // 插入schema后 有概率不生效，所以这里手动rerender
                              // setTimeout(() => {
                              //   target.document.project.simulatorHost.rerender();
                              // });
                            }
                            return target
                              .getProps()
                              .setPropValue('name', value);
                          },
                        },
                        isRequired: true,
                      },
                      {
                        name: 'hidden',
                        title: {
                          label: {
                            type: 'i18n',
                            'en-US': 'Hidden',
                            'zh-CN': '是否隐藏',
                          },
                          tip: {
                            type: 'i18n',
                            'en-US':
                              'hidden | Whether to hide the current column',
                            'zh-CN': 'hidden | 是否隐藏当前列',
                          },
                        },
                        propType: 'bool',
                        setter: 'BoolSetter',
                      },
                    ],
                  },
                },
                initialValue: { title: '标题', width: 250, dataIndex: '' },
              },
            },
          },
        },
        {
          title: {
            type: 'i18n',
            'en-US': 'Filter by',
            'zh-CN': '筛选',
          },
          name: 'filterBy',
          setter: {
            componentName: 'JsonSetter',
          },
        },
        {
          title: {
            type: 'i18n',
            'en-US': 'Sort by',
            'zh-CN': '排序',
          },
          name: 'sortBy',
          setter: {
            componentName: 'StringSetter',
          },
        },
        // {
        //   title: '字段',
        //   name: '_fields',
        //   display: 'entry',
        //   type: 'group',
        //   items: [
        //     {
        //       title: {
        //         type: 'i18n',
        //         'en-US': 'Fields',
        //         'zh-CN': '字段',
        //       },
        //       name: '_fields',
        //       display: 'block',
        //       setter: {
        //         componentName: 'PisellFieldSetter',
        //         props: (target: any) => {
        //           const columns = target.node
        //             .getProps()
        //             .getPropValue('columns');
        //           const allFields = getVariable(target, 'currentFields');
        //           const options = columns2Options(columns, allFields);
        //           return {
        //             options,
        //           };
        //         },
        //       },
        //       extraProps: {
        //         setValue(target: any, value: any) {
        //           const { operate } = value;
        //           const { mode, field } = operate;
        //           const fieldDetail = getVariable(target, 'currentFields').find(
        //             (f: any) => f.name === field
        //           );
        //           const columns =
        //             target.node.getProps().getPropValue('columns') || [];

        //           // 如果是隐藏操作
        //           if (mode === 'hidden') {
        //             // 过滤掉要隐藏的列
        //             const filteredColumns = columns.filter((col: any) => {
        //               return col.dataIndex !== field;
        //             });
        //             target.node.setPropValue('columns', filteredColumns);
        //           } else if (mode === 'show') {
        //             const newColumn = fields2Columns([fieldDetail]);
        //             const newColumns = [...columns, ...newColumn];

        //             target.node.setPropValue('columns', newColumns);
        //           }
        //           return {};
        //         },
        //       },
        //     },
        //   ],
        // },

        {
          type: 'group',
          title: '额外参数',
          display: 'entry',
          items: [
            {
              name: 'extraParams.list',
              title: {
                type: 'i18n',
                'en-US': 'List Params',
                'zh-CN': '列表参数',
              },
              setter: 'JsonSetter',
            },
            {
              name: 'extraParams.get',
              title: {
                type: 'i18n',
                'en-US': 'Get Params',
                'zh-CN': '获取参数',
              },
              setter: 'JsonSetter',
            },
            {
              name: 'extraParams.update',
              title: {
                type: 'i18n',
                'en-US': 'Update Params',
                'zh-CN': '更新参数',
              },
              setter: 'JsonSetter',
            },
            // {
            //   name: 'extraParams.create',
            //   title: {
            //     type: 'i18n',
            //     'en-US': 'Create Params',
            //     'zh-CN': '创建参数',
            //   },
            //   setter: 'StringSetter'
            // },
            // {
            //   name: 'extraParams.destroy',
            //   title: {
            //     type: 'i18n',
            //     'en-US': 'Destroy Params',
            //     'zh-CN': '删除参数',
            //   },
            //   setter: 'StringSetter'
            // }
          ],
        },
      ],
    },

    getFormItemGeneralInfoGroup([
      {
        name: 'title',
        title: {
          label: {
            type: 'i18n',
            'en-US': 'Title',
            'zh-CN': '标题',
          },
          tip: {
            type: 'i18n',
            'en-US': 'title | Title',
            'zh-CN': 'title | 标题',
          },
        },
        setter: [
          {
            componentName: 'PisellI18nSetter',
          },
          {
            componentName: 'SlotSetter',
            title: '表格标题插槽',
            initialValue: {
              type: 'JSSlot',
              params: ['currentPageData'],
              value: [],
            },
          },
        ],
      },
      {
        name: 'subTitle',
        title: {
          label: {
            type: 'i18n',
            'en-US': 'Subtitle',
            'zh-CN': '副标题',
          },
          tip: {
            type: 'i18n',
            'en-US': 'subTitle | Subtitle',
            'zh-CN': 'subTitle | 副标题',
          },
        },
        setter: [
          {
            componentName: 'PisellI18nSetter',
          },
          {
            componentName: 'SlotSetter',
            title: '表格副标题插槽',
            initialValue: {
              type: 'JSSlot',
              params: ['currentPageData'],
              value: [],
            },
          },
        ],
      },
      {
        name: 'showTitle',
        title: {
          label: {
            type: 'i18n',
            'en-US': 'Show Title',
            'zh-CN': '显示标题',
          },
          tip: {
            type: 'i18n',
            'en-US': 'showTitle | Whether to display the title',
            'zh-CN': 'showTitle | 是否显示标题',
          },
        },
        setter: 'BoolSetter',
        defaultValue: true,
      },
      {
        name: 'showSubTitle',
        title: {
          label: {
            type: 'i18n',
            'en-US': 'Show Subtitle',
            'zh-CN': '显示副标题',
          },
          tip: {
            type: 'i18n',
            'en-US': 'showSubTitle | Whether to display the subtitle',
            'zh-CN': 'showSubTitle | 是否显示副标题',
          },
        },
        setter: 'BoolSetter',
        defaultValue: true,
      },
      {
        name: 'columnSetting.show',
        title: {
          label: {
            type: 'i18n',
            'en-US': 'Show Hidden Fields',
            'zh-CN': '显示隐藏字段',
          },
        },
        propType: 'bool',
        setter: 'BoolSetter',
        extraProps: {
          setValue(target: any, value: any) {
            if (value) {
              target.node.setPropValue(
                'columnSetting.storageMode',
                'localStorage'
              );
            }
            return target.node.setPropValue('columnSetting.show', value);
          },
        },
        defaultValue: false,
      },
      // {
      //   name: 'showSizeChanger',
      //   title: {
      //     label: '行高调整',
      //     tip: 'showSizeChanger | 是否显示表格内行高调整按钮',
      //   },
      //   propType: 'bool',
      //   setter: 'BoolSetter',
      //   defaultValue: false,
      // },
      {
        title: '标题按钮',
        display: 'entry',
        type: 'group',
        name: '_buttons',
        items: [
          {
            name: 'titleButtons.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Title Buttons',
                'zh-CN': '开启标题按钮组',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'titleButtons.show | Whether to display the title button group',
                'zh-CN': 'titleButtons.show | 是否显示标题按钮组',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'titleButtons.items',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Title Buttons',
                'zh-CN': '标题按钮组',
              },
              tip: {
                type: 'i18n',
                'en-US': 'titleButtons.items | Title buttons on the right',
                'zh-CN': 'titleButtons.items | 标题右侧按钮项',
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("titleButtons.show")',
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'label',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Button Text',
                              'zh-CN': '按钮文案',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'buttonText | Button text',
                              'zh-CN': 'buttonText | 按钮文案',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'openMode',
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Open Mode',
                              'zh-CN': '打开方式',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'openMode | Open mode',
                              'zh-CN': 'openMode | 打开方式',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['modal', 'drawer'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '对话框',
                                  value: 'modal',
                                },
                                {
                                  title: '抽屉',
                                  value: 'drawer',
                                },
                              ],
                            },
                          },
                          defaultValue: 'drawer',
                        },
                        {
                          name: 'openContentSize',
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Dialog Size',
                              'zh-CN': '弹窗尺寸',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'dialogSize | Dialog size',
                              'zh-CN': 'dialogSize | 弹窗尺寸',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['small', 'middle', 'large'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '较窄',
                                  value: 'small',
                                },
                                {
                                  title: '中等',
                                  value: 'middle',
                                },
                                {
                                  title: '较宽',
                                  value: 'large',
                                },
                              ],
                            },
                          },
                          defaultValue: 'middle',
                        },
                        {
                          name: 'openTitle',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Dialog Title',
                              'zh-CN': '弹窗标题',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'dialogTitle | Dialog title',
                              'zh-CN': 'dialogTitle | 弹窗标题',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                        },
                        {
                          name: 'actionType',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Action Type',
                              'zh-CN': '操作类型',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'actionType | Action type',
                              'zh-CN': 'actionType | 操作类型',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['add', 'custom'],
                          },
                          extraProps: {
                            setValue(target: any, value: any) {
                              const key = target.parent.getPropValue('key');
                              if (['add', 'custom'].includes(value)) {
                                let content: any = getJsSlot();
                                if (value !== 'custom') {
                                  content = getFormContent(target, value);
                                }
                                target.node.setPropValue('operationContent', {
                                  ...(target.node.getPropValue(
                                    'operationContent'
                                  ) || {}),
                                  [key]: content,
                                });
                              }

                              return target.parent.setPropValue(
                                'actionType',
                                value
                              );
                            },
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '添加',
                                  value: 'add',
                                },
                                {
                                  title: '自定义',
                                  value: 'custom',
                                },
                              ],
                            },
                          },
                        },
                        {
                          name: 'beforeOpen',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Before Open',
                              'zh-CN': '打开前校验',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US':
                                'beforeOpen | Function to validate before opening',
                              'zh-CN':
                                'beforeOpen | 打开前的校验函数，返回 true 才会打开',
                            },
                          },
                          propType: 'func',
                          setter: {
                            componentName: 'FunctionSetter',
                            props: {
                              template:
                                'beforeOpen(values,${extParams}){\n// 校验数据\nreturn true}',
                            },
                          },
                        },
                        {
                          name: 'afterClose',
                          title: { label: '关闭后' },
                          setter: {
                            componentName: 'FunctionSetter',
                          },
                        },
                      ],
                    },
                  },
                  initialValue: () => {
                    return {
                      key: uuid(),
                      title: '操作',
                    };
                  },
                },
              },
            },
          },
          {
            name: 'titleButtons.maxCount',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Max Count',
                'zh-CN': '最大展示数量',
              },
              tip: {
                type: 'i18n',
                'en-US': 'maxCount | Maximum display count',
                'zh-CN': 'maxCount | 最大展示数量',
              },
            },
            propType: 'number',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("titleButtons.show")',
            },
            setter: 'NumberSetter',
          },
        ],
      },
      {
        title: '表格按钮',
        display: 'entry',
        type: 'group',
        name: '_tableButtons',
        items: [
          {
            name: 'tableButtons.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Table Buttons',
                'zh-CN': '开启表格按钮组',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'tableButtons.show | Whether to display the table button group',
                'zh-CN': 'tableButtons.show | 是否显示表格按钮组',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'tableButtons.items',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Table Buttons',
                'zh-CN': '表格按钮组',
              },
              tip: {
                type: 'i18n',
                'en-US': 'tableButtons.items | Table buttons on the right',
                'zh-CN': 'tableButtons.items | 表格右侧按钮项',
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("tableButtons.show")',
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'label',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Button Text',
                              'zh-CN': '按钮文案',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'buttonText | Button text',
                              'zh-CN': 'buttonText | 按钮文案',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'openMode',
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Open Mode',
                              'zh-CN': '打开方式',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'openMode | Open mode',
                              'zh-CN': 'openMode | 打开方式',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['modal', 'drawer'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '对话框',
                                  value: 'modal',
                                },
                                {
                                  title: '抽屉',
                                  value: 'drawer',
                                },
                              ],
                            },
                          },
                          defaultValue: 'drawer',
                        },
                        {
                          name: 'openContentSize',
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Dialog Size',
                              'zh-CN': '弹窗尺寸',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'dialogSize | Dialog size',
                              'zh-CN': 'dialogSize | 弹窗尺寸',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['small', 'middle', 'large'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '较窄',
                                  value: 'small',
                                },
                                {
                                  title: '中等',
                                  value: 'middle',
                                },
                                {
                                  title: '较宽',
                                  value: 'large',
                                },
                              ],
                            },
                          },
                          defaultValue: 'middle',
                        },
                        {
                          name: 'openTitle',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Dialog Title',
                              'zh-CN': '弹窗标题',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'dialogTitle | Dialog title',
                              'zh-CN': 'dialogTitle | 弹窗标题',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                          condition: (target: any) => {
                            const actionType =
                              target.parent.getPropValue('actionType');
                            return actionType === 'add';
                          },
                        },
                        {
                          name: 'actionType',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Action Type',
                              'zh-CN': '操作类型',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'actionType | Action type',
                              'zh-CN': 'actionType | 操作类型',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['add', 'custom'],
                          },
                          extraProps: {
                            setValue(target: any, value: any) {
                              const key = target.parent.getPropValue('key');
                              if (['add', 'custom'].includes(value)) {
                                let content: any = getJsSlot();
                                if (value !== 'custom') {
                                  content = getFormContent(target, value);
                                }
                                target.node.setPropValue('operationContent', {
                                  ...(target.node.getPropValue(
                                    'operationContent'
                                  ) || {}),
                                  [key]: content,
                                });
                              }

                              return target.parent.setPropValue(
                                'actionType',
                                value
                              );
                            },
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '添加',
                                  value: 'add',
                                },
                                {
                                  title: '自定义',
                                  value: 'custom',
                                },
                              ],
                            },
                          },
                        },
                        {
                          name: 'buttonProps',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Button props',
                              'zh-CN': '按钮props',
                            },
                          },
                          propType: 'object',
                          setter: 'JsonSetter',
                        },
                      ],
                    },
                  },
                  initialValue: () => {
                    return {
                      key: uuid(),
                      title: '操作',
                    };
                  },
                },
              },
            },
          },
          {
            name: 'tableButtons.maxCount',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Max Count',
                'zh-CN': '最大展示数量',
              },
              tip: {
                type: 'i18n',
                'en-US': 'maxCount | Maximum display count',
                'zh-CN': 'maxCount | 最大展示数量',
              },
            },
            propType: 'number',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("tableButtons.show")',
            },
            setter: 'NumberSetter',
          },
        ],
      },
      {
        title: '标签页',
        display: 'entry',
        type: 'group',
        name: '_tabs',
        items: [
          {
            name: 'tabs.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Tabs',
                'zh-CN': '开启标签页',
              },
              tip: {
                type: 'i18n',
                'en-US': 'tabs.show | Whether to display tabs',
                'zh-CN': 'tabs.show | 是否显示标签页',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'tabs.type',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Tabs Type',
                'zh-CN': '标签页类型',
              },
              tip: {
                type: 'i18n',
                'en-US': 'tabs.type | Tabs type',
                'zh-CN': 'tabs.type | 标签页类型',
              },
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              props: {
                options: [
                  {
                    title: '默认',
                    value: 'default',
                  },
                  {
                    title: '按钮',
                    value: 'button',
                  },
                  {
                    title: '按钮组',
                    value: 'buttonGroup',
                  },
                  {
                    title: '下拉菜单',
                    value: 'dropdown',
                  },
                ],
              },
            },
            defaultValue: 'default',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("tabs.show")',
            },
          },
          {
            name: 'tabs.items',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Tabs Items',
                'zh-CN': '标签页配置',
              },
              tip: {
                type: 'i18n',
                'en-US': 'tabs.items | Tabs items',
                'zh-CN': 'tabs.items | 标签页配置项',
              },
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'name',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Tab Name',
                              'zh-CN': '标签名称',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'tabName | Tab name',
                              'zh-CN': 'tabName | 标签页显示的名称',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'filterBy',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Filter',
                              'zh-CN': '过滤',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'filterBy | Filter',
                              'zh-CN': 'filterBy | 标签页的过滤条件',
                            },
                          },
                          propType: 'object',
                          setter: 'JsonSetter',
                        },
                        {
                          name: 'sortBy',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Sort',
                              'zh-CN': '排序',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'sortBy | Sort',
                              'zh-CN': 'sortBy | 标签页的排序条件',
                            },
                          },
                          propType: 'string',
                          setter: 'StringSetter',
                        },
                        {
                          name: 'disabled',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Disabled',
                              'zh-CN': '是否禁用',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'disabled | Whether the tab is disabled',
                              'zh-CN': 'disabled | 是否禁用标签页',
                            },
                          },
                          propType: 'bool',
                          defaultValue: false,
                          setter: 'BoolSetter',
                        },
                      ],
                    },
                  },
                  initialValue: {
                    name: '标签页',
                  },
                },
              },
            },
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("tabs.show")',
            },
          },
        ],
      },
      {
        title: '搜索条',
        display: 'entry',
        type: 'group',
        name: '_search',
        items: [
          {
            name: 'search.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Search',
                'zh-CN': '开启搜索',
              },
              tip: {
                type: 'i18n',
                'en-US': 'search.show | Whether to display search bar',
                'zh-CN': 'search.show | 是否显示搜索条',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'search.placeholder',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Search Placeholder',
                'zh-CN': '搜索占位符',
              },
              tip: {
                type: 'i18n',
                'en-US': 'search.placeholder | Search placeholder',
                'zh-CN': 'search.placeholder | 搜索框的占位提示文字',
              },
            },
            propType: 'string',
            setter: 'PisellI18nSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("search.show")',
            },
          },
          {
            name: 'search.key',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Search Key',
                'zh-CN': '搜索字段key',
              },
              tip: {
                type: 'i18n',
                'en-US': 'search.key | Search field key, default is _keywords',
                'zh-CN': 'search.key | 搜索字段的key,默认为_keywords',
              },
            },
            propType: 'string',
            setter: 'StringSetter',
            defaultValue: '_keywords',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("search.show") && ["pisell2-api","mypisell-api"].includes(target.getProps().getPropValue("dataSource").headerDataSource)',
            },
          },
        ],
      },
      {
        title: '筛选',
        display: 'entry',
        type: 'group',
        name: '_filter',
        items: [
          {
            name: 'filter.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Filter',
                'zh-CN': '开启筛选',
              },
              tip: {
                type: 'i18n',
                'en-US': 'filter.show | Whether to display filter',
                'zh-CN': 'filter.show | 是否显示筛选',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'filter.mode',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Filter Type',
                'zh-CN': '筛选类型',
              },
              tip: {
                type: 'i18n',
                'en-US': 'filter.mode | Filter type',
                'zh-CN': 'filter.mode | 筛选类型',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['simple', 'complex'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '简单筛选',
                    value: 'simple',
                  },
                  {
                    title: '复合筛选',
                    value: 'complex',
                  },
                ],
              },
            },
            defaultValue: 'simple',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
          },
          {
            name: 'filter.quickFilterMaxLength',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Quick Filter Max Length',
                'zh-CN': '快捷筛选最大长度',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'filter.quickFilterMaxLength | Quick filter max length',
                'zh-CN': 'filter.quickFilterMaxLength | 快捷筛选最大长度',
              },
            },
            propType: 'number',
            setter: 'NumberSetter',
            defaultValue: 10,
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
          },
          {
            name: 'filter.items',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Quick Filter Items',
                'zh-CN': '快捷筛选项',
              },
              tip: {
                type: 'i18n',
                'en-US': 'filter.items | Quick filter items',
                'zh-CN': 'filter.items | 快捷筛选项配置',
              },
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'isCustom',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Custom Component',
                              'zh-CN': '自定义组件',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Whether to use custom components',
                              'zh-CN': '是否使用自定义组件',
                            },
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                        },
                        {
                          name: 'name',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Filter Field',
                              'zh-CN': '筛选字段',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Filter field',
                              'zh-CN': '筛选字段',
                            },
                          },
                          propType: 'string',
                          setter: {
                            componentName: 'SelectSetter',
                            props: (target: any) => {
                              const currentFields = getVariable(
                                target,
                                'currentFields'
                              );

                              const useFields = target
                                .getProps()
                                .getPropValue('filter.items')
                                .map((item: any) => item?.name);

                              const options = fields2TableFilterOptions(
                                currentFields,
                                useFields
                              );

                              return {
                                options,
                              };
                            },
                          },
                          extraProps: {
                            setValue(target: any, value: any) {
                              target.parent.setPropValue('value', value);
                              const columns =
                                target.parent.parent.parent.getPropValue(
                                  'columns'
                                );
                              const column = columns?.find(
                                (item: any) => item.key === value
                              );
                              if (column) {
                                target.parent.setPropValue(
                                  'label',
                                  column.title
                                );
                              }
                              if (value === 'keywords') {
                                target.parent.setPropValue('label', 'Search');
                              }
                              return target.parent.setPropValue('name', value);
                            },
                          },
                          condition: (target: any) => {
                            return !target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'label',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Filter Name',
                              'zh-CN': '筛选名称',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Filter name',
                              'zh-CN': '筛选项展示文案',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'value',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Field',
                              'zh-CN': '字段',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Field',
                              'zh-CN': '筛选字段',
                            },
                          },
                          propType: 'string',
                          setter: [
                            {
                              componentName: 'StringSetter',
                            },
                          ],
                          condition: (target: any) => {
                            return !!target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'type',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Field Type',
                              'zh-CN': '字段类型',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Field type',
                              'zh-CN': '筛选字段类型',
                            },
                          },
                          propType: 'string',
                          setter: {
                            componentName: 'SelectSetter',
                            mode: 'single',
                            props: {
                              options: filterTypes,
                            },
                          },
                          condition: (target: any) => {
                            return !!target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'isHidden',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Hidden',
                              'zh-CN': '是否隐藏',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Hidden',
                              'zh-CN': '开启时，当前项展示，关闭时，当前项隐藏',
                            },
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                          isRequired: true,
                        },
                        {
                          name: 'other',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Other Properties',
                              'zh-CN': '其他拓展属性',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Other extended properties',
                              'zh-CN': '其他拓展属性',
                            },
                          },
                          propType: 'object',
                          setter: 'JsonSetter',
                        },
                      ],
                    },
                  },
                },
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
          },
        ],
      },
      {
        title: '排序',
        display: 'entry',
        type: 'group',
        name: '_sort',
        items: [
          {
            name: 'sort.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Sort',
                'zh-CN': '开启排序',
              },
              tip: {
                type: 'i18n',
                'en-US': 'sort.show | Whether to display sort',
                'zh-CN': 'sort.show | 是否显示排序',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'sort.type',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Sort Type',
                'zh-CN': '排序类型',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'Sort type | Simple sort(simple)、Complex sort(complex)',
                'zh-CN': '排序类型 | 简单排序(simple)、复合排序(complex)',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['simple', 'complex'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '简单排序',
                    value: 'simple',
                  },
                  {
                    title: '复合排序',
                    value: 'complex',
                  },
                ],
              },
            },
            defaultValue: 'simple',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("sort.show")',
            },
          },
          {
            name: 'sort.list',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Sort Items',
                'zh-CN': '排序项',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Sort items',
                'zh-CN': '排序项配置',
              },
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        // {
                        //   name: 'isCustom',
                        //   title: {
                        //     label: '开启定制字段',
                        //     tip: '开启定制字段，可自定义排序名和排序的key，关闭时可选择column中的title和dataIndex',
                        //   },
                        //   setter: 'BoolSetter',
                        //   defaultValue: false,
                        // },
                        {
                          name: 'name',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Field',
                              'zh-CN': '字段',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Field',
                              'zh-CN': '排序字段',
                            },
                          },
                          setter: [
                            {
                              componentName: 'SelectSetter',
                              mode: 'single',
                              props: (target: any) => {
                                return {
                                  options:
                                    target.parent.parent.parent
                                      .getPropValue('columns')
                                      ?.map?.((item: any) => ({
                                        title:
                                          typeof item.title === 'string'
                                            ? item.title
                                            : item.key,
                                        value: item.dataIndex,
                                      })) || [],
                                };
                              },
                            },
                            'StringSetter',
                          ],
                          extraProps: {
                            setValue(target: any, value: any) {
                              const columns =
                                target.parent.parent.parent.getPropValue(
                                  'columns'
                                );
                              const column = columns?.find(
                                (item: any) => item.key === value
                              );

                              if (column) {
                                const currentFields = getVariable(
                                  target,
                                  'currentFields'
                                );
                                const type = currentFields.find(
                                  (item: any) => item.name === value
                                )?.type;
                                target.parent.setPropValue(
                                  'label',
                                  column.title
                                );
                                type &&
                                  target.parent.setPropValue('type', type);
                              }
                              return target.parent.setPropValue('name', value);
                            },
                          },
                          isRequired: true,
                        },
                        {
                          name: 'label',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Sort Name',
                              'zh-CN': '排序名称',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Sort name',
                              'zh-CN': '排序项展示文案',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'type',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Field Type',
                              'zh-CN': '字段类型',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Field type',
                              'zh-CN': '所排序的字段类型',
                            },
                          },
                          propType: 'string',
                          // condition(target: any) {
                          //   return target.parent.getPropValue('isCustom');
                          // },
                          setter: {
                            componentName: 'SelectSetter',
                            mode: 'single',
                            defaultValue: 'single',
                            props: {
                              options: [
                                {
                                  title: '日期排序',
                                  value: 'date',
                                },
                                {
                                  title: '数字排序',
                                  value: 'number',
                                },
                                {
                                  title: 'a-z排序',
                                  value: 'string',
                                },
                              ],
                            },
                          },
                        },
                        {
                          name: 'isHidden',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Hidden',
                              'zh-CN': '是否隐藏',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Hidden',
                              'zh-CN': '开启时，当前项展示，关闭时，当前项隐藏',
                            },
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                      ],
                    },
                  },
                  initialValue: {
                    isHidden: false,
                    localFilter: false,
                    type: 'string',
                  },
                },
              },
            },
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("sort.show")',
            },
          },
        ],
      },
      // {
      //   title: '分组',
      //   display: 'entry',
      //   type: 'group',
      //   name: '_group',
      //   items: [
      //     {
      //       name: 'group.show',
      //       title: { label: '开启分组', tip: 'group.show | 是否显示分组' },
      //       propType: 'bool',
      //       setter: 'BoolSetter',
      //       defaultValue: false,
      //     },
      //     {
      //       name: 'group.type',
      //       title: {
      //         label: '分组类型',
      //         tip: '分组类型 | 简单分组(simple)、复合分组(complex)',
      //       },
      //       propType: {
      //         type: 'oneOf',
      //         value: ['simple', 'complex'],
      //       },
      //       setter: {
      //         componentName: 'RadioGroupSetter',
      //         props: {
      //           options: [
      //             {
      //               title: '简单分组',
      //               value: 'simple',
      //             },
      //             {
      //               title: '复合分组',
      //               value: 'complex',
      //             },
      //           ],
      //         },
      //       },
      //       defaultValue: 'simple',
      //       condition: {
      //         type: 'JSFunction',
      //         value: 'target => !!target.getProps().getPropValue("group.show")',
      //       },
      //     },
      //     {
      //       name: 'group.items',
      //       title: { label: '分组项', tip: '分组项配置' },
      //       setter: {
      //         componentName: 'ArraySetter',
      //         props: {
      //           itemSetter: {
      //             componentName: 'ObjectSetter',
      //             props: {
      //               config: {
      //                 items: [
      //                   {
      //                     name: 'label',
      //                     title: { label: '分组名称', tip: '分组项展示文案' },
      //                     propType: 'string',
      //                     setter: 'PisellI18nSetter',
      //                     isRequired: true,
      //                   },
      //                   {
      //                     name: 'name',
      //                     title: { label: '字段', tip: '分组字段' },
      //                     setter: [
      //                       {
      //                         componentName: 'SelectSetter',
      //                         mode: 'single',
      //                         props: (target: any) => {
      //                           return {
      //                             options:
      //                               target.parent.parent.parent
      //                                 .getPropValue('columns')
      //                                 ?.map?.((item: any) => ({
      //                                   title:
      //                                     typeof item.title === 'string'
      //                                       ? item.title
      //                                       : item.key,
      //                                   value: item.dataIndex,
      //                                 })) || [],
      //                           };
      //                         },
      //                       },
      //                       'StringSetter',
      //                     ],
      //                     isRequired: true,
      //                   },
      //                   {
      //                     name: 'isHidden',
      //                     title: {
      //                       label: '是否隐藏',
      //                       tip: '开启时，当前项展示，关闭时，当前项隐藏',
      //                     },
      //                     propType: 'bool',
      //                     setter: 'BoolSetter',
      //                     defaultValue: false,
      //                   },
      //                 ],
      //               },
      //             },
      //             initialValue: {
      //               label: '分组',
      //               isHidden: false,
      //             },
      //           },
      //         },
      //       },
      //       condition: {
      //         type: 'JSFunction',
      //         value: 'target => !!target.getProps().getPropValue("group.show")',
      //       },
      //     },
      //   ],
      // },
      {
        title: '多视图',
        display: 'entry',
        type: 'group',
        name: '_view',
        items: [
          {
            name: 'view.multiple',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Multiple View',
                'zh-CN': '开启多视图',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'view.multiple | Whether to display multiple view switching',
                'zh-CN': 'view.multiple | 是否显示多视图切换',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'view.modeList',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'View List',
                'zh-CN': '视图列表',
              },
              tip: {
                type: 'i18n',
                'en-US': 'View list',
                'zh-CN': '多视图配置列表',
              },
            },
            setter: {
              componentName: 'SelectSetter',
              props: {
                mode: 'multiple',
                options: [
                  {
                    title: 'Grid',
                    value: 'grid',
                  },
                  {
                    title: 'Gallery',
                    value: 'gallery',
                  },
                  {
                    title: 'Kanban',
                    value: 'kanban',
                  },
                ],
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("view.multiple")',
            },
          },
        ],
      },
      {
        title: '操作列',
        display: 'entry',
        type: 'group',
        name: '_operation',
        items: [
          {
            name: 'operation.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Show Operation Column',
                'zh-CN': '开启操作列',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'operation.show | Whether to display the operation column',
                'zh-CN': 'operation.show | 是否显示操作列',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'operation.title',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Operation Column Title',
                'zh-CN': '操作列标题',
              },
              tip: {
                type: 'i18n',
                'en-US': 'operation.title | Operation column title',
                'zh-CN': 'operation.title | 操作列标题',
              },
            },
            propType: 'string',
            setter: 'PisellI18nSetter',
            defaultValue: {
              en: 'Operation',
              'zh-CN': '操作',
              'zh-HK': '操作',
              type: 'i18n',
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
          {
            name: 'operation.width',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Column Width',
                'zh-CN': '列宽',
              },
              tip: {
                type: 'i18n',
                'en-US': 'operation.width | Column width',
                'zh-CN': 'operation.width | 操作列宽度',
              },
            },
            propType: 'number',
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
          {
            name: 'operation.align',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Alignment',
                'zh-CN': '对齐方式',
              },
              tip: {
                type: 'i18n',
                'en-US': 'operation.align | Operation column alignment',
                'zh-CN': 'operation.align | 操作列对齐方式',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['left', 'center', 'right'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '左对齐',
                    value: 'left',
                  },
                  {
                    title: '居中对齐',
                    value: 'center',
                  },
                  {
                    title: '右对齐',
                    value: 'right',
                  },
                ],
              },
            },
            defaultValue: 'left',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
          {
            name: 'operation.fixed',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Column Fixed',
                'zh-CN': '列固定',
              },
              tip: {
                type: 'i18n',
                'en-US': 'operation.fixed | Operation column fixed',
                'zh-CN': 'operation.fixed | 操作列固定方式',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['left', 'right', false],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '不固定',
                    value: false,
                  },
                  {
                    title: '固定在左侧',
                    value: 'left',
                  },
                  {
                    title: '固定在右侧',
                    value: 'right',
                  },
                ],
              },
            },
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
          {
            name: 'operation.type',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Button Type',
                'zh-CN': '按钮类型',
              },
              tip: {
                type: 'i18n',
                'en-US': 'operation.type | Operation column button type',
                'zh-CN': 'operation.type | 操作列按钮类型',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['link', 'button'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '链接',
                    value: 'link',
                  },
                  {
                    title: '按钮',
                    value: 'button',
                  },
                ],
              },
            },
            defaultValue: 'link',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
          {
            name: 'operation.items',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Operation Items',
                'zh-CN': '操作项',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Operation items configuration',
                'zh-CN': '操作项配置',
              },
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'label',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Operation Name',
                              'zh-CN': '操作名称',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Operation name',
                              'zh-CN': '操作名称',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        {
                          name: 'openMode',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Open Mode',
                              'zh-CN': '打开方式',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US':
                                'Open mode | Dialog(modal)、Drawer(drawer) | Custom(custom)',
                              'zh-CN':
                                '打开方式 | 对话框(modal)、抽屉(drawer) | 自定义(custom)',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['modal', 'drawer', 'custom'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '对话框',
                                  value: 'modal',
                                },
                                {
                                  title: '抽屉',
                                  value: 'drawer',
                                },
                                {
                                  title: '自定义',
                                  value: 'custom',
                                },
                              ],
                            },
                          },
                          defaultValue: 'drawer',
                        },
                        {
                          name: 'onClick',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Click Event',
                              'zh-CN': '点击事件',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Click event handler',
                              'zh-CN': '点击事件处理函数',
                            },
                          },
                          propType: 'func',
                          setter: [
                            {
                              componentName: 'FunctionSetter',
                              props: {
                                template:
                                  'onClick(record,${extParams}){\n// 点击按钮时的回调\nconsole.log("onClick", record);\n}',
                              },
                            },
                            'VariableSetter',
                          ],
                        },
                        {
                          name: 'openContentSize',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Open Content Size',
                              'zh-CN': '弹窗尺寸',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US':
                                'Open content size | Narrow(small)、Medium(middle)、Wide(large)',
                              'zh-CN':
                                '弹窗尺寸 | 较窄(small)、中等(middle)、较宽(large)',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['small', 'middle', 'large'],
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '较窄',
                                  value: 'small',
                                },
                                {
                                  title: '中等',
                                  value: 'middle',
                                },
                                {
                                  title: '较宽',
                                  value: 'large',
                                },
                              ],
                            },
                          },
                          defaultValue: 'middle',
                        },
                        {
                          name: 'openTitle',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Open Title',
                              'zh-CN': '弹窗标题',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Open title',
                              'zh-CN': '弹窗标题',
                            },
                          },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          isRequired: true,
                        },
                        // {
                        //   name: 'key',
                        //   title: { label: '操作标识', tip: '操作标识' },
                        //   propType: 'string',
                        //   setter: 'StringSetter',
                        //   condition: false,
                        // },
                        {
                          name: 'actionType',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Action Type',
                              'zh-CN': '操作类型',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Action type',
                              'zh-CN': '操作类型',
                            },
                          },
                          propType: {
                            type: 'oneOf',
                            value: ['delete', 'view', 'edit', 'custom'],
                          },
                          extraProps: {
                            setValue(target: any, value: any) {
                              const key = target.parent.getPropValue('key');
                              if (['view', 'edit', 'custom'].includes(value)) {
                                let content: any = getJsSlot();
                                if (value !== 'custom') {
                                  content = getFormContent(target, value);
                                }
                                target.node.setPropValue('operationContent', {
                                  ...(target.node.getPropValue(
                                    'operationContent'
                                  ) || {}),
                                  [key]: content,
                                });
                              }
                              return target.node.setPropValue(
                                'actionType',
                                value
                              );
                            },
                          },
                          setter: {
                            componentName: 'RadioGroupSetter',
                            props: {
                              options: [
                                {
                                  title: '详情',
                                  value: 'view',
                                },
                                {
                                  title: '编辑',
                                  value: 'edit',
                                },
                                {
                                  title: '删除',
                                  value: 'delete',
                                },
                                {
                                  title: '自定义',
                                  value: 'custom',
                                },
                              ],
                            },
                          },
                        },
                        {
                          name: 'softDelete',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Soft Delete',
                              'zh-CN': '软删除',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Whether to use soft delete',
                              'zh-CN': '是否使用软删除',
                            },
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                          condition: {
                            type: 'JSFunction',
                            value:
                              "target => target.parent.getPropValue('actionType') === 'delete'",
                          },
                        },
                        {
                          name: 'customDeleteAction',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Custom Delete',
                              'zh-CN': '自定义删除',
                            },
                          },
                          propType: 'func',
                          setter: [
                            {
                              componentName: 'FunctionSetter',
                              props: {
                                template:
                                  'customDeleteAction(record,${extParams}){\n// 自定义删除的回调\nconsole.log("customDeleteAction", record);\n}',
                              },
                            },
                            'VariableSetter',
                          ],
                          condition: {
                            type: 'JSFunction',
                            value:
                              "target => target.parent.getPropValue('actionType') === 'delete'",
                          },
                        },
                        {
                          name: 'show',
                          title: {
                            label: {
                              type: 'i18n',
                              'en-US': 'Show',
                              'zh-CN': '是否展示',
                            },
                            tip: {
                              type: 'i18n',
                              'en-US': 'Whether to show this operation button',
                              'zh-CN': '是否展示该操作按钮',
                            },
                          },
                          propType: {
                            type: 'oneOfType',
                            value: ['JSFunction', 'bool'],
                          },
                          setter: [
                            {
                              componentName: 'FunctionSetter',
                              props: {
                                template:
                                  'show(record,${extParams}){\n// 校验数据\nreturn true}',
                              },
                            },
                            {
                              componentName: 'BoolSetter',
                            },
                          ],
                        },
                        {
                          name: 'afterClose',
                          title: { label: '关闭后' },
                          setter: {
                            componentName: 'FunctionSetter',
                          },
                        },
                      ],
                    },
                  },
                  initialValue: () => {
                    return {
                      key: uuid(),
                      label: '操作',
                      openMode: 'drawer',
                      openContentSize: 'middle',
                    };
                  },
                },
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("operation.show")',
            },
          },
        ],
      },
      {
        title: '点击进入详情',
        display: 'entry',
        type: 'group',
        name: '_clickToDetail',
        items: [
          {
            name: 'clickToDetail.show',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Enable click to enter details',
                'zh-CN': '开启点击进入详情',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Click on the table row to enter the details page',
                'zh-CN': '点击表格行时是否进入详情页',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'clickToDetail.useCustomAction',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Use custom action',
                'zh-CN': '使用自定义操作',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Whether to use custom action configuration',
                'zh-CN': '是否使用自定义操作配置',
              },
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            extraProps: {
              setValue(target: any, value: any) {
                if (value) {
                  target.node.setPropValue('clickToDetail.key', 'onRowClick');
                } else {
                  target.node.setPropValue('clickToDetail.key', '');
                }
                return target.node.setPropValue(
                  'clickToDetail.useCustomAction',
                  value
                );
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show")',
            },
          },
          {
            name: 'clickToDetail.key',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Action Type',
                'zh-CN': '操作类型',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Select an existing action type',
                'zh-CN': '选择已有操作类型',
              },
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              props: (target: any) => {
                const operation = target.getProps().getPropValue('operation');
                const items = operation?.items || [];
                return {
                  options: items.map((item: any) => ({
                    title:
                      typeof item.label === 'string'
                        ? item.label
                        : item.label['zh-CN'],
                    value: item.key || item.actionType,
                  })),
                };
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show") && !target.getProps().getPropValue("clickToDetail.useCustomAction")',
            },
          },
          {
            name: 'clickToDetail.openMode',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Open Mode',
                'zh-CN': '打开方式',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Open mode | Dialog(modal)、Drawer(drawer)',
                'zh-CN': '打开方式 | 对话框(modal)、抽屉(drawer)',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['modal', 'drawer'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '对话框',
                    value: 'modal',
                  },
                  {
                    title: '抽屉',
                    value: 'drawer',
                  },
                ],
              },
            },
            defaultValue: 'drawer',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show") && !!target.getProps().getPropValue("clickToDetail.useCustomAction")',
            },
          },
          {
            name: 'clickToDetail.openContentSize',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Open Content Size',
                'zh-CN': '弹窗尺寸',
              },
              tip: {
                type: 'i18n',
                'en-US':
                  'Open content size | Narrow(small)、Medium(middle)、Wide(large)',
                'zh-CN': '弹窗尺寸 | 较窄(small)、中等(middle)、较宽(large)',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['small', 'middle', 'large'],
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '较窄',
                    value: 'small',
                  },
                  {
                    title: '中等',
                    value: 'middle',
                  },
                  {
                    title: '较宽',
                    value: 'large',
                  },
                ],
              },
            },
            defaultValue: 'middle',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show") && !!target.getProps().getPropValue("clickToDetail.useCustomAction")',
            },
          },
          {
            name: 'clickToDetail.openTitle',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Open Title',
                'zh-CN': '弹窗标题',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Open title',
                'zh-CN': '弹窗标题',
              },
            },
            propType: 'string',
            setter: 'PisellI18nSetter',
            isRequired: true,
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show") && !!target.getProps().getPropValue("clickToDetail.useCustomAction")',
            },
          },
          {
            name: 'clickToDetail.actionType',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Action Type',
                'zh-CN': '操作类型',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Action type',
                'zh-CN': '操作类型',
              },
            },
            propType: {
              type: 'oneOf',
              value: ['view', 'edit', 'custom'],
            },
            extraProps: {
              setValue(target: any, value: any) {
                const key = target.parent.getPropValue('clickToDetail.key');
                if (['view', 'edit', 'custom'].includes(value)) {
                  let content: any = getJsSlot();
                  if (value !== 'custom') {
                    content = getFormContent(target, value);
                  }
                  target.node.setPropValue('operationContent', {
                    ...(target.node.getPropValue('operationContent') || {}),
                    [key]: content,
                  });
                }
                return target.node.setPropValue('actionType', value);
              },
            },
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("clickToDetail.show") && !!target.getProps().getPropValue("clickToDetail.useCustomAction")',
            },
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: '详情',
                    value: 'view',
                  },
                  {
                    title: '编辑',
                    value: 'edit',
                  },
                  {
                    title: '自定义',
                    value: 'custom',
                  },
                ],
              },
            },
          },
        ],
      },
    ]),
    {
      type: 'group',
      title: {
        type: 'i18n',
        'en-US': 'Appearance',
        'zh-CN': '外观',
      },
      display: 'accordion',
      items: [
        {
          title: '风格和样式',
          display: 'entry',
          type: 'group',
          name: '_style',
          items: [
            {
              name: 'showHeader',
              title: {
                label: {
                  type: 'i18n',
                  'en-US': 'Show Header',
                  'zh-CN': '显示表头',
                },
                tip: {
                  type: 'i18n',
                  'en-US': 'Whether to display the table header',
                  'zh-CN': '是否显示表头',
                },
              },
              propType: 'bool',
              defaultValue: true,
              setter: 'BoolSetter',
            },
            {
              name: 'scroll.y',
              title: {
                label: {
                  type: 'i18n',
                  'en-US': 'Max Height',
                  'zh-CN': '最大高度',
                },
                tip: {
                  type: 'i18n',
                  'en-US': 'Maximum content area height',
                  'zh-CN': '最大内容区域高度',
                },
              },
              propType: 'string',
              setter: [
                {
                  componentName: 'StringSetter',
                },
                {
                  componentName: 'NumberSetter',
                },
              ],
            },
          ],
        },
      ],
    },

    {
      type: 'group',
      title: {
        type: 'i18n',
        'en-US': 'Other',
        'zh-CN': '其他',
      },
      display: 'accordion',
      items: [
        {
          title: "本地记忆",
          display: "block",
          type: "group",
          items: [
            {
              name: "localSettings.enable",
              title: {
                label: {
                  type: 'i18n',
                  'en-US': 'Enable settings memory',
                  'zh-CN': '启用设置记忆',
                  'zh-HK': '啟用設置記憶',
                },
                tip: {
                  type: 'i18n',
                  'en-US': 'Automatically save and restore table settings',
                  'zh-CN': '自动保存和恢复表格设置',
                  'zh-HK': '自動保存和恢復表格設置',
                },
              },
              propType: "bool",
              setter: "BoolSetter",
              defaultValue: true,
            },
            {
              name: "localSettings.scope",
              title: {
                label: {
                  type: 'i18n',
                  'en-US': 'Memory scope',
                  'zh-CN': '记忆范围',
                  'zh-HK': '記憶範圍',
                },
                tip: {
                  type: 'i18n',
                  'en-US': 'Choose which settings to remember',
                  'zh-CN': '选择要记忆的设置项',
                  'zh-HK': '選擇要記憶的設置項',
                },
              },
              condition: {
                type: "JSFunction",
                value: 'target => !!target.getProps().getPropValue("localSettings.enable")',
              },
              setter: {
                componentName: "SelectSetter",
                props: {
                  mode: "multiple",
                  options: [
                    { title: '筛选', value: "filters" },
                    { title: '排序', value: "sorting" },
                    { title: '列配置', value: "columns" },
                  ],
                },
              },
              defaultValue: ["filters", "sorting", "columns"],
            },
            {
              name: "localSettings.excludedFilterFields",
              title: {
                label: {
                  type: 'i18n',
                  'en-US': 'Excluded filter fields',
                  'zh-CN': '筛选排除字段',
                  'zh-HK': '篩選排除字段',
                },
                tip: {
                  type: 'i18n',
                  'en-US': 'Filter fields that should not be remembered',
                  'zh-CN': '不需要记忆的筛选字段',
                  'zh-HK': '不需要記憶的篩選字段',
                },
              },
              condition: {
                type: "JSFunction",
                value: 'target => { const enable = !!target.getProps().getPropValue("localSettings.enable"); const scope = target.getProps().getPropValue("localSettings.scope") || []; return enable && Array.isArray(scope) && scope.includes("filters"); }',
              },
              setter: {
                componentName: "SelectSetter",
                props: (target: any) => {
                  const filterList = (target.parent.parent.getPropValue("filter.items") || []) as any[];


                  const searchDetail = target.parent.parent.getPropValue("search");

                  if (searchDetail && searchDetail.show) {
                    filterList.unshift({
                      label: "搜索",
                      value: searchDetail.key || "_keywords",
                      isHidden: false,
                    });
                  }

                  return {
                    mode: "multiple",
                    options: filterList
                      .map((item: any) => ({
                        title:
                          (item && (typeof item.label === 'string' ? item.label : item.label?.["zh-CN"] || item.label?.["zh-HK"] || item.label?.en)) ||
                          item?.key ||
                          item?.columnKey ||
                          "",
                        value: item?.value || "",
                        isHidden: item?.isHidden,
                      }))
                      .filter((opt: any) => opt.value && !opt.isHidden),
                  };
                },
              },
            },
          ],
        },

      ],
    },
  ],
  configure: {
    props: [
      {
        title: '数据源',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'dataSource',
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Table Data',
                'zh-CN': '表格数据',
              },
              tip: {
                type: 'i18n',
                'en-US': 'dataSource | Table data',
                'zh-CN': 'dataSource | 表格数据',
              },
            },
            setter: {
              componentName: 'JsonSetter',
            },
            supportVariable: true,
          },
          {
            name: 'loading',
            title: { label: '加载中', tip: 'loading | 是否加载中' },
            setter: {
              componentName: 'BoolSetter',
            },
            defaultValue: false,
            supportVariable: true,
          },
          {
            name: 'rowKey',
            title: {
              label: '行Key',
              tip: 'rowKey | 表格行 key 的取值，可以是字符串或一个函数',
            },
            setter: [
              {
                componentName: 'StringSetter',
              },
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'getRowKey(record,index,${extParams}){\n// 通过函数获取表格行 key\nreturn record.id;\n}',
                },
              },
              'VariableSetter',
            ],
            defaultValue: 'id',
          },
          {
            name: 'currentSettingKey',
            title: {
              label: 'currentSettingKey',
              tip: 'currentSettingKey | 当前本地配置的key 用此hash是否改变用来判断是否清空本地配置 不填默认使用columns数据生成hash',
            },
            setter: {
              componentName: 'StringSetter',
            },
          },
          {
            name: 'currentComponentId',
            title: {
              label: 'currentComponentId',
              tip: 'currentComponentId | 当前本地配置的唯一值 不填默认使用currentSettingKey',
            },
            setter: {
              componentName: 'StringSetter',
            },
          },
        ],
      },
      {
        name: 'columns',
        title: { label: '表格列', tip: '表格列的配置描述，具体项见下表' },
        setter: {
          componentName: 'ArraySetter',
          props: {
            itemSetter: {
              componentName: 'ObjectSetter',
              props: {
                config: {
                  items: [
                    {
                      name: 'title',
                      title: { label: '列标题', tip: 'title | 列标题' },
                      propType: {
                        type: 'oneOfType',
                        value: ['string', 'func'],
                      },
                      setter: [
                        'PisellI18nSetter',
                        {
                          componentName: 'SlotSetter',
                          title: '列标题插槽',
                          initialValue: {
                            type: 'JSSlot',
                            params: ['options'],
                            value: [],
                          },
                        },
                      ],
                    },
                    {
                      name: 'dataIndex',
                      title: { label: '数据字段', tip: 'dataIndex | 数据字段' },
                      setter: [
                        'StringSetter',
                        {
                          componentName: 'ArraySetter',
                          props: {
                            itemSetter: {
                              componentName: 'StringSetter',
                            },
                          },
                        },
                      ],
                      isRequired: true,
                    },
                    {
                      name: 'key',
                      title: {
                        label: 'React key',
                        tip: 'key | React需要的key',
                      },
                      propType: 'string',
                      setter: 'StringSetter',
                      isRequired: true,
                    },
                    {
                      name: 'align',
                      title: { label: '对齐方式', tip: 'align | 对齐方式' },
                      propType: {
                        type: 'oneOf',
                        value: ['left', 'right', 'center'],
                      },
                      defaultValue: 'left',
                      setter: [
                        {
                          componentName: 'RadioGroupSetter',
                          props: {
                            options: [
                              {
                                title: 'left',
                                value: 'left',
                              },
                              {
                                title: 'right',
                                value: 'right',
                              },
                              {
                                title: 'center',
                                value: 'center',
                              },
                            ],
                          },
                        },
                        'VariableSetter',
                      ],
                    },
                    {
                      name: 'fixed',
                      title: { label: '列是否固定', tip: 'fixed | 列是否固定' },
                      description:
                        '（IE 下无效）列是否固定，可选 true (等效于 left) left right',
                      defaultValue: '',
                      propType: {
                        type: 'oneOf',
                        value: ['', 'left', 'right'],
                      },
                      setter: [
                        {
                          componentName: 'RadioGroupSetter',
                          props: {
                            options: [
                              {
                                title: '不固定',
                                value: '',
                              },
                              {
                                title: '固定在左侧',
                                value: 'left',
                              },
                              {
                                title: '固定在右侧',
                                value: 'right',
                              },
                            ],
                          },
                        },
                        'VariableSetter',
                      ],
                    },
                    {
                      name: 'className',
                      title: {
                        label: '列样式类名',
                        tip: 'className | 列样式类名',
                      },
                      propType: 'string',
                      setter: 'StringSetter',
                    },
                    {
                      name: 'width',
                      title: { label: '宽度', tip: 'width | 宽度' },
                      propType: {
                        type: 'oneOfType',
                        value: ['number', 'string'],
                      },
                      setter: [
                        'NumberSetter',
                        'StringSetter',
                        'VariableSetter',
                      ],
                    },
                    {
                      name: 'sorter',
                      title: {
                        label: '排序规则',
                        tip: 'sorter | 排序函数，本地排序使用一个函数，需要服务端排序可设为 true',
                      },
                      propType: { type: 'oneOfType', value: ['bool', 'func'] },
                      setter: [
                        'BoolSetter',
                        'FunctionSetter',
                        'VariableSetter',
                      ],
                    },
                    {
                      name: 'defaultFilters',
                      title: {
                        label: '默认筛选',
                        tip: 'defaultFilters | 是否开启默认筛选',
                      },
                      propType: 'bool',
                      setter: 'BoolSetter',
                    },
                    {
                      name: 'hidden',
                      title: {
                        label: '是否隐藏',
                        tip: 'hidden | 是否隐藏当前列',
                      },
                      propType: 'bool',
                      setter: 'BoolSetter',
                    },
                    {
                      name: 'filters',
                      title: {
                        label: '筛选菜单项',
                        tip: 'filters | 表头的筛选菜单项',
                      },
                      propType: 'object',
                      setter: 'JsonSetter',
                    },
                    {
                      name: 'other',
                      title: {
                        label: '其他拓展属性',
                        tip: '其他拓展属性',
                      },
                      propType: 'object',
                      setter: 'JsonSetter',
                    },
                    {
                      name: 'field_type',
                      title: { label: '字段类型', tip: '所筛选的字段类型' },
                      propType: 'string',
                      setter: {
                        componentName: 'SelectSetter',
                        mode: 'single',
                        defaultValue: 'text',
                        props: {
                          options: [
                            {
                              title: '文本',
                              value: 'text',
                            },
                            {
                              title: '单选',
                              value: 'select',
                            },
                            {
                              title: '数字',
                              value: 'number',
                            },
                            {
                              title: '日期',
                              value: 'date',
                            },
                            {
                              title: '链接',
                              value: 'link',
                            },
                          ],
                        },
                      },
                    },
                    {
                      name: 'render',
                      title: {
                        label: '自定义渲染',
                        tip: 'render | 插槽内的物料表达式可通过this.record获取当前行数据，this.index获取索引',
                      },
                      propType: 'func',
                      setter: [
                        {
                          componentName: 'SlotSetter',
                          title: '单元格插槽',
                          initialValue: {
                            type: 'JSSlot',
                            params: ['text', 'record', 'index'],
                            value: [],
                          },
                        },
                        'VariableSetter',
                      ],
                    },
                    {
                      name: 'action',
                      title: { label: 'Action', tip: 'Action' },
                      propType: 'string',
                      setter: 'StringSetter',
                    },
                    {
                      name: 'contentClassName',
                      title: {
                        label: '内容样式类名',
                        tip: '内容样式类名',
                      },
                      propType: 'string',
                      setter: 'StringSetter',
                    },
                  ],
                },
              },
              initialValue: { title: '标题', width: 250, dataIndex: '' },
            },
          },
        },
      },
      {
        title: '视图',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'view.defaultViewMode',
            title: {
              label: '默认视图',
              tip: 'view.defaultViewMode | 组件默认展示视图',
            },
            propType: 'string',
            setter: {
              componentName: 'RadioGroupSetter',
              props: {
                options: [
                  {
                    title: 'Grid',
                    value: 'grid',
                  },
                  {
                    title: 'Gallery',
                    value: 'gallery',
                  },
                  {
                    title: 'Kanban',
                    value: 'kanban',
                  },
                ],
              },
            },
          },
          {
            name: 'view.multiple',
            title: {
              label: '开启多视图',
              tip: 'view.multiple | 开启多视图后可以进行不同组件类型切换',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'view.modeList',
            title: {
              label: '多视图',
              tip: 'view.modeList | 组件多视图选项',
            },
            condition(target) {
              return !!target.getProps().getPropValue('view.multiple');
            },
            setter: {
              componentName: 'SelectSetter',
              props: {
                mode: 'multiple',
                options: [
                  {
                    title: 'Grid',
                    value: 'grid',
                  },
                  {
                    title: 'Gallery',
                    value: 'gallery',
                  },
                  {
                    title: 'Kanban',
                    value: 'kanban',
                  },
                ],
              },
            },
          },
        ],
      },
      {
        title: 'Gallery',
        display: 'entry',
        type: 'group',
        items: [
          {
            name: 'gallery.cardMinWidth',
            title: {
              label: '卡片最小宽度',
              tip: '卡片最小宽度，屏幕尺寸改变时卡片宽度始终保持在最大最小之间｜gallery.cardMinWidth',
            },
            setter: 'NumberSetter',
            defaultValue: 260,
          },
          {
            name: 'gallery.cardMaxWidth',
            title: {
              label: '卡片最大宽度',
              tip: '卡片最大宽度，屏幕尺寸改变时卡片宽度始终保持在最大最小之间｜gallery.cardMaxWidth',
            },
            setter: 'NumberSetter',
            defaultValue: 340,
          },
          {
            name: 'gallery.horizontalGutter',
            title: {
              label: '水平间隔',
              tip: '水平间隔｜gallery.horizontalGutter',
            },
            setter: 'NumberSetter',
            defaultValue: 32,
          },
          {
            name: 'gallery.verticalGutter',
            title: {
              label: '垂直间隔',
              tip: '垂直间隔｜gallery.verticalGutter',
            },
            setter: 'NumberSetter',
            defaultValue: 32,
          },
          {
            name: 'gallery.fixedHeight',
            title: { label: '高度固定', tip: '高度固定｜gallery.fixedHeight' },
            setter: 'BoolSetter',
          },
          {
            name: 'gallery.cardHeight',
            title: { label: '卡片高度', tip: '卡片高度｜gallery.cardHeight' },
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("gallery.fixedHeight")',
            },
          },
          {
            name: 'gallery.fixedHeader',
            title: {
              label: '固定顶部',
              tip: '是否固定顶部｜gallery.fixedHeader',
            },
            setter: 'BoolSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("gallery.fixedHeight")',
            },
          },
          {
            name: 'gallery.fixedFooter',
            title: {
              label: '固定底部',
              tip: '是否固定底部｜gallery.fixedFooter',
            },
            setter: 'BoolSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("gallery.fixedHeight")',
            },
          },
          {
            name: 'gallery.footer.render',
            title: {
              label: '底部渲染函数',
              tip: '底部渲染函数 ｜gallery.footer.render',
            },
            propType: 'func',
            setter: [
              {
                componentName: 'SlotSetter',
                title: '底部函数插槽',
                initialValue: {
                  type: 'JSSlot',
                  params: ['record', 'index'],
                  value: [],
                },
              },
              {
                componentName: 'FunctionSetter',
                props: {
                  template: 'footer(){\n// 自定义渲染底部\nreturn `Footer`;\n}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'gallery.footer.height',
            title: {
              label: '底部高度',
              tip: '底部高度｜gallery.footer.height',
            },
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("gallery.footer.render")',
            },
          },
          {
            name: 'gallery.onItem',
            title: {
              label: '卡片点击事件',
              tip: '卡片点击事件｜gallery.onItem',
            },
            setter: {
              componentName: 'FunctionSetter',
              props: {
                template:
                  "onItem(record,index){\n// 卡片点击事件\nconsole.log(record,index,'record,index');\n}",
              },
            },
          },
          {
            title: '头部区域',
            display: 'block',
            type: 'group',
            items: [
              {
                name: 'gallery.cover.show',
                title: {
                  label: '封面开启',
                  tip: '封面开启｜gallery.cover.show',
                },
                setter: 'BoolSetter',
                defaultValue: true,
              },
              {
                name: 'gallery.cover.fields',
                title: {
                  label: '封面内容',
                  tip: 'gallery.cover.fields | 封面内容字段',
                },
                setter: {
                  componentName: 'SelectSetter',
                  props: (target) => {
                    const columns = (
                      target.parent as any
                    ).parent.parent.getPropValue('columns');
                    return {
                      mode: 'multiple',
                      options:
                        columns?.map?.((item: any) => ({
                          title:
                            typeof item.title === 'string'
                              ? item.title
                              : item.key,
                          value: item.key,
                        })) || [],
                    };
                  },
                },
                condition: {
                  type: 'JSFunction',
                  value:
                    'target => !!target.getProps().getPropValue("gallery.cover.show")',
                },
              },
              {
                name: 'gallery.cover.height',
                title: {
                  label: '封面高度',
                  tip: 'gallery.cover.height | 封面高度',
                },
                propType: 'number',
                setter: 'NumberSetter',
                defaultValue: 230,
                condition: {
                  type: 'JSFunction',
                  value:
                    'target => !!target.getProps().getPropValue("gallery.cover.show")',
                },
              },
              {
                name: 'gallery.cover.objectFit',
                title: {
                  label: '封面效果',
                  tip: 'gallery.cover.objectFit | 封面效果',
                },
                propType: 'string',
                setter: {
                  componentName: 'RadioGroupSetter',
                  props: {
                    options: [
                      {
                        title: '适应',
                        value: 'fill',
                      },
                      {
                        title: '裁剪',
                        value: 'cover',
                      },
                    ],
                  },
                  initialValue: 'fill',
                },
                condition: {
                  type: 'JSFunction',
                  value:
                    'target => !!target.getProps().getPropValue("gallery.cover.show")',
                },
              },
              {
                name: 'gallery.title.field',
                title: {
                  label: '标题内容',
                  tip: 'gallery.title.field | 标题内容',
                },
                propType: 'string',
                setter: {
                  componentName: 'SelectSetter',
                  props: (target) => {
                    const columns = (
                      target.parent as any
                    ).parent.parent.getPropValue('columns');
                    return {
                      mode: 'single',
                      options:
                        columns?.map?.((item: any) => ({
                          title:
                            typeof item.title === 'string'
                              ? item.title
                              : item.key,
                          value: item.key,
                        })) || [],
                    };
                  },
                },
              },
              {
                name: 'gallery.title.line',
                title: {
                  label: '标题行数',
                  tip: 'gallery.title.line | 标题行数',
                },
                propType: 'number',
                setter: 'NumberSetter',
              },
              {
                name: 'gallery.header.slot',
                title: {
                  label: '开启插槽',
                  tip: 'gallery.header.slot | 开启插槽',
                },
                propType: 'func',
                setter: [
                  {
                    componentName: 'SlotSetter',
                    title: '函数插槽',
                    initialValue: {
                      type: 'JSSlot',
                      params: ['record', 'index'],
                      value: [],
                    },
                  },
                  'VariableSetter',
                ],
              },
              {
                name: 'gallery.header.fields.show',
                title: {
                  label: '其他字段',
                  tip: 'gallery.header.fields.show | 其他字段',
                },
                propType: 'bool',
                setter: 'BoolSetter',
                defaultValue: false,
              },
              {
                name: 'gallery.header.fields.list',
                title: {
                  label: '其他字段',
                  tip: 'gallery.header.fields.list | 选择字段渲染在上方',
                },
                condition: {
                  type: 'JSFunction',
                  value:
                    'target => !!target.getProps().getPropValue("gallery.header.fields.show")',
                },
                setter: {
                  componentName: 'SelectSetter',
                  props: (target: any) => {
                    const columns =
                      target.parent.parent.parent.getPropValue('columns');
                    return {
                      mode: 'multiple',
                      options:
                        columns?.map?.((item: any) => ({
                          title:
                            typeof item.title === 'string'
                              ? item.title
                              : item.key,
                          value: item.key,
                        })) || [],
                    };
                  },
                },
              },
            ],
          },
          {
            title: '内容区域',
            display: 'block',
            type: 'group',
            items: [
              {
                name: 'gallery.content.fields',
                title: '',
                setter: {
                  componentName: 'ArraySetter',
                  props: {
                    itemSetter: {
                      componentName: 'ObjectSetter',
                      props: {
                        config: {
                          items: [
                            {
                              name: 'columnKey',
                              title: { label: '渲染字段', tip: '渲染字段' },
                              isRequired: true,
                              setter: {
                                componentName: 'SelectSetter',
                                props: (target: any) => {
                                  const columns =
                                    target.parent.parent.parent.getPropValue(
                                      'columns'
                                    );
                                  const fieldsKey = target.parent.parent.parent
                                    .getPropValue('gallery.content.fields')
                                    .map((item: any) => item?.columnKey)
                                    .filter(Boolean);
                                  return {
                                    mode: 'single',
                                    options:
                                      columns?.map?.((item: any) => ({
                                        title:
                                          typeof item.title === 'string'
                                            ? item.title
                                            : item.key,
                                        value: item.key,
                                        disabled: fieldsKey.includes(item.key),
                                      })) || [],
                                  };
                                },
                              },
                            },
                            {
                              name: 'show',
                              title: { label: '是否展示', tip: '是否展示' },
                              propType: 'bool',
                              setter: 'BoolSetter',
                              isRequired: true,
                            },
                          ],
                        },
                      },
                      initialValue: {
                        columnKey: '',
                        show: true,
                      },
                    },
                  },
                  initialValue: (target: any) => {
                    const columns =
                      target.parent.parent.parent.getPropValue('columns');
                    return (
                      columns?.map?.((item: any) => ({
                        columnKey: item.key,
                        show: true,
                      })) || []
                    );
                  },
                },
              },
            ],
          },
        ],
      },
      {
        title: '外观',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'showHeader',
            title: { label: '显示表头', tip: 'showHeader | 是否显示表头' },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: true,
          },
          {
            name: 'bordered',
            title: {
              label: '显示边框',
              tip: 'bordered | 是否展示外边框和列边框',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: true,
          },
          {
            name: 'size',
            title: { label: '表格大小', tip: 'size | 表格大小' },
            propType: {
              type: 'oneOf',
              value: ['default', 'middle', 'small'],
            },
            setter: [
              {
                componentName: 'RadioGroupSetter',
                props: {
                  options: [
                    {
                      title: '默认',
                      value: 'default',
                    },
                    {
                      title: '中',
                      value: 'middle',
                    },
                    {
                      title: '小',
                      value: 'small',
                    },
                  ],
                },
              },
              'VariableSetter',
            ],
            defaultValue: 'default',
          },
          {
            name: 'tableLayout',
            title: { label: '表格布局', tip: 'tableLayout | 表格布局' },
            defaultValue: '',
            propType: {
              type: 'oneOf',
              value: ['', 'auto', 'fixed'],
            },
            setter: [
              {
                componentName: 'RadioGroupSetter',
                props: {
                  options: [
                    {
                      title: '默认',
                      value: '',
                    },
                    {
                      title: '自动',
                      value: 'auto',
                    },
                    {
                      title: '固定',
                      value: 'fixed',
                    },
                  ],
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'virtual',
            title: {
              label: '虚拟列表',
              tip: 'virtual | 支持虚拟列表，开启后不支持 components.body 自定义',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: true,
          },
        ],
      },
      {
        title: '分页',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'pagination',
            title: { label: '显示分页', tip: 'pagination | 显示分页' },
            propType: 'object',
            setter: 'BoolSetter',
            extraProps: {
              setValue: (target, value) => {
                if (value) {
                  target.parent.setPropValue('pagination', {
                    pageSize: 10,
                  });
                }
              },
            },
          },
          {
            name: 'pagination.pageSize',
            title: { label: '每页条数', tip: 'pagination.pageSize | 每页条数' },
            propType: 'number',
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.total',
            title: { label: '数据总数', tip: 'pagination.total | 数据总数' },
            propType: 'number',
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.defaultCurrent',
            title: {
              label: '默认当前页',
              tip: 'pagination.defaultCurrent | 默认的当前页数',
            },
            propType: 'number',
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.current',
            title: { label: '当前页数', tip: 'pagination.current | 当前页数' },
            propType: 'number',
            setter: 'NumberSetter',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.showPagination',
            title: {
              label: '始终显示分页',
              tip: 'pagination.showPagination | 当前数据总数大于10 则始终显示分页器',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.showTotal',
            title: {
              label: '显示总数',
              tip: 'pagination.showTotal | 用于显示数据总量和当前数据顺序',
            },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'showTotal(total,range,${extParams}){\n// 用于格式化显示表格数据总量\nreturn `共 ${total} 条`;\n}',
                },
              },
              'VariableSetter',
            ],
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.showSizeChanger',
            title: {
              label: '页数切换',
              tip: 'pagination.showSizeChanger | 是否展示 pageSize 切换器',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.localPagination',
            title: {
              label: '前端分页',
              tip: 'pagination.localPagination | 是否前端分页开启后表头搜索和分页前端处理',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.showQuickJumper',
            title: {
              label: '快速跳转',
              tip: 'pagination.showQuickJumper | 是否可以快速跳转至某页',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.simple',
            title: { label: '简单分页', tip: 'pagination.simple | 简单分页' },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.size',
            title: { label: '分页尺寸', tip: 'pagination.size | 分页尺寸' },
            propType: {
              type: 'oneOf',
              value: ['default', 'small'],
            },
            setter: [
              {
                componentName: 'RadioGroupSetter',
                props: {
                  options: [
                    {
                      title: '默认',
                      value: 'default',
                    },
                    {
                      title: '小',
                      value: 'small',
                    },
                  ],
                },
              },
              'VariableSetter',
            ],
            defaultValue: 'default',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
          {
            name: 'pagination.position',
            title: { label: '分页位置', tip: 'pagination.position | 分页位置' },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'SelectSetter',
                  props: {
                    options: [
                      {
                        title: '上左',
                        value: 'topLeft',
                      },
                      {
                        title: '上中',
                        value: 'topCenter',
                      },
                      {
                        title: '上右',
                        value: 'topRight',
                      },
                      {
                        title: '下左',
                        value: 'bottomLeft',
                      },
                      {
                        title: '下中',
                        value: 'bottomCenter',
                      },
                      {
                        title: '下右',
                        value: 'bottomRight',
                      },
                    ],
                  },
                  initialValue: 'bottomRight',
                },
              },
            },
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("pagination")',
            },
          },
        ],
      },
      {
        title: '滚动',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'scroll.autoCalc',
            title: {
              label: '自动计算',
              tip: 'scroll.autoCalc | 是否自动计算scroll x y',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'scroll.scrollToFirstRowOnChange',
            title: {
              label: '自动滚动',
              tip: 'scroll.scrollToFirstRowOnChange | 是否自动滚动到表格顶部',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: true,
          },
          {
            name: 'scroll.x',
            title: {
              label: '横向滚动',
              tip: 'scroll.x | 	设置横向滚动，也可用于指定滚动区域的宽，可以设置为像素值，百分比，true 和 max-content',
            },
            propType: { type: 'oneOfType', value: ['number', 'bool'] },
            setter: ['NumberSetter', 'BoolSetter', 'VariableSetter'],
          },
          {
            name: 'scroll.y',
            title: {
              label: '纵向滚动',
              tip: 'scroll.y | 	设置纵向滚动，也可用于指定滚动区域的高，可以设置为像素值',
            },
            propType: 'number',
            setter: ['NumberSetter', 'VariableSetter'],
          },
        ],
      },
      {
        title: '行选择器',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'rowSelection',
            title: { label: '行选择', tip: 'rowSelection | 行选择' },
            propType: 'object',
            setter: 'BoolSetter',
            extraProps: {
              setValue: (target, value) => {
                if (value) {
                  target.parent.setPropValue('rowSelection', {
                    type: 'radio',
                    columnWidth: 48,
                  });
                }
              },
            },
          },
          {
            name: 'rowSelection.type',
            title: {
              label: '行选择类型',
              tip: 'rowSelection.type | 多选/单选',
            },
            propType: {
              type: 'oneOf',
              value: ['checkbox', 'radio'],
            },
            setter: [
              {
                componentName: 'RadioGroupSetter',
                props: {
                  options: [
                    {
                      title: '多选',
                      value: 'checkbox',
                    },
                    {
                      title: '单选',
                      value: 'radio',
                    },
                  ],
                },
              },
              'VariableSetter',
            ],
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
          {
            name: 'rowSelection.fixed',
            title: {
              label: '固定左边',
              tip: 'rowSelection.fixed | 把选择框列固定在左边',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
          {
            name: 'rowSelection.columnWidth',
            title: {
              label: '自定义列表选择框宽度',
              tip: 'rowSelection.columnWidth | 自定义列表选择框宽度',
            },
            propType: {
              type: 'oneOfType',
              value: ['number', 'string'],
            },
            setter: ['NumberSetter', 'StringSetter', 'VariableSetter'],
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
          {
            name: 'rowSelection.selectedRowKeys',
            title: {
              label: '选中行Key',
              tip: 'rowSelection.selectedRowKeys | 指定选中项的 key 数组',
            },
            propType: 'object',
            setter: 'JsonSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
          {
            name: 'rowSelection.preserveSelectedRowKeys',
            title: {
              label: '保留选项',
              tip: 'rowSelection.preserveSelectedRowKeys | 当数据被删除时仍然保留选项',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
          {
            name: 'rowSelection.getCheckboxProps',
            title: {
              label: '默认属性',
              tip: 'rowSelection.getCheckboxProps | 选择框的默认属性配置',
            },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'getCheckboxProps(record,${extParams}){\n// 选择框的默认属性配置\nreturn { disabled: false };\n}',
                },
              },
              'VariableSetter',
            ],
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("rowSelection")',
            },
          },
        ],
      },
      {
        title: '行展开',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'expandable.expandedRowRender',
            title: {
              label: '展开行渲染',
              tip: 'expandable.expandedRowRender | 额外的展开行',
            },
            propType: 'func',
            setter: [
              {
                componentName: 'SlotSetter',
                title: '展开行插槽',
                initialValue: {
                  type: 'JSSlot',
                  params: ['record', 'index', 'indent', 'expanded'],
                  value: [],
                },
              },
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'expandedRowRender(record,index,indent,expanded,${extParams}){\n// 展开行渲染\nreturn `${record.id}`}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'expandable.rowExpandable',
            title: {
              label: '是否可展开',
              tip: 'expandable.rowExpandable | 行是否可展开',
            },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'rowExpandable(record,${extParams}){\n// 行是否可展开\nreturn true;\n}',
                },
              },
              'VariableSetter',
            ],
          },
        ],
      },
      {
        title: '扩展',
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'title',
            title: { label: '表格标题', tip: 'title | 表格标题' },
            propType: 'func',
            setter: [
              {
                componentName: 'SlotSetter',
                title: '表格标题插槽',
                initialValue: {
                  type: 'JSSlot',
                  params: ['currentPageData'],
                  value: [],
                },
              },
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'renderTitle(currentPageData,${extParams}){\n// 自定义渲染表格顶部\nreturn "表格顶部";\n}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'summary',
            title: { label: '统计栏' },
            propType: 'func',
            setter: [
              {
                componentName: 'SlotSetter',
                title: '统计栏插槽',
                initialValue: {
                  type: 'JSSlot',
                  params: ['currentPageData'],
                  value: [],
                },
              },
            ],
          },
          {
            name: 'onHeaderRow',
            title: { label: '头部行属性', tip: 'onHeaderRow | 设置头部行属性' },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'onHeaderRow(columns,index,${extParams}){\n// 设置头部行属性\nreturn {onClick:()=>{}};\n}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'onRow',
            title: { label: '行属性', tip: 'onRow | 设置行属性' },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'onRow(record,index,${extParams}){\n// 设置行属性\nreturn {onClick:event=>{}};\n}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'rowClassName',
            title: { label: '行类名', tip: 'rowClassName | 表格行的类名' },
            propType: 'func',
            setter: [
              {
                componentName: 'FunctionSetter',
                props: {
                  template:
                    'rowClassName(record,index,${extParams}){\n// 表格行的类名\nreturn `className-${record.type}`;\n}',
                },
              },
              'VariableSetter',
            ],
          },
          {
            name: 'dragSort',
            title: {
              label: '拖拽排序',
              tip: 'dragSort | 开启拖拽排序',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
        ],
      },
      {
        title: "本地记忆",
        display: "block",
        type: "group",
        items: [
          {
            name: "localSettings.enable",
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Enable settings memory',
                'zh-CN': '启用设置记忆',
                'zh-HK': '啟用設置記憶',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Automatically save and restore table settings',
                'zh-CN': '自动保存和恢复表格设置',
                'zh-HK': '自動保存和恢復表格設置',
              },
            },
            propType: "bool",
            setter: "BoolSetter",
            defaultValue: true,
          },
          {
            name: "localSettings.scope",
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Memory scope',
                'zh-CN': '记忆范围',
                'zh-HK': '記憶範圍',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Choose which settings to remember',
                'zh-CN': '选择要记忆的设置项',
                'zh-HK': '選擇要記憶的設置項',
              },
            },
            condition: {
              type: "JSFunction",
              value: 'target => !!target.getProps().getPropValue("localSettings.enable")',
            },
            setter: {
              componentName: "SelectSetter",
              props: {
                mode: "multiple",
                options: [
                  { title: '筛选', value: "filters" },
                  { title: '排序', value: "sorting" },
                  { title: '列配置', value: "columns" },
                ],
              },
            },
            defaultValue: ["filters", "sorting", "columns"],
          },
          {
            name: "localSettings.excludedFilterFields",
            title: {
              label: {
                type: 'i18n',
                'en-US': 'Excluded filter fields',
                'zh-CN': '筛选排除字段',
                'zh-HK': '篩選排除字段',
              },
              tip: {
                type: 'i18n',
                'en-US': 'Filter fields that should not be remembered',
                'zh-CN': '不需要记忆的筛选字段',
                'zh-HK': '不需要記憶的篩選字段',
              },
            },
            condition: {
              type: "JSFunction",
              value: 'target => { const enable = !!target.getProps().getPropValue("localSettings.enable"); const scope = target.getProps().getPropValue("localSettings.scope") || []; return enable && Array.isArray(scope) && scope.includes("filters"); }',
            },
            setter: {
              componentName: "SelectSetter",
              props: (target: any) => {
                const filterList = (target.parent.parent.getPropValue("filter.items") || []) as any[];


                const searchDetail = target.parent.parent.getPropValue("search");

                if (searchDetail && searchDetail.show) {
                  filterList.unshift({
                    label: "搜索",
                    value: searchDetail.key || "_keywords",
                    isHidden: false,
                  });
                }

                return {
                  mode: "multiple",
                  options: filterList
                    .map((item: any) => ({
                      title:
                        (item && (typeof item.label === 'string' ? item.label : item.label?.["zh-CN"] || item.label?.["zh-HK"] || item.label?.en)) ||
                        item?.key ||
                        item?.columnKey ||
                        "",
                      value: item?.value || "",
                      isHidden: item?.isHidden,
                    }))
                    .filter((opt: any) => opt.value && !opt.isHidden),
                };
              },
            },
          },
        ],
      },
      {
        title: { label: '列配置', tip: '表格的列配置' },
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'columnSetting.show',
            title: {
              label: '开启列配置',
              tip: 'columnSetting.show | 是否开启字段隐藏展示及顺序调整按钮',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'columnSetting.storageMode',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("columnSetting.show")',
            },
            title: {
              label: '存储模式',
              tip: 'columnSetting.storageMode | 列配置存储模式 关闭时刷新页面还原',
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              mode: 'single',
              defaultValue: 'localStorage',
              props: {
                options: [
                  {
                    title: '关闭',
                    value: '',
                  },
                  {
                    title: '本地localStorage',
                    value: 'localStorage',
                  },
                ],
              },
            },
          },
        ],
      },
      {
        title: { label: '分组配置', tip: '表格的分组配置' },
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'dataSourceGroup.show',
            title: {
              label: '开启分组功能',
              tip: 'dataSourceGroup.show | 是否开启针对字段分组功能',
            },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'dataSourceGroup.storageMode',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("dataSourceGroup.show")',
            },
            title: {
              label: '存储模式',
              tip: 'dataSourceGroup.storageMode | 分组信息存储模式 关闭时刷新页面还原',
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              mode: 'single',
              defaultValue: 'localStorage',
              props: {
                options: [
                  {
                    title: '关闭',
                    value: '',
                  },
                  {
                    title: '本地localStorage',
                    value: 'localStorage',
                  },
                ],
              },
            },
          },
          {
            name: 'dataSourceGroup.list',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("dataSourceGroup.show")',
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'isCustom',
                          title: {
                            label: '开启定制字段',
                            tip: '开启定制字段，可自定义排序名和排序的key，关闭时可选择column中的title和dataIndex',
                          },
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'isHidden',
                          title: {
                            label: '是否隐藏',
                            tip: '开启时，当前项展示， 关闭时，当前项隐藏',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'columnKey',
                          title: {
                            label: '选择字段',
                            tip: '选择column中的title和dataIndex字段进行排序',
                          },
                          isRequired: true,
                          condition(target: any) {
                            return !target.parent.getPropValue('isCustom');
                          },
                          setter: [
                            {
                              componentName: 'SelectSetter',
                              mode: 'single',
                              props: (target: any) => {
                                const fieldsKey = target.parent.parent.parent
                                  .getPropValue('dataSourceGroup.list')
                                  .map((item: any) => item?.columnKey)
                                  .filter(Boolean);
                                return {
                                  options:
                                    target.parent.parent.parent
                                      .getPropValue('columns')
                                      ?.map?.((item: any) => ({
                                        title: getI18n(item.title) || item.key,
                                        value: item.key,
                                        disabled: fieldsKey.includes(item.key),
                                      })) || [],
                                };
                              },
                            },
                            'StringSetter',
                          ],
                        },
                        {
                          name: 'label',
                          title: { label: '筛选项', tip: '筛选项' },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'name',
                          title: { label: '字段', tip: '所筛选的字段' },
                          setter: [
                            'StringSetter',
                            {
                              componentName: 'ArraySetter',
                              props: {
                                itemSetter: {
                                  componentName: 'StringSetter',
                                },
                              },
                            },
                          ],
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                      ],
                    },
                  },
                  initialValue: {
                    label: '标题',
                    name: '',
                    columnKey: '',
                    isCustom: false,
                    isHidden: false,
                  },
                },
              },
            },
          },
        ],
      },
      {
        title: { label: '筛选项', tip: '表格的筛选项' },
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'filter.show',
            title: { label: '开启筛选', tip: '开启筛选' },
            propType: 'object',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'filter.sortButtonShow',
            title: { label: '开启筛选排序按钮', tip: '开启筛选排序按钮' },
            propType: 'object',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'filter.storageMode',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
            title: {
              label: '存储模式',
              tip: 'filter.storageMode | 筛选信息存储模式 关闭时刷新页面还原',
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              mode: 'single',
              defaultValue: 'localStorage',
              props: {
                options: [
                  {
                    title: '关闭',
                    value: '',
                  },
                  {
                    title: '本地localStorage',
                    value: 'localStorage',
                  },
                ],
              },
            },
          },
          {
            name: 'filter.quickFilterMaxLength',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
            title: { label: '快速筛选项', tip: '外层快速筛选项最大数量控制' },
            propType: 'number',
            setter: 'NumberSetter',
            defaultValue: 3,
          },
          {
            name: 'filter.list',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("filter.show")',
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'isCustom',
                          title: {
                            label: '开启定制字段',
                            tip: '开启定制字段，可自定义排序名和排序的key，关闭时可选择column中的title和dataIndex',
                          },
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'columnKey',
                          title: {
                            label: '选择字段',
                            tip: '选择column中的title和dataIndex字段进行排序',
                          },
                          isRequired: true,
                          condition(target: any) {
                            return !target.parent.getPropValue('isCustom');
                          },
                          setter: [
                            {
                              componentName: 'SelectSetter',
                              mode: 'single',
                              props: (target: any) => {
                                console.log(
                                  target.parent.parent.parent,
                                  this,
                                  'target.parent.parent.parent\n' +
                                    '                                  .getPropValue("columns")'
                                );
                                const fieldsKey =
                                  target.parent.parent.parent
                                    .getPropValue('filter.list')
                                    ?.map((item: any) => item?.columnKey)
                                    ?.filter(Boolean) || [];
                                return {
                                  options:
                                    target.parent.parent.parent
                                      .getPropValue('columns')
                                      ?.map?.((item: any) => ({
                                        title: getI18n(item.title) || item.key,
                                        value: item.key,
                                        disabled: fieldsKey.includes(item.key),
                                      })) || [],
                                };
                              },
                            },
                            'StringSetter',
                          ],
                        },
                        {
                          name: 'label',
                          title: { label: '筛选项', tip: '筛选项' },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'name',
                          title: { label: '字段', tip: '所筛选的字段' },
                          setter: [
                            'StringSetter',
                            {
                              componentName: 'ArraySetter',
                              props: {
                                itemSetter: {
                                  componentName: 'StringSetter',
                                },
                              },
                            },
                          ],
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'key',
                          title: { label: 'key', tip: '唯一标识' },
                          propType: 'string',
                          setter: 'StringSetter',
                          isRequired: true,
                        },
                        {
                          name: 'type',
                          title: { label: '字段类型', tip: '所筛选的字段类型' },
                          propType: 'string',
                          setter: {
                            componentName: 'SelectSetter',
                            mode: 'single',
                            defaultValue: 'single',
                            props: {
                              options: [
                                {
                                  title: '输入框',
                                  value: 'text',
                                },
                                {
                                  title: '搜索框',
                                  value: 'search',
                                },
                                {
                                  title: '数字输入框',
                                  value: 'number',
                                },
                                {
                                  title: '数字范围输入框',
                                  value: 'numberRange',
                                },
                                {
                                  title: '下拉选择框',
                                  value: 'select',
                                },
                                {
                                  title: '日期选择器',
                                  value: 'date',
                                },
                                {
                                  title: '日期范围选择器',
                                  value: 'rangePicker',
                                },
                                {
                                  title: '旧版日期范围选择器',
                                  value: 'oldRangePicker',
                                },
                                {
                                  title: '树选择',
                                  value: 'treeSelect',
                                },
                              ],
                            },
                          },
                        },
                        {
                          name: 'sort',
                          title: {
                            label: '开启排序',
                            tip: '开启字段排序可以对顺序及字段隐藏调整,关闭时筛选项只在最外层展示',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'localFilter',
                          title: {
                            label: '开启本地筛选',
                            tip: '开启本地筛选时，字段值改变会走本地前端搜索，关闭时是调用接口对数据更新。',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'isHidden',
                          title: {
                            label: '是否隐藏',
                            tip: '开启时，当前项展示， 关闭时，当前项隐藏',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'other',
                          title: {
                            label: '其他拓展属性',
                            tip: '其他拓展属性',
                          },
                          propType: 'object',
                          setter: 'JsonSetter',
                        },
                      ],
                    },
                  },
                  initialValue: {
                    label: '标题',
                    type: 'text',
                    key: 'name',
                    columnKey: '',
                    isCustom: false,
                    isHidden: false,
                  },
                },
              },
            },
          },
        ],
      },
      {
        title: { label: '排序', tip: '表格的排序项' },
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'sort.show',
            title: { label: '开启排序', tip: '开启排序' },
            propType: 'object',
            setter: 'BoolSetter',
            defaultValue: true,
          },
          {
            name: 'sort.storageMode',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("sort.show")',
            },
            title: {
              label: '存储模式',
              tip: 'filter.storageMode | 排序存储模式 关闭时刷新页面还原',
            },
            propType: 'string',
            setter: {
              componentName: 'SelectSetter',
              mode: 'single',
              defaultValue: 'localStorage',
              props: {
                options: [
                  {
                    title: '关闭',
                    value: '',
                  },
                  {
                    title: '本地localStorage',
                    value: 'localStorage',
                  },
                ],
              },
            },
          },
          {
            name: 'sort.list',
            condition: {
              type: 'JSFunction',
              value: 'target => !!target.getProps().getPropValue("sort.show")',
            },
            setter: {
              componentName: 'ArraySetter',
              props: {
                itemSetter: {
                  componentName: 'ObjectSetter',
                  props: {
                    config: {
                      items: [
                        {
                          name: 'isCustom',
                          title: {
                            label: '开启定制字段',
                            tip: '开启定制字段，可自定义排序名和排序的key，关闭时可选择column中的title和dataIndex',
                          },
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'columnKey',
                          title: {
                            label: '选择字段',
                            tip: '选择column中的title和dataIndex字段进行排序',
                          },
                          isRequired: true,
                          condition(target: any) {
                            return !target.parent.getPropValue('isCustom');
                          },
                          setter: [
                            {
                              componentName: 'SelectSetter',
                              mode: 'single',
                              props: (target: any) => {
                                const fieldsKey = target.parent.parent.parent
                                  .getPropValue('sort.list')
                                  .map((item: any) => item?.columnKey)
                                  .filter(Boolean);
                                return {
                                  options:
                                    target.parent.parent.parent
                                      .getPropValue('columns')
                                      ?.map?.((item: any) => ({
                                        title: getI18n(item.title) || item.key,
                                        value: item.key,
                                        disabled: fieldsKey.includes(item.key),
                                      })) || [],
                                };
                              },
                            },
                            'StringSetter',
                          ],
                        },
                        {
                          name: 'localFilter',
                          title: {
                            label: '开启本地排序',
                            tip: '开启本地排序时，排序改变会走本地前端排序，关闭时是调用接口对数据更新。',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: true,
                        },
                        {
                          name: 'label',
                          title: { label: '排序项', tip: '排序项展示文案' },
                          propType: 'string',
                          setter: 'PisellI18nSetter',
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'name',
                          title: { label: '字段', tip: '所排序的字段' },
                          setter: [
                            {
                              componentName: 'SelectSetter',
                              mode: 'single',
                              props: (target: any) => {
                                return {
                                  options:
                                    target.parent.parent.parent
                                      .getPropValue('columns')
                                      ?.map?.((item: any) => ({
                                        title:
                                          typeof item.title === 'string'
                                            ? item.title
                                            : item.key,
                                        value: item.dataIndex,
                                      })) || [],
                                };
                              },
                            },
                            'StringSetter',
                            {
                              componentName: 'ArraySetter',
                              props: {
                                itemSetter: {
                                  componentName: 'StringSetter',
                                },
                              },
                            },
                          ],
                          condition(target: any) {
                            return target.parent.getPropValue('isCustom');
                          },
                        },
                        {
                          name: 'isHidden',
                          title: {
                            label: '是否隐藏',
                            tip: '开启时，当前项展示， 关闭时，当前项隐藏',
                          },
                          propType: 'bool',
                          setter: 'BoolSetter',
                          defaultValue: false,
                        },
                        {
                          name: 'type',
                          title: { label: '字段类型', tip: '所排序的字段类型' },
                          propType: 'string',
                          isRequired: true,
                          setter: {
                            componentName: 'SelectSetter',
                            mode: 'single',
                            defaultValue: 'single',
                            props: {
                              options: [
                                {
                                  title: '日期排序',
                                  value: 'date',
                                },
                                {
                                  title: '数字排序',
                                  value: 'number',
                                },
                                {
                                  title: 'a-z排序',
                                  value: 'string',
                                },
                              ],
                            },
                          },
                        },
                      ],
                    },
                  },
                  initialValue: {
                    label: '标题',
                    type: 'date',
                    columnKey: '',
                    isCustom: false,
                    isHidden: false,
                  },
                },
              },
            },
          },
        ],
      },
      {
        title: { label: '导入导出', tip: '表单的导入导出' },
        display: 'block',
        type: 'group',
        items: [
          {
            name: 'exportImport.show',
            title: { label: '开启导入导出', tip: '开启表单的导入导出' },
            propType: 'bool',
            setter: 'BoolSetter',
            defaultValue: false,
          },
          {
            name: 'exportImport.hiddenKeys',
            title: {
              label: '隐藏字段',
              tip: "比如：['import'] '导入(import)|导出(export)|导出文件(export_file)|导入日志(import_log)'",
            },
            setter: 'ObjectSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
          {
            name: 'exportImport.apiUrl',
            title: {
              label: '接口地址',
              tip: "接口地址 | [{export: '/shop/order/task'}]",
            },
            setter: 'ObjectSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
          // {
          //   name: "exportImport.formId",
          //   title: { label: "表单ID", tip: "表单ID" },
          //   propType: "string",
          //   setter: "StringSetter",
          //   condition: {
          //     type: "JSFunction",
          //     value: 'target => !!target.getProps().getPropValue("exportImport.show")',
          //   },
          // },
          // {
          //   name: "exportImport.formCode",
          //   title: { label: "表单Code", tip: "表单Code｜表单的唯一标识" },
          //   propType: "string",
          //   setter: "StringSetter",
          //   condition: {
          //     type: "JSFunction",
          //     value: 'target => !!target.getProps().getPropValue("exportImport.show")',
          //   },
          // },
          {
            name: 'exportImport.otherParams',
            title: { label: '接口其他参数', tip: '接口其他参数' },
            setter: 'ObjectSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
          {
            name: 'exportImport.title',
            title: { label: '标题', tip: '打开弹窗的标题' },
            propType: 'string',
            setter: 'PisellI18nSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
          {
            name: 'exportImport.templateFileUrl',
            title: { label: '导入模版链接', tip: '导入模版链接' },
            propType: 'string',
            setter: 'StringSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
          {
            name: 'exportImport.selectLists',
            title: {
              label: '当前所选项',
              tip: '当前所选择的需要导出的哪些数据',
            },
            setter: 'ObjectSetter',
            condition: {
              type: 'JSFunction',
              value:
                'target => !!target.getProps().getPropValue("exportImport.show")',
            },
          },
        ],
      },
      {
        name: 'buttons',
        title: { label: '标题按钮组', tip: '标题右侧按钮项' },
        setter: {
          componentName: 'ArraySetter',
          props: {
            itemSetter: {
              componentName: 'ObjectSetter',
              props: {
                config: {
                  items: [
                    {
                      name: 'title',
                      title: { label: '按钮名称', tip: '按钮名称' },
                      propType: 'string',
                      setter: 'PisellI18nSetter',
                      isRequired: true,
                    },
                    ...button.configure.props,
                    {
                      name: 'onClick',
                      title: { label: '点击事件', tip: '点击事件' },
                      propType: 'func',
                    },
                    {
                      name: 'action',
                      title: { label: '功能', tip: '按钮的功能' },
                      propType: 'string',
                      setter: [
                        {
                          componentName: 'SelectSetter',
                          mode: 'single',
                          defaultValue: 'add',
                          props: {
                            options: [
                              {
                                title: 'Add',
                                value: 'add',
                              },
                              {
                                title: 'Reset',
                                value: 'reset',
                              },
                            ],
                          },
                        },
                      ],
                    },

                    {
                      name: 'other',
                      title: {
                        label: '其他拓展属性',
                        tip: '其他拓展属性',
                      },
                      propType: 'object',
                      setter: 'JsonSetter',
                    },
                  ],
                },
              },
              initialValue: { title: '按钮' },
            },
          },
        },
      },
      {
        name: 'actionButtons',
        title: { label: '表格按钮组', tip: '表格action右侧按钮项' },
        setter: {
          componentName: 'ArraySetter',
          props: {
            itemSetter: {
              componentName: 'ObjectSetter',
              props: {
                config: {
                  items: [
                    {
                      name: 'title',
                      title: { label: '按钮名称', tip: '按钮名称' },
                      propType: 'string',
                      setter: 'PisellI18nSetter',
                      isRequired: true,
                    },
                    ...button.configure.props,
                    {
                      name: 'onClick',
                      title: { label: '点击事件', tip: '点击事件' },
                      propType: 'func',
                    },
                    {
                      name: 'action',
                      title: { label: '功能', tip: '按钮的功能' },
                      propType: 'string',
                      setter: [
                        {
                          componentName: 'SelectSetter',
                          mode: 'single',
                          defaultValue: 'add',
                          props: {
                            options: [
                              {
                                title: 'Add',
                                value: 'add',
                              },
                              {
                                title: 'Reset',
                                value: 'reset',
                              },
                            ],
                          },
                        },
                      ],
                    },

                    {
                      name: 'other',
                      title: {
                        label: '其他拓展属性',
                        tip: '其他拓展属性',
                      },
                      propType: 'object',
                      setter: 'JsonSetter',
                    },
                  ],
                },
              },
              initialValue: { title: '按钮' },
            },
          },
        },
      },
    ] as IPublicTypeFieldConfig[],
    supports: {
      style: true,
      events: [
        {
          name: 'onChange',
          template:
            "onChange(pagination,filters,sorter,extra,${extParams}){\n// 表格翻页事件\nconsole.log('onChange', pagination);}",
        },
        {
          name: 'onSortChange',
          template:
            "onSortChange(detail){\n// 表格拖拽排序事件\nconsole.log('detail', detail);}",
        },
        {
          name: 'onValuesChange',
          template: 'onValuesChange(changedValues, values){}',
        },
        {
          name: 'onDataSourceChange',
          template: 'onDataSourceChange(currentDataSource) {}',
        },
        {
          name: 'rowSelection.onChange',
          template:
            "onRowSelectionChange(selectedRowKeys,selectedRows,${extParams}){\n// 选中项发生变化时的回调\nconsole.log('onRowSelectionChange', selectedRowKeys, selectedRows);}",
        },
        {
          name: 'expandable.onExpand',
          template:
            "onExpandableExpand(expanded,record){\n// 点击展开图标时触发\nconsole.log('onRowSelectionChange', expanded, record);}",
        },
        {
          name: 'onExportChange',
          template:
            "onExportChange(expanded,record){\n// 点击展开图标时触发\nconsole.log('onExport', expanded, record);}",
        },
        {
          name: 'onImportChange',
          template:
            "onImportChange(expanded,record){\n// 点击展开图标时触发\nconsole.log('onExport', expanded, record);}",
        },
        {
          name: 'onExportFileChange',
          template:
            "onExportFileChange(expanded,record){\n// 点击展开图标时触发\nconsole.log('onExport', expanded, record);}",
        },
        {
          name: 'onImportLogChange',
          template:
            "onImportLogChange(expanded,record){\n// 点击展开图标时触发\nconsole.log('onExport', expanded, record);}",
        },
      ],
    },
  },
};

export default dataSourceTable;