@nocobase/client-v2 2.1.31 → 2.2.0-alpha.10

package/src/flow/models/base/__tests__/GridModel.dragSnapshotContainer.test.ts

@@ -10,7 +10,7 @@
 import { FlowEngine } from '@nocobase/flow-engine';
 import React from 'react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { GridModel } from '../GridModel';
+import { GridModel, transformRowsToSingleColumn } from '../GridModel';
 
 const createMockRect = ({ top, left, width, height }: { top: number; left: number; width: number; height: number }) => {
   return {
@@ -66,6 +66,83 @@ const createGridContainer = () => {
   return container;
 };
 
+const createGridContainerWithEmptyColumn = () => {
+  const container = document.createElement('div');
+  container.setAttribute('data-grid-root', '');
+  const row = document.createElement('div');
+  row.setAttribute('data-grid-row-id', 'row-1');
+  container.appendChild(row);
+
+  const firstColumn = document.createElement('div');
+  firstColumn.setAttribute('data-grid-column-row-id', 'row-1');
+  firstColumn.setAttribute('data-grid-column-index', '0');
+  row.appendChild(firstColumn);
+
+  const item = document.createElement('div');
+  item.setAttribute('data-grid-item-row-id', 'row-1');
+  item.setAttribute('data-grid-column-index', '0');
+  item.setAttribute('data-grid-item-index', '0');
+  item.setAttribute('data-grid-item-uid', 'item-1');
+  firstColumn.appendChild(item);
+
+  const secondColumn = document.createElement('div');
+  secondColumn.setAttribute('data-grid-column-row-id', 'row-1');
+  secondColumn.setAttribute('data-grid-column-index', '1');
+  row.appendChild(secondColumn);
+
+  mockRect(container, { top: 0, left: 0, width: 480, height: 280 });
+  mockRect(row, { top: 20, left: 20, width: 440, height: 120 });
+  mockRect(firstColumn, { top: 20, left: 20, width: 220, height: 120 });
+  mockRect(item, { top: 30, left: 30, width: 200, height: 100 });
+  mockRect(secondColumn, { top: 20, left: 260, width: 200, height: 120 });
+  return container;
+};
+
+const createProjectedMobileGridContainer = (rows: Record<string, string[][]>) => {
+  const container = document.createElement('div');
+  container.setAttribute('data-grid-root', '');
+  mockRect(container, { top: 0, left: 0, width: 480, height: 320 });
+
+  let top = 20;
+  Object.entries(transformRowsToSingleColumn(rows)).forEach(([rowId, columns]) => {
+    const row = document.createElement('div');
+    row.setAttribute('data-grid-row-id', rowId);
+    container.appendChild(row);
+
+    const column = document.createElement('div');
+    column.setAttribute('data-grid-column-row-id', rowId);
+    column.setAttribute('data-grid-column-index', '0');
+    row.appendChild(column);
+
+    const items = columns[0] || [];
+    items.forEach((itemUid, itemIndex) => {
+      const item = document.createElement('div');
+      item.setAttribute('data-grid-item-row-id', rowId);
+      item.setAttribute('data-grid-column-index', '0');
+      item.setAttribute('data-grid-item-index', String(itemIndex));
+      item.setAttribute('data-grid-item-uid', itemUid);
+      column.appendChild(item);
+      mockRect(item, { top: top + 10 + itemIndex * 36, left: 30, width: 420, height: 32 });
+    });
+
+    mockRect(row, { top, left: 20, width: 440, height: 52 });
+    mockRect(column, { top, left: 20, width: 440, height: 52 });
+    top += 72;
+  });
+
+  return container;
+};
+
+const setMobileGridItems = (engine: FlowEngine, model: GridModel, itemUids: string[]) => {
+  (model as any).subModels = {
+    items: itemUids.map((itemUid) => engine.createModel({ use: 'FlowModel', uid: itemUid })),
+  };
+};
+
+const getSavedTopLevelItemOrder = (model: GridModel) => {
+  return Object.values(model.props.rows || {}).map((columns: string[][]) => columns[0]?.[0]);
+};
+
 describe('GridModel drag snapshot container', () => {
   let engine: FlowEngine;
 
@@ -106,6 +183,167 @@ describe('GridModel drag snapshot container', () => {
     model.handleDragCancel({} as any);
   });
 
+  it('filters multi-column drop slots from mobile drag snapshots', () => {
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-mobile-drag-slots',
+      props: {
+        rows: {
+          'row-1': [['item-1'], []],
+        },
+        sizes: {
+          'row-1': [12, 12],
+        },
+      },
+      structure: {} as any,
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+
+    const container = createGridContainerWithEmptyColumn();
+    (model.gridContainerRef as any).current = container;
+
+    model.handleDragStart({
+      active: { id: 'item-1' },
+      activatorEvent: { clientX: 80, clientY: 80 },
+    } as any);
+
+    const slotTypes = ((model as any).dragState?.slots || []).map((slot) => slot.type);
+    expect(slotTypes).toContain('column');
+    expect(slotTypes).toContain('row-gap');
+    expect(slotTypes).not.toContain('column-edge');
+    expect(slotTypes).not.toContain('item-edge');
+    expect(slotTypes).not.toContain('empty-column');
+    model.handleDragCancel({} as any);
+  });
+
+  it('keeps empty-row slot available for the first mobile grid item', () => {
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-mobile-empty-drag-slots',
+      props: {},
+      structure: {} as any,
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+
+    const container = document.createElement('div');
+    mockRect(container, { top: 0, left: 0, width: 480, height: 280 });
+    (model.gridContainerRef as any).current = container;
+
+    model.handleDragStart({
+      active: { id: 'item-1' },
+      activatorEvent: { clientX: 80, clientY: 80 },
+    } as any);
+
+    expect(((model as any).dragState?.slots || []).map((slot) => slot.type)).toEqual(['empty-row']);
+    model.handleDragCancel({} as any);
+  });
+
+  it('saves mobile vertical sorting when moving the second item above the first one', () => {
+    const rows = {
+      'row-a': [['item-a']],
+      'row-b': [['item-b']],
+    };
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-mobile-sort-second-above-first',
+      props: {
+        rows,
+        sizes: {
+          'row-a': [24],
+          'row-b': [24],
+        },
+        rowOrder: ['row-a', 'row-b'],
+      },
+      structure: {} as any,
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+    setMobileGridItems(engine, model, ['item-a', 'item-b']);
+    (model as any).saveStepParams = vi.fn();
+
+    const container = createProjectedMobileGridContainer(rows);
+    (model.gridContainerRef as any).current = container;
+
+    model.handleDragStart({
+      active: { id: 'item-b' },
+      activatorEvent: { clientX: 240, clientY: 118 },
+    } as any);
+    model.handleDragEnd({
+      delta: { x: 0, y: -112 },
+    } as any);
+
+    expect(getSavedTopLevelItemOrder(model)).toEqual(['item-b', 'item-a']);
+  });
+
+  it('saves mobile vertical sorting when moving the first item below the last one', () => {
+    const rows = {
+      'row-a': [['item-a']],
+      'row-b': [['item-b']],
+      'row-c': [['item-c']],
+    };
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-mobile-sort-first-below-last',
+      props: {
+        rows,
+        sizes: {
+          'row-a': [24],
+          'row-b': [24],
+          'row-c': [24],
+        },
+        rowOrder: ['row-a', 'row-b', 'row-c'],
+      },
+      structure: {} as any,
+    });
+    model.context.defineProperty('isMobileLayout', { value: true });
+    setMobileGridItems(engine, model, ['item-a', 'item-b', 'item-c']);
+    (model as any).saveStepParams = vi.fn();
+
+    const container = createProjectedMobileGridContainer(rows);
+    (model.gridContainerRef as any).current = container;
+
+    model.handleDragStart({
+      active: { id: 'item-a' },
+      activatorEvent: { clientX: 240, clientY: 46 },
+    } as any);
+    model.handleDragEnd({
+      delta: { x: 0, y: 184 },
+    } as any);
+
+    expect(getSavedTopLevelItemOrder(model)).toEqual(['item-b', 'item-c', 'item-a']);
+  });
+
+  it('does not filter multi-column drop slots from desktop drag snapshots', () => {
+    const model = engine.createModel<GridModel>({
+      use: 'GridModel',
+      uid: 'grid-desktop-drag-slots',
+      props: {
+        rows: {
+          'row-1': [['item-1'], []],
+        },
+        sizes: {
+          'row-1': [12, 12],
+        },
+      },
+      structure: {} as any,
+    });
+
+    const container = createGridContainerWithEmptyColumn();
+    (model.gridContainerRef as any).current = container;
+
+    model.handleDragStart({
+      active: { id: 'item-1' },
+      activatorEvent: { clientX: 80, clientY: 80 },
+    } as any);
+
+    const slotTypes = ((model as any).dragState?.slots || []).map((slot) => slot.type);
+    expect(slotTypes).toContain('column');
+    expect(slotTypes).toContain('row-gap');
+    expect(slotTypes).toContain('column-edge');
+    expect(slotTypes).toContain('item-edge');
+    expect(slotTypes).toContain('empty-column');
+    model.handleDragCancel({} as any);
+  });
+
   it('uses native pointer position instead of scroll-adjusted drag delta', () => {
     const model = engine.createModel<GridModel>({
       use: 'GridModel',

package/src/flow/models/base/__tests__/transformRowsToSingleColumn.test.ts

@@ -35,6 +35,36 @@ describe('transformRowsToSingleColumn', () => {
     expect(all).toEqual([['a'], ['b', 'c'], ['d'], ['e']]);
   });
 
+  it('should preserve row ids for ordinary single-column mobile rows', () => {
+    const rows = {
+      row_a: [['a']],
+      row_b: [['b']],
+    };
+
+    expect(transformRowsToSingleColumn(rows)).toEqual(rows);
+  });
+
+  it('should avoid adding another mobile prefix to ordinary single-column projected rows', () => {
+    const rows = {
+      'mobile:row_a:0': [['a']],
+    };
+
+    expect(Object.keys(transformRowsToSingleColumn(rows))).toEqual(['mobile:row_a:0']);
+  });
+
+  it('should keep split multi-column row keys stable and unique', () => {
+    const rows = {
+      row_a: [['a'], ['b']],
+    };
+    const result = transformRowsToSingleColumn(rows);
+    const keys = Object.keys(result);
+
+    expect(keys).toHaveLength(2);
+    expect(new Set(keys).size).toBe(2);
+    expect(keys.every((key) => key.startsWith('mobile:'))).toBe(true);
+    expect(Object.values(result).map((row) => row[0])).toEqual([['a'], ['b']]);
+  });
+
   it('should skip columns that only contain EMPTY_COLUMN_UID', () => {
     const rows = buildRows([[[EMPTY_COLUMN_UID], ['a']]]);
     const result = transformRowsToSingleColumn(rows);
@@ -55,4 +85,22 @@ describe('transformRowsToSingleColumn', () => {
     const all = Object.values(result).map((r) => r[0]);
     expect(all).toEqual([['x'], ['y']]);
   });
+
+  it('should keep generated row keys stable for the same input', () => {
+    const rows = buildRows([
+      [['a'], ['b']],
+      [['c'], ['d']],
+    ]);
+
+    expect(Object.keys(transformRowsToSingleColumn(rows))).toEqual(Object.keys(transformRowsToSingleColumn(rows)));
+  });
+
+  it('should keep existing row keys stable when appending new mobile rows', () => {
+    const before = buildRows([[['a'], ['b']]]);
+    const after = buildRows([[['a'], ['b']], [['c']]]);
+    const beforeKeys = Object.keys(transformRowsToSingleColumn(before));
+    const afterKeys = Object.keys(transformRowsToSingleColumn(after));
+
+    expect(afterKeys.slice(0, beforeKeys.length)).toEqual(beforeKeys);
+  });
 });

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -19,7 +19,6 @@ import {
   isRunJSValue,
   normalizeRunJSValue,
   parseCtxDateExpression,
-  runjsWithSafeGlobals,
   tExpr,
   FlowModelRenderer,
   FlowSettingsButton,
@@ -513,7 +512,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
       // RunJS support
       if (isRunJSValue(raw)) {
         const { code, version } = normalizeRunJSValue(raw);
-        const ret = await runjsWithSafeGlobals(this.context, code, { version });
+        const ret = await this.context.runjs(code, undefined, { version });
         return ret?.success ? ret.value : undefined;
       }
 

package/src/flow/models/blocks/filter-form/FilterFormJSActionModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { createSafeDocument, createSafeWindow, createSafeNavigator, tExpr } from '@nocobase/flow-engine';
+import { tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../../../components/code-editor';
 import { FilterFormActionModel } from './FilterFormActionModel';
 import { resolveRunJsParams } from '../../utils/resolveRunJsParams';
@@ -60,12 +60,7 @@ FilterFormJSActionModel.registerFlow({
       },
       async handler(ctx, params) {
         const { code, version } = resolveRunJsParams(ctx, params);
-        const navigator = createSafeNavigator();
-        await ctx.runjs(
-          code,
-          { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-          { version },
-        );
+        await ctx.runjs(code, undefined, { version });
       },
     },
   },

package/src/flow/models/blocks/form/JSFormActionModel.tsx

@@ -10,7 +10,7 @@
 /**
  * JS Form Action：表单工具栏按钮点击执行 JS。
  */
-import { tExpr, createSafeWindow, createSafeDocument, createSafeNavigator } from '@nocobase/flow-engine';
+import { tExpr } from '@nocobase/flow-engine';
 import { CodeEditor } from '../../../components/code-editor';
 import { FormActionModel } from './FormActionModel';
 import { resolveRunJsParams } from '../../utils/resolveRunJsParams';
@@ -73,12 +73,7 @@ ctx.message.success('Current form values: ' + JSON.stringify(values));
             await ctx.resource.refresh();
           }
         });
-        const navigator = createSafeNavigator();
-        await ctx.runjs(
-          code,
-          { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-          { version },
-        );
+        await ctx.runjs(code, undefined, { version });
       },
     },
   },

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

@@ -127,6 +127,93 @@ function createFieldContext(runtime: FormValueRuntime) {
 }
 
 describe('FormValueRuntime (default rules)', () => {
+  it('builds draft snapshots from current user-edited values only', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({});
+    const dispatchEvent = vi.fn();
+
+    const blockModel = {
+      uid: 'form-user-edited-draft-snapshot',
+      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, [{ path: ['fixed'], value: 'Fixed auto value' }], { source: 'system' });
+    await runtime.setFormValues(blockCtx, [{ path: ['defaultTitle'], value: 'Default auto value' }], {
+      source: 'default',
+    });
+    await runtime.setFormValues(blockCtx, [{ path: ['overrideTitle'], value: 'Override auto value' }], {
+      source: 'override',
+    });
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({});
+
+    await runtime.setFormValues(
+      blockCtx,
+      [
+        { path: ['title'], value: 'Manual title' },
+        { path: ['roles', 0, 'roleName'], value: 'Manual role' },
+      ],
+      { source: 'user' },
+    );
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([
+      { path: ['title'], value: 'Manual title' },
+      { path: ['roles', 0, 'roleName'], value: 'Manual role' },
+    ]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      title: 'Manual title',
+      roles: [{ roleName: 'Manual role' }],
+    });
+
+    await runtime.setFormValues(blockCtx, [{ path: ['title'], value: 'Fixed title' }], { source: 'system' });
+
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      roles: [{ roleName: 'Manual role' }],
+    });
+  });
+
+  it('omits non-user descendant values from parent user-edited draft patches', async () => {
+    const engineEmitter = new EventEmitter();
+    const blockEmitter = new EventEmitter();
+    const formStub = createFormStub({});
+    const dispatchEvent = vi.fn();
+
+    const blockModel = {
+      uid: 'form-user-edited-parent-draft-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,
+      [{ path: ['roles'], value: [{ roleName: 'Manual role', fixedRoleName: 'Initial fixed role' }] }],
+      { source: 'user' },
+    );
+    await runtime.setFormValues(blockCtx, [{ path: ['roles', 0, 'fixedRoleName'], value: 'System fixed role' }], {
+      source: 'system',
+    });
+
+    expect(runtime.getUserEditedValuePatches()).toEqual([{ path: ['roles'], value: [{ roleName: 'Manual role' }] }]);
+    expect(runtime.getUserEditedValuesSnapshot()).toEqual({
+      roles: [{ roleName: 'Manual role' }],
+    });
+  });
+
   it('skips object patches when values are unchanged', async () => {
     const engineEmitter = new EventEmitter();
     const blockEmitter = new EventEmitter();

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

@@ -8,7 +8,7 @@
  */
 
 import { isObservable, reaction, toJS } from '@formily/reactive';
-import { FlowContext, FlowModel, isRunJSValue, normalizeRunJSValue, runjsWithSafeGlobals } from '@nocobase/flow-engine';
+import { FlowContext, FlowModel, isRunJSValue, normalizeRunJSValue } from '@nocobase/flow-engine';
 import { getValuesByPath } from '@nocobase/shared';
 import _ from 'lodash';
 import { dayjs } from '@nocobase/utils/client';
@@ -1718,7 +1718,7 @@ export class RuleEngine {
   ): Promise<any> {
     try {
       const { code, version } = normalizeRunJSValue(rawValue);
-      const ret = await runjsWithSafeGlobals(evalCtx, code, { version });
+      const ret = await evalCtx.runjs(code, undefined, { version });
       if (!ret?.success) {
         if (seq !== state.runSeq) return SKIP_RULE_VALUE;
         this.commitRuleDeps(rule, state, collector);

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

@@ -38,6 +38,11 @@ type FormBlockModel = FlowModel & {
   getAclActionName?: () => string;
 };
 
+export type FormValuePatch = {
+  path: NamePath;
+  value: unknown;
+};
+
 export class FormValueRuntime {
   private readonly model: FormBlockModel;
   private readonly getForm: () => FormInstance;
@@ -142,6 +147,49 @@ export class FormValueRuntime {
     return this.getForm().getFieldsValue(true);
   }
 
+  getUserEditedValuePatches(): FormValuePatch[] {
+    const snapshot = this.getFormValuesSnapshot();
+    if (!snapshot || typeof snapshot !== 'object') {
+      return [];
+    }
+
+    const patches: FormValuePatch[] = [];
+    const pathKeys = Array.from(this.userEditedSet).sort(
+      (a, b) => pathKeyToNamePath(a).length - pathKeyToNamePath(b).length,
+    );
+
+    for (const pathKey of pathKeys) {
+      if (!this.isCurrentUserEditedPath(pathKey)) {
+        continue;
+      }
+
+      const namePath = pathKeyToNamePath(pathKey);
+      if (!namePath.length || !_.has(snapshot, namePath as any)) {
+        continue;
+      }
+
+      const value = _.get(snapshot, namePath as any);
+      if (typeof value === 'undefined') {
+        continue;
+      }
+
+      patches.push({
+        path: namePath,
+        value: this.omitNonUserDescendantValues(pathKey, this.toMirrorSnapshot(value)),
+      });
+    }
+
+    return patches;
+  }
+
+  getUserEditedValuesSnapshot(): Record<string, unknown> {
+    const values: Record<string, unknown> = {};
+    for (const patch of this.getUserEditedValuePatches()) {
+      _.set(values, patch.path as any, patch.value);
+    }
+    return values;
+  }
+
   private toMirrorSnapshot(value: any) {
     const raw = isObservable(value) ? toJS(value) : value;
     return _.cloneDeepWith(raw, (item) => {
@@ -1453,6 +1501,49 @@ export class FormValueRuntime {
     return null;
   }
 
+  private findLatestWriteMeta(pathKey: string): FormValueWriteMeta | undefined {
+    let latest: FormValueWriteMeta | undefined;
+    const namePath = pathKeyToNamePath(pathKey);
+    const prefix: NamePath = [];
+
+    for (let i = 0; i < namePath.length; i++) {
+      prefix.push(namePath[i]);
+      const meta = this.lastWriteMetaByPathKey.get(namePathToPathKey(prefix as any));
+      if (!meta) {
+        continue;
+      }
+      if (!latest || meta.writeSeq >= latest.writeSeq) {
+        latest = meta;
+      }
+    }
+
+    return latest;
+  }
+
+  private isCurrentUserEditedPath(pathKey: string) {
+    const lastWrite = this.findLatestWriteMeta(pathKey);
+    return !lastWrite || lastWrite.source === 'user';
+  }
+
+  private omitNonUserDescendantValues(pathKey: string, value: unknown) {
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+
+    const namePath = pathKeyToNamePath(pathKey);
+    for (const childKey of this.lastWriteMetaByPathKey.keys()) {
+      if (!this.isDescendantPathKey(childKey, pathKey)) {
+        continue;
+      }
+      if (this.isCurrentUserEditedPath(childKey)) {
+        continue;
+      }
+      _.unset(value as Record<string, unknown>, pathKeyToNamePath(childKey).slice(namePath.length) as any);
+    }
+
+    return value;
+  }
+
   private isDescendantPathKey(candidateKey: string, parentKey: string) {
     if (!candidateKey || !parentKey || candidateKey === parentKey) return false;
     const candidatePath = pathKeyToNamePath(candidateKey);

package/src/flow/models/blocks/js-block/JSBlock.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ElementProxy, tExpr, createSafeDocument, createSafeWindow, createSafeNavigator } from '@nocobase/flow-engine';
+import { ElementProxy, tExpr } from '@nocobase/flow-engine';
 import React from 'react';
 import { BlockModel } from '../../base';
 import { BlockItemCard } from '../../../components';
@@ -388,12 +388,7 @@ ctx.render(\`
               },
             },
           });
-          const navigator = createSafeNavigator();
-          await ctx.runjs(
-            code,
-            { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-            { version },
-          );
+          await ctx.runjs(code, undefined, { version });
         });
       },
     },

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

@@ -19,9 +19,6 @@ import {
   createRecordMetaFactory,
   createRecordResolveOnServerWithLocal,
   ElementProxy,
-  createSafeDocument,
-  createSafeWindow,
-  createSafeNavigator,
   observer,
 } from '@nocobase/flow-engine';
 import { Tooltip } from 'antd';
@@ -294,12 +291,7 @@ JSColumnModel.registerFlow({
             get: () => new ElementProxy((ctx.ref?.current as HTMLElement | null) || element),
             cache: false,
           });
-          const navigator = createSafeNavigator();
-          await ctx.runjs(
-            code,
-            { window: createSafeWindow({ navigator }), document: createSafeDocument(), navigator },
-            { version },
-          );
+          await ctx.runjs(code, undefined, { version });
         });
       },
     },

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

@@ -164,7 +164,7 @@ const AddActionToolbarComponent = observer(({ model }: any) => {
       subModelBaseClass={model.context.getModelClassName('RecordActionGroupModel')}
       subModelKey="actions"
       afterSubModelInit={async (actionModel) => {
-        actionModel.setStepParams('buttonSettings', 'general', { type: 'link', icon: null });
+        actionModel.setStepParams('buttonSettings', 'general', { type: 'link', icon: null, iconOnly: false });
       }}
     >
       <PlusOutlined />