@nocobase/client-v2 2.3.0-beta.9 → 2.4.0-alpha.10

package/src/flow/models/actions/__tests__/JSItemActionModel.test.tsx

@@ -8,13 +8,59 @@
  */
 
 import React from 'react';
-import { render, screen, waitFor } from '@nocobase/test/client';
+import { act, render, screen, waitFor } from '@nocobase/test/client';
 import { App, ConfigProvider } from 'antd';
 import { describe, expect, it } from 'vitest';
 import { FlowEngine, FlowEngineProvider, FlowModelRenderer } from '@nocobase/flow-engine';
 import { JSItemActionModel } from '../JSItemActionModel';
 
 describe('JSItemActionModel', () => {
+  it('keeps empty items reachable in configuration mode without replacing rendered content', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSItemActionModel });
+    const model = engine.createModel<JSItemActionModel>({ use: 'JSItemActionModel' });
+    await engine.flowSettings.disable();
+
+    render(model.render());
+    const host = model.context.ref.current;
+    expect(host).toBeInstanceOf(HTMLDivElement);
+    expect(host.style.minWidth).toBe('');
+    expect(host.textContent).toBe('');
+
+    await act(async () => {
+      await engine.flowSettings.enable();
+    });
+    await waitFor(() => expect(host.style.minWidth).toBe('40px'));
+
+    const content = document.createElement('button');
+    content.textContent = 'Custom action';
+    host.appendChild(content);
+
+    await act(async () => {
+      await engine.flowSettings.disable();
+    });
+    await waitFor(() => expect(host.style.minWidth).toBe(''));
+    expect(model.context.ref.current).toBe(host);
+    expect(host.firstElementChild).toBe(content);
+  });
+
+  it('keeps hidden empty items configurable and removes them outside configuration mode', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ JSItemActionModel });
+    const model = engine.createModel<JSItemActionModel>({ use: 'JSItemActionModel' });
+    model.setHidden(true);
+    await engine.flowSettings.enable();
+
+    const { container } = render(model.render());
+    expect(model.context.ref.current.style.minWidth).toBe('40px');
+    expect(model.context.ref.current.style.opacity).toBe('0.3');
+
+    await act(async () => {
+      await engine.flowSettings.disable();
+    });
+    await waitFor(() => expect(container).toBeEmptyDOMElement());
+  });
+
   it('renders collection-level custom content', async () => {
     const engine = new FlowEngine();
     engine.registerModels({ JSItemActionModel });

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

@@ -23,6 +23,7 @@ import {
 } from '@nocobase/flow-engine';
 import { Button, Form, Skeleton, Space } from 'antd';
 import React from 'react';
+import { findDataScopeStep, getQuickEditDataScopeFilter } from '../../../internal/utils/quickEditDataScope';
 import { FieldModel } from '../../base/FieldModel';
 import { FormComponent } from './FormBlockModel';
 import { FormItemModel } from './FormItemModel';
@@ -36,6 +37,14 @@ const QUICK_EDIT_MOBILE_CONTENT_PADDING = '8px var(--nb-mobile-page-tabs-content
 const QUICK_EDIT_MOBILE_ACTIONS_PADDING =
   '8px var(--nb-mobile-page-tabs-content-padding, 12px) calc(80px + env(safe-area-inset-bottom, 0px))';
 const QUICK_EDIT_MOBILE_MEDIA_QUERY = '(max-width: 768px)';
+// Dropdown-style editors open upwards inside the desktop popover so the option list does not cover the Submit and
+// Cancel buttons rendered right below the field. antd still flips the list downwards when there is no room above.
+const QUICK_EDIT_DROPDOWN_UP_MODELS = [
+  'SelectFieldModel',
+  'RecordSelectFieldModel',
+  'CascadeSelectFieldModel',
+  'CascadeSelectListFieldModel',
+];
 
 type QuickEditViewBeforeClosePayload = {
   result?: unknown;
@@ -159,6 +168,7 @@ export class QuickEditFormModel extends FlowModel {
   __onSubmitSuccess;
   _fieldProps: any;
   _onOk: any;
+  _dataScopeFilter: Record<string, any> | undefined;
 
   get form() {
     return this.context.form;
@@ -212,6 +222,7 @@ export class QuickEditFormModel extends FlowModel {
       },
       sourceFieldModel ? { delegate: sourceFieldModel.context } : undefined,
     ) as QuickEditFormModel;
+    model._dataScopeFilter = getQuickEditDataScopeFilter(sourceFieldModel);
 
     const bodyStyles = {
       maxHeight: QUICK_EDIT_POPOVER_MAX_HEIGHT,
@@ -410,6 +421,13 @@ QuickEditFormModel.registerFlow({
         resource.setDataSourceKey(dataSourceKey);
         resource.setResourceName(collectionName);
         ctx.model.resource = resource;
+        // Seed the edited row before dispatching the field model's flows. An association data scope resolves
+        // `ctx.record` while the field renders, and so does the foreign key filter that one-to-one and one-to-many
+        // editors build, so the record has to be in place first.
+        if (ctx.inputArgs.filterByTk || ctx.inputArgs.record) {
+          resource.setFilterByTk(ctx.inputArgs.filterByTk);
+          resource.setData(ctx.inputArgs.record);
+        }
         const collectionField = ctx.model.collection.getField(fieldPath) as CollectionField;
         if (collectionField) {
           const binding = FormItemModel.getDefaultBindingByField(ctx, collectionField);
@@ -417,24 +435,42 @@ QuickEditFormModel.registerFlow({
             return;
           }
           const use = binding.modelName;
+          const stepParams: Record<string, Record<string, Record<string, unknown>>> = {
+            fieldSettings: {
+              init: {
+                dataSourceKey,
+                collectionName,
+                fieldPath,
+              },
+            },
+          };
+          const dataScopeFilter = ctx.model._dataScopeFilter;
+          if (dataScopeFilter) {
+            const dataScopeStep = findDataScopeStep(ctx.engine.getModelClass(use));
+            if (dataScopeStep) {
+              stepParams[dataScopeStep.flowKey] = {
+                ...stepParams[dataScopeStep.flowKey],
+                [dataScopeStep.stepKey]: { filter: dataScopeFilter },
+              };
+            }
+          }
           const fieldModel = ctx.model.addSubModel<FieldModel>('fields', {
             use,
             props:
               typeof binding.defaultProps === 'function'
                 ? binding.defaultProps(ctx, collectionField)
                 : binding.defaultProps,
-            stepParams: {
-              fieldSettings: {
-                init: {
-                  dataSourceKey,
-                  collectionName,
-                  fieldPath,
-                },
-              },
-            },
+            stepParams,
           });
           fieldModel.setProps(getQuickEditFieldProps(collectionField, ctx.model._fieldProps));
           fieldModel.setProps({ sourceFieldModelUid: ctx.inputArgs.sourceFieldModelUid });
+          if (
+            !ctx.model.context.isMobileLayout &&
+            QUICK_EDIT_DROPDOWN_UP_MODELS.includes(use) &&
+            fieldModel.props.placement == null
+          ) {
+            fieldModel.setProps({ placement: 'topLeft' });
+          }
           ctx.model.context.defineProperty('collectionField', {
             get: () => collectionField,
           });
@@ -442,8 +478,6 @@ QuickEditFormModel.registerFlow({
           await fieldModel.dispatchEvent('beforeRender');
         }
         if (ctx.inputArgs.filterByTk || ctx.inputArgs.record) {
-          resource.setFilterByTk(ctx.inputArgs.filterByTk);
-          resource.setData(ctx.inputArgs.record);
           ctx.model.form?.setFieldsValue(resource.getData());
         }
       },

package/src/flow/models/blocks/form/__tests__/QuickEditFormModel.quickEdit.test.ts

@@ -9,7 +9,11 @@
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { FlowEngine, FlowModel, SingleRecordResource } from '@nocobase/flow-engine';
+import '../../../index';
 import { QuickEditFormModel } from '../QuickEditFormModel';
+import { dataScope } from '../../../../actions/dataScope';
+import { RecordSelectFieldModel } from '../../../fields/AssociationFieldModel/RecordSelectFieldModel';
+import { SelectFieldModel } from '../../../fields/SelectFieldModel';
 
 describe('QuickEditFormModel - quick edit save triggers API (regression)', () => {
   let engine: FlowEngine;
@@ -55,6 +59,54 @@ describe('QuickEditFormModel - quick edit save triggers API (regression)', () =>
     });
   };
 
+  const addMemberCollections = () => {
+    const ds = engine.context.dataSourceManager.getDataSource('main');
+    ds.addCollection({
+      name: 'departments',
+      filterTargetKey: 'id',
+      titleField: 'name',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'name', type: 'string', interface: 'input', uiSchema: { title: 'Name' } },
+        { name: 'level', type: 'string', interface: 'input', uiSchema: { title: 'Level' } },
+      ],
+    });
+    ds.addCollection({
+      name: 'members',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'level', type: 'string', interface: 'input', uiSchema: { title: 'Level' } },
+        {
+          name: 'department',
+          type: 'belongsTo',
+          interface: 'm2o',
+          target: 'departments',
+          targetKey: 'id',
+          uiSchema: { title: 'Department' },
+        },
+      ],
+    });
+  };
+
+  const openQuickEditForAssociation = async (dataScopeFilter?: Record<string, unknown>) => {
+    engine.registerModels({ QuickEditFormModel, RecordSelectFieldModel });
+    engine.registerActions({ dataScope });
+    addMemberCollections();
+    const model = engine.createModel<QuickEditFormModel>({
+      use: QuickEditFormModel,
+      uid: `qe-association-${dataScopeFilter ? 'scoped' : 'plain'}`,
+      stepParams: {
+        quickEditFormSettings: {
+          init: { dataSourceKey: 'main', collectionName: 'members', fieldPath: 'department' },
+        },
+      },
+    });
+    model._dataScopeFilter = dataScopeFilter;
+    await model.applyFlow('quickEditFormSettings', { filterByTk: 7, record: { id: 7, level: 'senior' } });
+    return model;
+  };
+
   it('uses source field context when opening quick edit', async () => {
     engine.registerModels({ QuickEditFormModel });
     engine.context.defineProperty('pageActive', { value: { value: false } });
@@ -414,4 +466,72 @@ describe('QuickEditFormModel - quick edit save triggers API (regression)', () =>
 
     expect(api.request).toHaveBeenCalledTimes(1);
   });
+
+  it('opens dropdown editors upwards in the desktop popover so they do not cover the actions', async () => {
+    engine.registerModels({ QuickEditFormModel, SelectFieldModel });
+    const ds = engine.context.dataSourceManager.getDataSource('main');
+    ds.addCollection({
+      name: 'users',
+      fields: [
+        {
+          name: 'tags',
+          type: 'array',
+          interface: 'multipleSelect',
+          uiSchema: { title: 'Tags', enum: [{ label: 'A', value: 'a' }] },
+        },
+      ],
+    });
+
+    const desktopModel = engine.createModel<QuickEditFormModel>({
+      use: QuickEditFormModel,
+      uid: 'qe-desktop',
+      stepParams: {
+        quickEditFormSettings: {
+          init: { dataSourceKey: 'main', collectionName: 'users', fieldPath: 'tags' },
+        },
+      },
+    });
+    await desktopModel.applyFlow('quickEditFormSettings', { record: {} });
+    const desktopField = desktopModel.subModels.fields[0];
+    expect(desktopField.use).toBe('SelectFieldModel');
+    expect(desktopField.props.placement).toBe('topLeft');
+
+    const mobileModel = engine.createModel<QuickEditFormModel>({
+      use: QuickEditFormModel,
+      uid: 'qe-mobile',
+      stepParams: {
+        quickEditFormSettings: {
+          init: { dataSourceKey: 'main', collectionName: 'users', fieldPath: 'tags' },
+        },
+      },
+    });
+    mobileModel.context.defineProperty('isMobileLayout', { value: true });
+    await mobileModel.applyFlow('quickEditFormSettings', { record: {} });
+    expect(mobileModel.subModels.fields[0].props.placement).toBeUndefined();
+  });
+
+  it('hands the column data scope to the association editor built for the popover', async () => {
+    const filter = { logic: '$and', items: [{ path: 'level', operator: 'eq', value: '{{ctx.record.level}}' }] };
+
+    const model = await openQuickEditForAssociation(filter);
+
+    const fieldModel = model.subModels.fields[0];
+    expect(fieldModel.use).toBe('RecordSelectFieldModel');
+    expect(fieldModel.getStepParams('selectSettings', 'dataScope')).toEqual({ filter });
+  });
+
+  it('leaves the association editor unscoped when the column has no data scope', async () => {
+    const model = await openQuickEditForAssociation();
+
+    expect(model.subModels.fields[0].getStepParams('selectSettings', 'dataScope')).toBeUndefined();
+  });
+
+  it('seeds the edited row before the editor flows run so record variables resolve', async () => {
+    const filter = { logic: '$and', items: [{ path: 'level', operator: 'eq', value: '{{ctx.record.level}}' }] };
+
+    const model = await openQuickEditForAssociation(filter);
+
+    expect(model.resource.getData()).toMatchObject({ id: 7, level: 'senior' });
+    expect(JSON.stringify(model.subModels.fields[0].resource.getFilter() ?? null)).toContain('senior');
+  });
 });

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

@@ -152,6 +152,7 @@ const JSBlockPlainHost = ({
   afterContent,
   contentRef,
   marginBlock,
+  minHeight,
   ...rest
 }: React.HTMLAttributes<HTMLDivElement> & {
   uid: string;
@@ -161,6 +162,7 @@ const JSBlockPlainHost = ({
   afterContent?: React.ReactNode;
   contentRef: React.RefObject<HTMLDivElement>;
   marginBlock: number;
+  minHeight: number;
 }) => {
   const hostRef = React.useRef<HTMLDivElement | null>(null);
   const resolvedHeight = usePlainHostHeight({ height, heightMode, hostRef, marginBlock });
@@ -175,7 +177,7 @@ const JSBlockPlainHost = ({
         display: 'flex',
         flexDirection: 'column',
         height: resolvedHeight ?? undefined,
-        minHeight: 0,
+        minHeight,
         overflow: 'auto',
         ...(style || {}),
       }}
@@ -228,6 +230,8 @@ export class JSBlockModel extends BlockModel {
           afterContent={afterContent}
           contentRef={this.context.ref}
           marginBlock={this.context.themeToken?.marginBlock ?? 0}
+          // Keep empty blocks reachable by the settings overlay while the UI editor is active.
+          minHeight={this.context.flowSettingsEnabled ? this.context.themeToken?.controlHeightLG ?? 40 : 0}
         />
       );
     }

package/src/flow/models/blocks/js-block/__tests__/JSBlockModel.test.tsx

@@ -9,7 +9,7 @@
 
 import React from 'react';
 import { App, ConfigProvider } from 'antd';
-import { render } from '@nocobase/test/client';
+import { act, render, waitFor } from '@nocobase/test/client';
 import { describe, expect, it, vi } from 'vitest';
 import { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
 import { JSBlockModel } from '../JSBlock';
@@ -78,6 +78,28 @@ describe('JSBlockModel', () => {
     expect(model.context.ref.current).toBe(host?.firstElementChild);
   });
 
+  it('keeps an empty cardless block reachable only while the UI editor is active', async () => {
+    const { engine, model } = createJSBlock('js-block-empty-without-card', false, { style: undefined });
+    await engine.flowSettings.disable();
+    const { container } = renderBlock(engine, model);
+    const host = container.querySelector('#model-js-block-empty-without-card') as HTMLElement;
+    const content = model.context.ref.current;
+
+    expect(host.style.minHeight).toBe('0');
+    await act(async () => {
+      await engine.flowSettings.enable();
+    });
+    await waitFor(() => expect(host.style.minHeight).toBe('40px'));
+    expect(model.context.ref.current).toBe(content);
+    expect(container.querySelector('.ant-card')).toBeNull();
+
+    await act(async () => {
+      await engine.flowSettings.disable();
+    });
+    await waitFor(() => expect(host.style.minHeight).toBe('0'));
+    expect(model.context.ref.current).toBe(content);
+  });
+
   it('keeps cardless specified-height content scrollable inside the plain host', () => {
     const { engine, model } = createJSBlock('js-block-without-card-height', false, {
       heightMode: 'specifyValue',

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

@@ -37,6 +37,7 @@ import { getRowKey } from './utils';
 import { getSavedAssociationTitleField, getTableColumnSortField } from './sortUtils';
 import { getFieldBindingUse, rebuildFieldSubModel } from '../../../internal/utils/rebuildFieldSubModel';
 import { getSavedDateTimeFormatParams, resolveDateTimeDisplayProps } from '../../../utils/dateTimeDisplayProps';
+import { QuickEditDataScopeInput, resolveQuickEditDataScopeStep } from '../../../internal/utils/quickEditDataScope';
 
 export function FieldDeletePlaceholder(props: any) {
   const { t } = useTranslation();
@@ -542,6 +543,36 @@ TableColumnModel.registerFlow({
         ctx.model.setProps('editable', ctx.model.associationPathName ? false : params.editable);
       },
     },
+    quickEditDataScope: {
+      title: tExpr('Data scope'),
+      uiMode: {
+        type: 'dialog',
+        props: {
+          width: 800,
+        },
+      },
+      uiSchema: {
+        filter: {
+          type: 'object',
+          'x-decorator': 'FormItem',
+          'x-component': QuickEditDataScopeInput,
+        },
+      },
+      useRawParams: true,
+      defaultParams: {
+        filter: { logic: '$and', items: [] },
+      },
+      hideInSettings(ctx) {
+        if (ctx.model.associationPathName || !ctx.model.props.editable) {
+          return true;
+        }
+        return !resolveQuickEditDataScopeStep(ctx, ctx.collectionField);
+      },
+      handler() {
+        // Settings-only step. The filter is kept raw on the column and handed to the editor model that
+        // QuickEditFormModel builds when the popover opens, so there is nothing to apply to the column itself.
+      },
+    },
     model: {
       title: tExpr('Field component'),
       use: 'displayFieldComponent',

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

@@ -9,8 +9,36 @@
 
 import { FlowEngine } from '@nocobase/flow-engine';
 import { describe, expect, it, vi } from 'vitest';
+// Prime the model module graph so the editable field bindings used by the quick edit data scope setting are registered.
+import '../../../index';
+import { RecordSelectFieldModel } from '../../../fields/AssociationFieldModel/RecordSelectFieldModel';
 import { TableColumnModel } from '../TableColumnModel';
 
+const createQuickEditDataScopeCtx = (
+  overrides: { associationPathName?: string; editable?: boolean; isAssociation?: boolean } = {},
+) => {
+  const engine = new FlowEngine();
+  engine.registerModels({ RecordSelectFieldModel });
+  const { associationPathName, editable = true, isAssociation = true } = overrides;
+  return {
+    engine,
+    model: {
+      associationPathName,
+      props: { editable },
+    },
+    collectionField: {
+      interface: isAssociation ? 'm2o' : 'input',
+      isAssociationField: () => isAssociation,
+      targetCollection: isAssociation ? { template: 'general' } : undefined,
+    },
+  };
+};
+
+const getQuickEditDataScopeStep = (engine: FlowEngine) => {
+  const model = new TableColumnModel({ uid: 'table-column-quick-edit-data-scope', flowEngine: engine } as any);
+  return model.getFlow('tableColumnSettings')?.steps?.quickEditDataScope as any;
+};
+
 describe('TableColumnModel sorter settings', () => {
   it('clamps custom column width to the minimum value', () => {
     const engine = new FlowEngine();
@@ -30,6 +58,42 @@ describe('TableColumnModel sorter settings', () => {
     expect(setProps).toHaveBeenCalledWith('width', 10);
   });
 
+  it('offers the quick edit data scope on an editable association column', async () => {
+    const engine = new FlowEngine();
+    const step = getQuickEditDataScopeStep(engine);
+
+    const hidden = await step.hideInSettings(createQuickEditDataScopeCtx());
+
+    expect(hidden).toBe(false);
+  });
+
+  it('hides the quick edit data scope when quick edit is off', async () => {
+    const engine = new FlowEngine();
+    const step = getQuickEditDataScopeStep(engine);
+
+    const hidden = await step.hideInSettings(createQuickEditDataScopeCtx({ editable: false }));
+
+    expect(hidden).toBe(true);
+  });
+
+  it('hides the quick edit data scope for non-association columns', async () => {
+    const engine = new FlowEngine();
+    const step = getQuickEditDataScopeStep(engine);
+
+    const hidden = await step.hideInSettings(createQuickEditDataScopeCtx({ isAssociation: false }));
+
+    expect(hidden).toBe(true);
+  });
+
+  it('hides the quick edit data scope for relation path columns', async () => {
+    const engine = new FlowEngine();
+    const step = getQuickEditDataScopeStep(engine);
+
+    const hidden = await step.hideInSettings(createQuickEditDataScopeCtx({ associationPathName: 'department' }));
+
+    expect(hidden).toBe(true);
+  });
+
   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);

package/src/flow/models/fields/AssociationFieldModel/CascadeSelectFieldModel.tsx

@@ -25,6 +25,7 @@ import { arrayMove, SortableContext, verticalListSortingStrategy, useSortable }
 import { CSS } from '@dnd-kit/utilities';
 import { AssociationFieldModel } from './AssociationFieldModel';
 import { transformNestedData } from '../ClickableFieldModel';
+import { syncQuickEditPreventClose } from '../../../internal/utils/quickEditViewContainer';
 
 type CascadeHydrateStatus = 'pending' | 'done';
 
@@ -373,7 +374,12 @@ export class CascadeSelectInnerFieldModel extends AssociationFieldModel {
     this.setProps({ onPopupScroll: fn });
   }
   set onDropdownVisibleChange(fn) {
-    this.setProps({ onDropdownVisibleChange: fn });
+    this.setProps({
+      onDropdownVisibleChange: (visible: boolean) => {
+        syncQuickEditPreventClose(this, visible);
+        fn(visible);
+      },
+    });
   }
   set onSearch(fn) {
     this.setProps({ onSearch: fn });

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/PopupSubTableFieldModel.tsx

@@ -19,7 +19,7 @@ import {
   createCurrentRecordMetaFactory,
   useFlowModel,
 } from '@nocobase/flow-engine';
-import { Table, Button, Space } from 'antd';
+import { Table, Button, Space, theme } from 'antd';
 import { uid } from '@formily/shared';
 import classNames from 'classnames';
 import { DragEndEvent } from '@dnd-kit/core';
@@ -190,6 +190,7 @@ const AddFieldColumn = ({ model }) => {
 };
 
 const DisplayTable = (props) => {
+  const { token } = theme.useToken();
   const {
     pageSize,
     value,
@@ -269,7 +270,7 @@ const DisplayTable = (props) => {
           },
         },
         ...baseColumns,
-        { key: 'empty' },
+        { key: 'empty', render: () => <div style={{ minHeight: token.controlHeight }} /> },
       ].filter(Boolean),
     ) as any[];
 
@@ -283,7 +284,7 @@ const DisplayTable = (props) => {
     }
 
     return cols;
-  }, [baseColumns, enableIndexColumn, currentPage, currentPageSize, isConfigMode, model]);
+  }, [baseColumns, enableIndexColumn, currentPage, currentPageSize, isConfigMode, model, token.controlHeight]);
   return (
     <Table
       tableLayout="fixed"

package/src/flow/models/fields/AssociationFieldModel/RecordSelectFieldModel.tsx

@@ -41,6 +41,7 @@ import { BlockSceneEnum } from '../../base/BlockModel';
 import { ActionWithoutPermission } from '../../base/ActionModel';
 import { EditFormModel } from '../../blocks';
 import { hasAncestorModel } from './recordSelectSettingsUtils';
+import { syncQuickEditPreventClose } from '../../../internal/utils/quickEditViewContainer';
 
 function RemoteModelRenderer({ options }) {
   const ctx = useFlowViewContext();
@@ -65,6 +66,11 @@ function RemoteModelRenderer({ options }) {
 
 export function CreateContent({ model, toOne = false }) {
   const ctx = useFlowContext();
+  // Quick-create popups isolate business context but must retain the field's configuration mode.
+  ctx.defineProperty('flowSettingsEnabled', {
+    get: () => model.context.flowSettingsEnabled,
+    cache: false,
+  });
   const { Header, type } = ctx.view;
   model._closeView = ctx.view.close;
   return (
@@ -308,6 +314,7 @@ const LazySelect = (props: Readonly<LazySelectProps>) => {
             }
             setKeepOpenRuntime({ preventCloseOnSelect: false, open });
           }
+          syncQuickEditPreventClose(model, open);
           others.onDropdownVisibleChange?.(open);
         }}
         optionRender={({ data }) => {
@@ -874,6 +881,8 @@ RecordSelectFieldModel.registerFlow({
             dataSourceKey: ctx.collection.dataSourceKey,
             collectionName: ctx.collectionField?.target,
             ...(associationName && sourceId != null ? { associationName, sourceId } : {}),
+            // 上级记录暂无主键（如审批配置态表单）时不能传 associationName，否则弹窗内新建的区块会绑定到关联资源；改传 sourceAssociationName，仅用于展示“当前弹窗上级记录”变量
+            ...(associationName && sourceId == null ? { sourceAssociationName: associationName } : {}),
             collectionField: ctx.collectionField,
             openerUids,
             onChange: (e) => {