@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.46

package/src/flow/models/blocks/form/__tests__/FormItemModel.defineChildren.test.ts

@@ -12,7 +12,7 @@ import { FlowEngine, type FlowModelContext, type SubModelItem } from '@nocobase/
 // Import from the aggregate to preserve the model initialization order used by adjacent tests.
 import { FormItemModel, FormJSFieldItemModel, InputFieldModel, JSEditableFieldModel } from '../../../..';
 
-function createFormMenuContext(prefixFieldPath = 'roles') {
+function createFormMenuContext(prefixFieldPath = 'roles', collectionName = 'roles') {
   const engine = new FlowEngine();
   engine.registerModels({
     FormItemModel,
@@ -36,15 +36,29 @@ function createFormMenuContext(prefixFieldPath = 'roles') {
     fields: [
       { name: 'id', type: 'integer', interface: 'number', title: 'ID' },
       { name: 'name', type: 'string', interface: 'input', title: 'Name' },
+      { name: 'department', type: 'belongsTo', interface: 'm2o', target: 'departments', title: 'Department' },
     ],
   });
+  dataSource.addCollection({
+    name: 'departments',
+    filterTargetKey: 'id',
+    fields: [
+      { name: 'name', type: 'string', interface: 'input', title: 'Name' },
+      { name: 'company', type: 'belongsTo', interface: 'm2o', target: 'companies', title: 'Company' },
+    ],
+  });
+  dataSource.addCollection({
+    name: 'companies',
+    filterTargetKey: 'id',
+    fields: [{ name: 'name', type: 'string', interface: 'input', title: 'Name' }],
+  });
 
   const blockModel = engine.createModel({ use: 'FlowModel', uid: 'users-form-block' });
   (blockModel as any).collection = dataSource.getCollection('users');
 
   const gridModel = engine.createModel({ use: 'FlowModel', uid: 'users-form-grid' });
   gridModel.context.defineProperty('blockModel', { value: blockModel });
-  gridModel.context.defineProperty('collection', { value: dataSource.getCollection('roles') });
+  gridModel.context.defineProperty('collection', { value: dataSource.getCollection(collectionName) });
   gridModel.context.defineProperty('prefixFieldPath', { value: prefixFieldPath });
 
   return gridModel.context as FlowModelContext;
@@ -105,4 +119,15 @@ describe('FormItemModel defineChildren', () => {
 
     expect((jsNameItem?.toggleable as (model: any) => boolean)(createModelLike(normalCreateOptions))).toBe(true);
   });
+
+  it('hides association fields after two association levels in form add-field menus', async () => {
+    const ctx = createFormMenuContext('roles.department', 'departments');
+    const formItems = FormItemModel.defineChildren(ctx) as SubModelItem[];
+    const jsItems = (await FormJSFieldItemModel.defineChildren(ctx)) as SubModelItem[];
+
+    expect(formItems.map((item) => item.key)).toContain('roles.department.name');
+    expect(formItems.map((item) => item.key)).not.toContain('roles.department.company');
+    expect(jsItems.map((item) => item.key)).toContain('roles.department.name');
+    expect(jsItems.map((item) => item.key)).not.toContain('roles.department.company');
+  });
 });

package/src/flow/models/blocks/form/__tests__/submitHandler.test.ts

@@ -0,0 +1,71 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { SingleRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it, vi } from 'vitest';
+import { submitHandler } from '../submitHandler';
+
+describe('submitHandler', () => {
+  it('merges assigned values into submitted values and lets assigned values override form values', async () => {
+    const resource = Object.create(SingleRecordResource.prototype);
+    resource.save = vi.fn(async () => ({ data: { id: 1 } }));
+
+    const blockModel = {
+      form: {
+        validateFields: vi.fn(async () => undefined),
+        getFieldsValue: vi.fn(() => ({
+          title: 'Draft title',
+          status: 'draft',
+        })),
+        resetFields: vi.fn(),
+      },
+      emitter: {
+        emit: vi.fn(),
+      },
+      resetUserModifiedFields: vi.fn(),
+      formValueRuntime: {
+        resetAfterFormReset: vi.fn(),
+      },
+      collection: {
+        name: 'posts',
+      },
+    };
+
+    const ctx = {
+      resource,
+      blockModel,
+      model: {
+        getStepParams: vi.fn(),
+      },
+      view: {
+        inputArgs: {},
+      },
+      message: {
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+
+    await submitHandler(ctx, {
+      assignedValues: {
+        status: 'published',
+        reviewer: 'Alice',
+      },
+    });
+
+    expect(resource.save).toHaveBeenCalledWith(
+      {
+        title: 'Draft title',
+        status: 'published',
+        reviewer: 'Alice',
+      },
+      undefined,
+    );
+  });
+});

package/src/flow/models/blocks/form/submitHandler.ts

@@ -8,6 +8,7 @@
  */
 
 import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import { mergeAssignFieldValues, resolveAssignFieldValues } from '../assign-form/assignFieldValuesFlow';
 import type { FormBlockModel } from './FormBlockModel';
 import { omitHiddenModelValuesFromSubmit, shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
@@ -24,7 +25,13 @@ export async function submitHandler(ctx, params, cb?: (values?: any, filterByTk?
     skipValidator: shouldSkipSubmitValidation(ctx?.model),
   });
   const rawValues = blockModel.form.getFieldsValue(true);
-  const values = omitHiddenModelValuesFromSubmit(rawValues, blockModel);
+  const formValues = omitHiddenModelValuesFromSubmit(rawValues, blockModel);
+  const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'FormSubmitAction');
+  if (!assignedValues) {
+    ctx.exit?.();
+    return;
+  }
+  const values = mergeAssignFieldValues(formValues, assignedValues);
   if (resource instanceof SingleRecordResource) {
     if (isEditFormModel) {
       const currentFilterByTk = resource.getMeta('currentFilterByTk');

package/src/flow/models/blocks/form/submitValues.ts

@@ -84,7 +84,10 @@ function forEachModelIncludingForks(engine: any, visitor: (model: any) => void)
 
     const forks: any = model?.forks;
     if (forks && typeof forks.forEach === 'function') {
-      forks.forEach((fork: any) => visitor(fork));
+      forks.forEach((fork: any) => {
+        if (!fork || fork.disposed) return;
+        visitor(fork);
+      });
     }
   });
 }

package/src/flow/models/blocks/form/value-runtime/__tests__/runtime.test.ts

@@ -15,6 +15,7 @@ import { observable } from '@formily/reactive';
 import { get as lodashGet, merge as lodashMerge, set as lodashSet } from 'lodash';
 import { FlowContext, JSRunner } from '@nocobase/flow-engine';
 import { FormValueRuntime } from '..';
+import type { FormInstance } from 'antd';
 
 function createFormStub(initialValues: any = {}) {
   const store: any = JSON.parse(JSON.stringify(initialValues || {}));
@@ -121,6 +122,34 @@ function createFieldContext(runtime: FormValueRuntime) {
 }
 
 describe('FormValueRuntime (default rules)', () => {
+  it('skips object patches when values are unchanged', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({ name: 'old' });
+    const dispatchEvent = vi.fn();
+
+    const blockModel = {
+      uid: 'form-noop-patch',
+      flowEngine: { emitter: engineEmitter },
+      emitter: blockEmitter,
+      dispatchEvent,
+      getAclActionName: () => 'create',
+    } as ConstructorParameters<typeof FormValueRuntime>[0]['model'];
+
+    const runtime = new FormValueRuntime({ model: blockModel, getForm: () => formStub as unknown as FormInstance });
+    runtime.mount({ sync: true });
+
+    const blockCtx = createFieldContext(runtime);
+    await runtime.setFormValues(blockCtx, { name: 'old' }, { source: 'system' });
+
+    expect(dispatchEvent).not.toHaveBeenCalled();
+
+    await runtime.setFormValues(blockCtx, { name: 'new' }, { source: 'system' });
+
+    expect(formStub.getFieldValue(['name'])).toBe('new');
+    expect(dispatchEvent).toHaveBeenCalledTimes(1);
+  });
+
   it('recomputes default on dependency change when current equals last default; user change disables default permanently', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();

package/src/flow/models/blocks/form/value-runtime/runtime.ts

@@ -846,7 +846,11 @@ export class FormValueRuntime {
       const changedPaths: NamePath[] = [];
 
       if (!Array.isArray(patch)) {
-        const patchEntries = Object.entries(patch || {}).filter(([pathKey]) => !shouldSkipByLinkageScope(pathKey));
+        const patchEntries = Object.entries(patch || {}).filter(([pathKey, rawValue]) => {
+          if (shouldSkipByLinkageScope(pathKey)) return false;
+          const value = isObservable(rawValue) ? toJS(rawValue) : rawValue;
+          return !_.isEqual(this.getFormValueAtPath([pathKey]), value);
+        });
         const patchToApply = Object.fromEntries(patchEntries);
         const patchKeys = patchEntries.map(([pathKey]) => pathKey);
         if (!patchKeys.length) {

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -39,6 +39,7 @@ import { TableColumnModel } from './TableColumnModel';
 import { extractIndex, adjustColumnOrder, setNestedValue, extractIds, getRowKey, useBlockHeight } from './utils';
 import { resolveTableSorterField } from './sortUtils';
 import { commonConditionHandler, ConditionBuilder } from '../../../components/ConditionBuilder';
+import { BulkDeleteActionModel } from '../../actions/BulkDeleteActionModel';
 import {
   applyMobilePaginationProps,
   createCompactSimpleItemRender,
@@ -128,6 +129,18 @@ const rowSelectCheckboxWrapperNoIndexClass = css`
   }
 `;
 
+const leftAuxiliaryColumnCellClass = css`
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 22px;
+`;
+
+const leftAuxiliaryColumnCellWithHandleClass = css`
+  padding-left: 24px;
+`;
+
 const highlightedRowClass = css`
   & td {
     background-color: #e6f7ff !important;
@@ -382,21 +395,76 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
     },
   };
 
-  renderCell = (checked, record, index, originNode) => {
-    if (!this.props.dragSort && !this.props.showIndex) {
-      return originNode;
-    }
-    const current = this.resource.getPage();
+  isRowSelectionEnabled() {
+    return this.props.enableRowSelection !== false;
+  }
+
+  isShowIndexEnabled() {
+    return this.props.showIndex !== false;
+  }
 
+  getRecordIndex(record: Record<string, unknown>, index: number) {
+    let nextIndex = index;
+    const current = this.resource.getPage();
     const pageSize = this.resource.getPageSize() || 20;
     if (current) {
-      index = index + (current - 1) * pageSize + 1;
+      nextIndex = nextIndex + (current - 1) * pageSize + 1;
     } else {
-      index = index + 1;
+      nextIndex = nextIndex + 1;
     }
-    if (record.__index) {
-      index = extractIndex(record.__index);
+    const treeIndex = record?.__index;
+    if (treeIndex) {
+      return extractIndex(treeIndex);
     }
+    return nextIndex;
+  }
+
+  getLeftAuxiliaryColumn() {
+    const showIndex = this.isShowIndexEnabled();
+    const showDragHandle = this.props.dragSort && this.props.dragSortBy;
+    if (!showIndex && !showDragHandle) {
+      return null;
+    }
+
+    return {
+      key: '__rowSelectionDisabledAuxiliary__',
+      width: showDragHandle ? 74 : 50,
+      align: 'center' as const,
+      render: (_value: unknown, record: Record<string, unknown>, index: number) => {
+        const displayIndex = this.getRecordIndex(record, index);
+        const rowKey = getRowKey(record, this.collection.filterTargetKey);
+        const rowKeyString = rowKey == null ? rowKey : String(rowKey);
+        return (
+          <div
+            className={classNames(leftAuxiliaryColumnCellClass, {
+              [leftAuxiliaryColumnCellWithHandleClass]: showDragHandle,
+            })}
+          >
+            {showDragHandle && (
+              <SortHandle
+                id={rowKeyString}
+                style={{
+                  position: 'absolute',
+                  left: 0,
+                  top: '50%',
+                  justifyContent: 'center',
+                  transform: 'translateY(-50%)',
+                }}
+              />
+            )}
+            {showIndex && <TableIndex index={displayIndex} aria-label={`table-index-${displayIndex}`} />}
+          </div>
+        );
+      },
+    };
+  }
+
+  renderCell = (checked, record, index, originNode) => {
+    const showIndex = this.isShowIndexEnabled();
+    if (!this.props.dragSort && !showIndex) {
+      return originNode;
+    }
+    index = this.getRecordIndex(record, index);
     const rowKey = getRowKey(record, this.collection.filterTargetKey);
     const rowKeyString = rowKey == null ? rowKey : String(rowKey);
     const showDragHandle = this.props.dragSort && this.props.dragSortBy;
@@ -406,7 +474,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
         aria-label={`table-index-${index}`}
         className={classNames(checked ? 'checked' : null, rowSelectCheckboxWrapperClass, {
           [rowSelectCheckboxWrapperClassHover]: true,
-          [rowSelectCheckboxWrapperNoIndexClass]: !this.props.showIndex,
+          [rowSelectCheckboxWrapperNoIndexClass]: !showIndex,
         })}
       >
         {showDragHandle && (
@@ -422,7 +490,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
           />
         )}
         <div className={classNames(checked ? 'checked' : null, rowSelectCheckboxContentClass)}>
-          {this.props.showIndex && <TableIndex index={index} />}
+          {showIndex && <TableIndex index={index} />}
         </div>
 
         <div className={classNames('nb-origin-node', checked ? 'checked' : null, rowSelectCheckboxCheckedClassHover)}>
@@ -445,6 +513,16 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
     );
   }
 
+  shouldRenderAction(action: ActionModel, isConfigMode: boolean) {
+    if (action.hidden && !isConfigMode) {
+      return false;
+    }
+    if (!isConfigMode && !this.isRowSelectionEnabled() && action instanceof BulkDeleteActionModel) {
+      return false;
+    }
+    return true;
+  }
+
   pagination() {
     const totalCount = this.resource.getMeta('count');
     const pageSize = this.resource.getPageSize();
@@ -509,6 +587,9 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
           >
             <Space wrap>
               {this.mapSubModels('actions', (action) => {
+                if (!this.shouldRenderAction(action, isConfigMode)) {
+                  return null;
+                }
                 // @ts-ignore
                 if (action.props.position === 'left') {
                   return (
@@ -527,8 +608,8 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
             </Space>
             <Space wrap>
               {this.mapSubModels('actions', (action) => {
-                if (action.hidden && !isConfigMode) {
-                  return;
+                if (!this.shouldRenderAction(action, isConfigMode)) {
+                  return null;
                 }
                 // @ts-ignore
                 if (action.props.position !== 'left') {
@@ -673,6 +754,20 @@ TableBlockModel.registerFlow({
         });
       },
     },
+    enableRowSelection: {
+      title: tExpr('Enable row selection'),
+      uiMode: { type: 'switch', key: 'enableRowSelection' },
+      defaultParams: {
+        enableRowSelection: true,
+      },
+      handler(ctx, params) {
+        const model = ctx.model as TableBlockModel;
+        model.setProps('enableRowSelection', params.enableRowSelection);
+        if (!params.enableRowSelection) {
+          model.resource.setSelectedRows([]);
+        }
+      },
+    },
     showRowNumbers: {
       title: tExpr('Show row numbers'),
       uiMode: { type: 'switch', key: 'showIndex' },
@@ -875,7 +970,11 @@ const HighPerformanceTable = React.memo(
       [model.collection.filterTargetKey],
     );
 
+    const enableRowSelection = model.isRowSelectionEnabled();
     const rowSelection = useMemo(() => {
+      if (!enableRowSelection) {
+        return undefined;
+      }
       return {
         columnWidth: 50,
         type: 'checkbox',
@@ -887,7 +986,10 @@ const HighPerformanceTable = React.memo(
         renderCell: model.renderCell,
         ...model.rowSelectionProps,
       };
-    }, [model, selectedRowKeys]);
+    }, [enableRowSelection, model, selectedRowKeys]);
+
+    const leftAuxiliaryColumn = enableRowSelection ? null : model.getLeftAuxiliaryColumn();
+    const mergedColumns = leftAuxiliaryColumn ? [leftAuxiliaryColumn, ...columns] : columns;
 
     const handleChange = useCallback(
       async (pagination, filters, sorter) => {
@@ -923,7 +1025,7 @@ const HighPerformanceTable = React.memo(
       [highlightedRowKey, model.collection?.filterTargetKey],
     );
 
-    const pagination = useMemo(() => _pagination, [dataSource]);
+    const pagination = _pagination;
 
     const onRow = useCallback(
       (record, rowIndex) => {
@@ -1029,7 +1131,7 @@ const HighPerformanceTable = React.memo(
         virtual={virtual}
         scroll={tableScroll}
         dataSource={dataSource}
-        columns={columns}
+        columns={mergedColumns}
         pagination={pagination}
         onChange={handleChange}
         rowClassName={rowClassName}

package/src/flow/models/blocks/table/TableColumnModel.tsx

@@ -47,7 +47,7 @@ export function FieldDeletePlaceholder(props: any) {
     const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : '';
     return `${dataSourcePrefix}${collectionPrefix}${name}`;
-  }, []);
+  }, [collection, dataSource.displayName, dataSource.key, name, t]);
   const content = t(`The {{type}} "{{name}}" may have been deleted. Please remove this {{blockType}}.`, {
     type: t('Field'),
     name: nameValue,
@@ -71,7 +71,7 @@ function FieldWithoutPermissionPlaceholder() {
     const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : '';
     return `${dataSourcePrefix}${collectionPrefix}${name}`;
-  }, []);
+  }, [collection, dataSource.displayName, dataSource.key, name, t]);
   const { actionName } = model.forbidden;
   const messageValue = useMemo(() => {
     return t(
@@ -81,7 +81,7 @@ function FieldWithoutPermissionPlaceholder() {
         actionName: t(capitalize(actionName)),
       },
     ).replaceAll('>', '>');
-  }, [nameValue, t]);
+  }, [actionName, nameValue, t]);
   return (
     <Tooltip title={messageValue}>
       <LockOutlined style={{ opacity: '0.3' }} />
@@ -89,6 +89,15 @@ function FieldWithoutPermissionPlaceholder() {
   );
 }
 
+export const TABLE_COLUMN_MIN_WIDTH = 10;
+
+export function normalizeTableColumnWidth(width: number | null | undefined) {
+  if (typeof width === 'number' && width < TABLE_COLUMN_MIN_WIDTH) {
+    return TABLE_COLUMN_MIN_WIDTH;
+  }
+  return width;
+}
+
 export const CustomWidth = ({ setOpen, t, handleChange, defaultValue }) => {
   const [customWidth, setCustomWidth] = useState(defaultValue);
   return (
@@ -104,13 +113,14 @@ export const CustomWidth = ({ setOpen, t, handleChange, defaultValue }) => {
       <Space.Compact block>
         <InputNumber
           placeholder={t('Custom column width')}
+          min={TABLE_COLUMN_MIN_WIDTH}
           value={customWidth}
           onChange={(val) => {
             setCustomWidth(val);
           }}
           style={{ width: '100%', minWidth: 200 }}
         />
-        <Button type="primary" onClick={() => handleChange(customWidth)}>
+        <Button type="primary" onClick={() => handleChange(normalizeTableColumnWidth(customWidth))}>
           OK
         </Button>
       </Space.Compact>
@@ -442,7 +452,7 @@ TableColumnModel.registerFlow({
         width: 150,
       },
       handler(ctx, params) {
-        ctx.model.setProps('width', params.width);
+        ctx.model.setProps('width', normalizeTableColumnWidth(params.width));
       },
     },
     aclCheck: {

package/src/flow/models/blocks/table/TableCustomColumnModel.tsx

@@ -10,7 +10,7 @@
 import { tExpr, FlowModel, ModelRenderMode } from '@nocobase/flow-engine';
 import { Divider } from 'antd';
 import React from 'react';
-import { CustomWidth } from './TableColumnModel';
+import { CustomWidth, normalizeTableColumnWidth } from './TableColumnModel';
 export class TableCustomColumnModel extends FlowModel {
   static renderMode: ModelRenderMode = ModelRenderMode.RenderFunction;
 }
@@ -100,7 +100,7 @@ TableCustomColumnModel.registerFlow({
         width: 150,
       },
       handler(ctx, params) {
-        ctx.model.setProps('width', params.width);
+        ctx.model.setProps('width', normalizeTableColumnWidth(params.width));
       },
     },
     fixed: {

package/src/flow/models/blocks/table/__tests__/TableBlockModel.rowSelection.test.tsx

@@ -0,0 +1,114 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { render, screen } from '@testing-library/react';
+import { FlowEngine } from '@nocobase/flow-engine';
+import '@nocobase/client';
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import { BulkDeleteActionModel } from '../../../actions/BulkDeleteActionModel';
+import { TableBlockModel } from '../TableBlockModel';
+
+function createTableModel() {
+  const engine = new FlowEngine();
+  engine.registerModels({ TableBlockModel });
+
+  const ds = engine.dataSourceManager.getDataSource('main');
+  ds.addCollection({
+    name: 'posts',
+    filterTargetKey: 'id',
+    fields: [
+      { name: 'id', type: 'integer', interface: 'number' },
+      { name: 'title', type: 'string', interface: 'input' },
+    ],
+  });
+
+  return engine.createModel<TableBlockModel>({
+    uid: 'posts-table',
+    use: 'TableBlockModel',
+    stepParams: {
+      resourceSettings: {
+        init: {
+          dataSourceKey: 'main',
+          collectionName: 'posts',
+        },
+      },
+    },
+  });
+}
+
+describe('TableBlockModel row selection setting', () => {
+  it('keeps row selection enabled by default', () => {
+    const model = createTableModel();
+
+    expect(model.isRowSelectionEnabled()).toBe(true);
+
+    model.setProps('enableRowSelection', false);
+
+    expect(model.isRowSelectionEnabled()).toBe(false);
+  });
+
+  it('builds a standalone row-number column when row selection is disabled', () => {
+    const model = createTableModel();
+    model.resource.setPage(2);
+    model.resource.setPageSize(20);
+    model.setProps('enableRowSelection', false);
+    model.setProps('showIndex', true);
+
+    const column = model.getLeftAuxiliaryColumn();
+
+    expect(column).toMatchObject({
+      key: '__rowSelectionDisabledAuxiliary__',
+      width: 50,
+      align: 'center',
+    });
+
+    render(<>{column?.render(null, { id: 1, title: 'first post' }, 1)}</>);
+
+    expect(screen.getByLabelText('table-index-22').textContent).toBe('22');
+  });
+
+  it('omits the standalone column when row selection and row numbers are both disabled', () => {
+    const model = createTableModel();
+    model.setProps('enableRowSelection', false);
+    model.setProps('showIndex', false);
+
+    expect(model.getLeftAuxiliaryColumn()).toBeNull();
+  });
+
+  it('keeps a standalone drag handle column without row selection checkboxes', () => {
+    const model = createTableModel();
+    model.setProps('enableRowSelection', false);
+    model.setProps('showIndex', false);
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+
+    expect(model.getLeftAuxiliaryColumn()).toMatchObject({
+      key: '__rowSelectionDisabledAuxiliary__',
+      width: 74,
+      align: 'center',
+    });
+  });
+
+  it('hides bulk delete in runtime when row selection is disabled', () => {
+    const model = createTableModel();
+    const bulkDelete = new BulkDeleteActionModel({
+      uid: 'bulk-delete',
+      use: 'BulkDeleteActionModel',
+      flowEngine: model.flowEngine,
+    });
+
+    expect(model.shouldRenderAction(bulkDelete, false)).toBe(true);
+
+    model.setProps('enableRowSelection', false);
+
+    expect(model.shouldRenderAction(bulkDelete, false)).toBe(false);
+    expect(model.shouldRenderAction(bulkDelete, true)).toBe(true);
+  });
+});

package/src/flow/models/blocks/table/__tests__/TableColumnModel.test.tsx

@@ -12,6 +12,24 @@ import { describe, expect, it, vi } from 'vitest';
 import { TableColumnModel } from '../TableColumnModel';
 
 describe('TableColumnModel sorter settings', () => {
+  it('clamps custom column width to the minimum value', () => {
+    const engine = new FlowEngine();
+    const model = new TableColumnModel({ uid: 'table-column-min-width', flowEngine: engine } as any);
+    const widthStep = model.getFlow('tableColumnSettings')?.steps?.width as any;
+    const setProps = vi.fn();
+
+    widthStep.handler(
+      {
+        model: {
+          setProps,
+        },
+      },
+      { width: 0 },
+    );
+
+    expect(setProps).toHaveBeenCalledWith('width', 10);
+  });
+
   it('hides quick edit setting for relation path columns added from association groups', async () => {
     const engine = new FlowEngine();
     const model = new TableColumnModel({ uid: 'table-column-relation-path-quick-edit', flowEngine: engine } as any);