@nocobase/client-v2 2.2.0-beta.7 → 2.2.0-beta.8

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

@@ -13,7 +13,7 @@ import { App, ConfigProvider } from 'antd';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
 import { ActionModel } from '../../../base/ActionModel';
-import { TableActionsColumnModel } from '../TableActionsColumnModel';
+import { TableActionsColumnModel, tableRowActionsClassName } from '../TableActionsColumnModel';
 
 const capturedDroppableUids: string[] = [];
 const capturedRendererProps: any[] = [];
@@ -77,6 +77,10 @@ class TestAlwaysActionModel extends ActionModel {
   defaultProps: any = { type: 'link', title: 'Always' };
 }
 
+class TestTextActionModel extends ActionModel {
+  defaultProps: any = { type: 'text', title: 'Text action' };
+}
+
 // 在 beforeRender 中，根据 inputArgs（即当前行 record）决定是否隐藏按钮
 TestViewActionModel.registerFlow({
   key: 'autoHideByPhone',
@@ -174,6 +178,58 @@ describe('TableActionsColumnModel: hidden action layout', () => {
     expect(wrappers).toHaveLength(0);
     expect(secondUid).toBeTruthy();
   });
+
+  it('renders row link and text actions with compact button styles', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ TableActionsColumnModel, TestViewActionModel, TestTextActionModel });
+
+    const actionsCol = engine.createModel<TableActionsColumnModel>({
+      use: 'TableActionsColumnModel',
+      props: { width: 200, title: 'Actions' },
+      subModels: { actions: [{ use: 'TestViewActionModel' }, { use: 'TestTextActionModel' }] },
+    });
+
+    const colProps = actionsCol.getColumnProps();
+    const record = { id: 1, phone: '000000' } as any;
+
+    const { container } = render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>{colProps.render?.(undefined, record, 0) as any}</App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('View')).toBeInTheDocument();
+      expect(screen.getByText('Text action')).toBeInTheDocument();
+    });
+
+    const actions = container.querySelector('.nb-table-row-actions');
+    expect(actions).toBeInTheDocument();
+    expect(actions).toHaveClass(tableRowActionsClassName);
+
+    const linkButton = actions?.querySelector('.ant-btn-link') as HTMLButtonElement;
+    const textButton = actions?.querySelector('.ant-btn-text') as HTMLButtonElement;
+
+    expect(linkButton).toBeInTheDocument();
+    expect(textButton).toBeInTheDocument();
+    expect(linkButton).toHaveClass('nb-table-row-action-button');
+    expect(textButton).toHaveClass('nb-table-row-action-button');
+
+    const actionButtonStyleText = Array.from(document.querySelectorAll('style'))
+      .map((style) => style.textContent || '')
+      .find((styleText) => styleText.includes('.nb-table-row-action-button.ant-btn-link'));
+    expect(actionButtonStyleText).toContain(tableRowActionsClassName);
+    expect(actionButtonStyleText).toContain('font:inherit');
+    expect(actionButtonStyleText).toContain('height:auto');
+    expect(actionButtonStyleText).toContain('line-height:inherit');
+    expect(actionButtonStyleText).toContain('padding:0');
+    expect(actionButtonStyleText).toContain('border:0');
+    expect(actionButtonStyleText).toContain('box-shadow:none');
+    expect(actionButtonStyleText).not.toContain('1.5714285714285714');
+    expect(actionButtonStyleText).not.toContain('!important');
+  });
 });
 
 describe('TableActionsColumnModel: drag integration', () => {

package/src/flow/models/blocks/table/__tests__/TableBlockModel.dragSort.test.ts

@@ -0,0 +1,127 @@
+/**
+ * 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 { FlowEngine } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import '@nocobase/client';
+import { initDragSortParams } from '../dragSort';
+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' },
+      { name: 'sort', type: 'sort', interface: 'sort' },
+    ],
+  });
+
+  return engine.createModel<TableBlockModel>({
+    uid: 'posts-table',
+    use: 'TableBlockModel',
+    stepParams: {
+      resourceSettings: {
+        init: {
+          dataSourceKey: 'main',
+          collectionName: 'posts',
+        },
+      },
+    },
+  });
+}
+
+describe('TableBlockModel drag sorting settings', () => {
+  it('does not keep a deleted drag sort field in resource sort', () => {
+    const model = createTableModel();
+
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+    model.setProps('globalSort', ['title']);
+    model.resource.setSort(['sort']);
+    model.collection.fields.delete('sort');
+
+    initDragSortParams(model);
+
+    expect(model.getDragSortFieldName()).toBeUndefined();
+    expect(model.resource.getSort()).toEqual(['title']);
+  });
+
+  it('hides the drag handle when the configured sort field was deleted', () => {
+    const model = createTableModel();
+
+    model.setProps('enableRowSelection', false);
+    model.setProps('showIndex', false);
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+    model.collection.fields.delete('sort');
+
+    expect(model.getLeftAuxiliaryColumn()).toBeNull();
+  });
+
+  it('allows clearing the configured drag sort field and restores default sorting', () => {
+    const model = createTableModel();
+    const dragSortByStep = model.getFlow('tableSettings')?.steps?.dragSortBy;
+
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+    model.setProps('globalSort', ['title']);
+    model.resource.setSort(['sort']);
+
+    const uiMode =
+      typeof dragSortByStep?.uiMode === 'function' ? dragSortByStep.uiMode({ model, t: (key: string) => key }) : null;
+    dragSortByStep?.handler({ model }, { dragSortBy: null });
+
+    expect(uiMode).toMatchObject({
+      type: 'select',
+      key: 'dragSortBy',
+      props: {
+        allowClear: true,
+      },
+    });
+    expect(model.props.dragSortBy).toBeNull();
+    expect(model.resource.getSort()).toEqual(['title']);
+  });
+
+  it('ignores a deleted drag sort field submitted by settings', () => {
+    const model = createTableModel();
+    const dragSortByStep = model.getFlow('tableSettings')?.steps?.dragSortBy;
+
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+    model.setProps('globalSort', ['title']);
+    model.resource.setSort(['sort']);
+    model.collection.fields.delete('sort');
+
+    dragSortByStep?.handler({ model }, { dragSortBy: 'sort' });
+
+    expect(model.props.dragSortBy).toBeNull();
+    expect(model.resource.getSort()).toEqual(['title']);
+  });
+
+  it('restores default sorting when drag sorting is disabled', () => {
+    const model = createTableModel();
+    const dragSortStep = model.getFlow('tableSettings')?.steps?.dragSort;
+
+    model.setProps('dragSort', true);
+    model.setProps('dragSortBy', 'sort');
+    model.setProps('globalSort', ['title']);
+    model.resource.setSort(['sort']);
+
+    dragSortStep?.handler({ model }, { dragSort: false });
+
+    expect(model.props.dragSort).toBe(false);
+    expect(model.resource.getSort()).toEqual(['title']);
+  });
+});

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

@@ -26,6 +26,7 @@ function createTableModel() {
     fields: [
       { name: 'id', type: 'integer', interface: 'number' },
       { name: 'title', type: 'string', interface: 'input' },
+      { name: 'sort', type: 'sort', interface: 'sort' },
     ],
   });
 

package/src/flow/models/blocks/table/dragSort/dragSortHooks.tsx

@@ -19,16 +19,23 @@ export function useDragSortBodyWrapper(
   model: TableBlockModel,
   dataSourceRef: React.MutableRefObject<any>,
   getRowKeyFunc: (record: any) => string | number,
+  dragSortFieldName?: string,
 ) {
+  const expandedRowKeys = model.props.expandedRowKeys;
+  const defaultExpandAllRows = model.props.defaultExpandAllRows;
+  const resource = model.resource;
+  const filterTargetKey = model.collection.filterTargetKey;
+  const message = (model as { ctx?: { message?: { error?: (content: string) => void } } }).ctx?.message;
+
   return useMemo(() => {
-    if (!model.props.dragSort) {
+    if (!dragSortFieldName) {
       return (props) => <tbody {...props} />;
     }
 
     const flattenTreeData = (data: any[]) => {
       const result: any[] = [];
-      const expandedKeys = new Set((model.props.expandedRowKeys || []).map((key) => (key == null ? key : String(key))));
-      const includeAll = !!model.props.defaultExpandAllRows;
+      const expandedKeys = new Set((expandedRowKeys || []).map((key) => (key == null ? key : String(key))));
+      const includeAll = !!defaultExpandAllRows;
 
       const walk = (nodes: any[]) => {
         if (!nodes?.length) return;
@@ -73,22 +80,22 @@ export function useDragSortBodyWrapper(
         }
 
         if (from && to) {
-          model.resource
+          resource
             .runAction('move', {
               method: 'post',
               params: {
-                sourceId: getRowKey(from, model.collection.filterTargetKey),
-                targetId: getRowKey(to, model.collection.filterTargetKey),
-                sortField: model.props.dragSort ? model.props.dragSortBy : undefined,
+                sourceId: getRowKey(from, filterTargetKey),
+                targetId: getRowKey(to, filterTargetKey),
+                sortField: dragSortFieldName,
               },
             })
             .then(() => {
-              model.resource.refresh();
+              resource.refresh();
             })
             .catch((error) => {
               console.error('Move failed:', error);
               // Show a user-facing error message if the message system is available
-              (model as any)?.ctx?.message?.error?.(error?.message || 'Move failed');
+              message?.error?.(error?.message || 'Move failed');
             });
         }
       };
@@ -104,13 +111,14 @@ export function useDragSortBodyWrapper(
       );
     };
   }, [
-    model.props.dragSort,
-    model.props.dragSortBy,
-    model.props.expandedRowKeys,
-    model.props.defaultExpandAllRows,
-    model.resource,
-    model.collection.filterTargetKey,
+    dataSourceRef,
+    defaultExpandAllRows,
+    dragSortFieldName,
+    expandedRowKeys,
+    filterTargetKey,
     getRowKeyFunc,
+    message,
+    resource,
   ]);
 }
 
@@ -124,7 +132,10 @@ export function useDragSortRowComponent(dragSort: boolean) {
 }
 
 export function initDragSortParams(model: TableBlockModel) {
-  if (model.props.dragSort && model.props.dragSortBy) {
-    model.resource.setSort([model.props.dragSortBy]);
+  const dragSortFieldName = model.getDragSortFieldName();
+  if (dragSortFieldName) {
+    model.resource.setSort([dragSortFieldName]);
+  } else if (model.props.dragSort && model.props.dragSortBy) {
+    model.resource.setSort(Array.isArray(model.props.globalSort) ? model.props.globalSort : []);
   }
 }

package/src/flow/models/blocks/table/dragSort/dragSortSettings.ts

@@ -9,7 +9,11 @@
 
 import { tExpr } from '@nocobase/flow-engine';
 import type { TableBlockModel } from '../TableBlockModel';
-import { convertFieldsToOptions, getSortFields } from './dragSortUtils';
+import { convertFieldsToOptions, getSortFields, hasSortField } from './dragSortUtils';
+
+function getFallbackSort(model: TableBlockModel): string[] {
+  return Array.isArray(model.props.globalSort) ? model.props.globalSort : [];
+}
 
 export const dragSortSettings = {
   title: tExpr('Enable drag and drop sorting'),
@@ -17,9 +21,12 @@ export const dragSortSettings = {
   defaultParams: {
     dragSort: false,
   },
-  async handler(ctx, params) {
+  handler(ctx, params) {
     const model = ctx.model as TableBlockModel;
     model.setProps('dragSort', params.dragSort);
+    if (!params.dragSort) {
+      model.resource.setSort(getFallbackSort(model));
+    }
 
     // Note: automatic configuration of the drag sort field has been removed;
     // users now configure `dragSortBy` explicitly via `dragSortBySettings`.
@@ -45,6 +52,7 @@ export const dragSortBySettings = {
       key: 'dragSortBy',
       props: {
         options,
+        allowClear: true,
         placeholder: ctx.t('Select field'),
       },
     };
@@ -54,9 +62,8 @@ export const dragSortBySettings = {
   },
   handler(ctx, params) {
     const model = ctx.model as TableBlockModel;
-    model.setProps('dragSortBy', params.dragSortBy);
-    if (params.dragSortBy) {
-      model.resource.setSort([params.dragSortBy]);
-    }
+    const dragSortBy = hasSortField(model.collection, params.dragSortBy) ? params.dragSortBy : null;
+    model.setProps('dragSortBy', dragSortBy);
+    model.resource.setSort(dragSortBy ? [dragSortBy] : getFallbackSort(model));
   },
 };

package/src/flow/models/blocks/table/dragSort/dragSortUtils.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import type { Collection } from '@nocobase/flow-engine';
+import type { Collection, CollectionField } from '@nocobase/flow-engine';
 
 /**
  * 从 collection 中获取所有 sort 类型的字段
@@ -24,6 +24,19 @@ export function getSortFields(collection: Collection | undefined) {
   });
 }
 
+export function getSortField(
+  collection: Collection | undefined,
+  fieldName?: string | null,
+): CollectionField | undefined {
+  if (!collection || !fieldName) return undefined;
+
+  return getSortFields(collection).find((field) => field.name === fieldName);
+}
+
+export function hasSortField(collection: Collection | undefined, fieldName?: string | null): boolean {
+  return !!getSortField(collection, fieldName);
+}
+
 /**
  * 获取 collection 中第一个可用的 sort 字段
  * @param collection - 集合对象
@@ -39,7 +52,7 @@ export function getFirstSortField(collection: Collection | undefined) {
  * @param fields - 字段数组
  * @returns 选项数组
  */
-export function convertFieldsToOptions(fields: any[]) {
+export function convertFieldsToOptions(fields: CollectionField[]) {
   return fields.map((field) => ({
     label: field?.uiSchema?.title || field?.name,
     value: field?.name,

package/src/flow/resolveViewParamsToViewList.tsx

@@ -49,12 +49,12 @@ export function resolveViewParamsToViewList(
   return viewItems;
 }
 
-export function updateViewListHidden(viewItems: ViewItem[]) {
+export function updateViewListHidden(viewItems: ViewItem[], isMobileLayout = false) {
   // Calculate hidden values based on view types and positions
   let hasEmbedAfter = false;
   for (let i = viewItems.length - 1; i >= 0; i--) {
     const viewItem = viewItems[i];
-    const viewType = getViewType(viewItem);
+    const viewType = getViewType(viewItem, isMobileLayout);
 
     if (viewType === 'embed' && !hasEmbedAfter) {
       hasEmbedAfter = true;
@@ -65,15 +65,23 @@ export function updateViewListHidden(viewItems: ViewItem[]) {
   }
 }
 
-function getViewType(viewItem: ViewItem): string {
+function getViewType(viewItem: ViewItem, isMobileLayout = false): string {
   if (viewItem.model instanceof RouteModel) {
     return 'embed';
   }
 
+  if (isMobileLayout && viewItem.index > 0) {
+    return 'embed';
+  }
+
   if (!viewItem.model) {
     return 'drawer';
   }
 
+  if (viewItem.params.openViewRouteState?.mode) {
+    return viewItem.params.openViewRouteState.mode;
+  }
+
   const params = viewItem.model.getStepParams('popupSettings', 'openView');
   return params?.mode || 'drawer';
 }

package/src/settings-center/SystemSettingsPage.tsx

@@ -239,7 +239,7 @@ export const SystemSettingsPage = () => {
         <Form.Item
           name="raw_title"
           label={t('System title')}
-          rules={[{ required: true, message: t('Please enter') + t('System title') }]}
+          rules={[{ required: true, message: t('Please enter') + ' ' + t('System title') }]}
         >
           <Input.TextArea autoSize={{ minRows: 2, maxRows: 4 }} />
         </Form.Item>