@nocobase/client-v2 2.1.4 → 2.1.5

package/src/flow/actions/__tests__/subFormFieldLinkageRules.inputArgs.test.ts

@@ -13,7 +13,7 @@ import { subFormFieldLinkageRules } from '../linkageRules';
 import { SubFormFieldModel, SubFormListFieldModel } from '../../models/fields/AssociationFieldModel/SubFormFieldModel';
 
 describe('subFormFieldLinkageRules action', () => {
-  it('passes inputArgs to fork runtime context', async () => {
+  it('passes inputArgs to fork runtime context when grid forks are stored in a Set', async () => {
     const linkageAssignHandler = vi.fn();
     const engine = new FlowEngine();
     const forkModel = new FlowModel({ uid: 'fork-model', flowEngine: engine }) as any;
@@ -38,7 +38,7 @@ describe('subFormFieldLinkageRules action', () => {
         hidden: false,
         subModels: {
           grid: {
-            forks: [forkModel],
+            forks: new Set([forkModel]),
           },
         },
       },

package/src/flow/actions/linkageRules.tsx

@@ -2842,7 +2842,7 @@ export const subFormFieldLinkageRules = defineAction({
       }
     } else {
       await Promise.all(
-        (grid.forks || []).map(async (forkModel: FlowModel) => {
+        Array.from(grid.forks || []).map(async (forkModel: FlowModel) => {
           if (forkModel.hidden) {
             return;
           }

package/src/flow/actions/linkageRulesFormValueRefresh.ts

@@ -15,17 +15,29 @@ import {
   isRunJSValue,
 } from '@nocobase/flow-engine';
 import _ from 'lodash';
-import { namePathToPathKey, parsePathString, pathKeyToNamePath } from '../models/blocks/form/value-runtime/path';
+import { namePathToPathKey } from '../models/blocks/form/value-runtime/path';
 import {
   collectStaticDepsFromRunJSValue,
   collectStaticDepsFromTemplateValue,
   recordDep,
   type DepCollector,
 } from '../models/blocks/form/value-runtime/deps';
+import {
+  buildItemListRootPath,
+  buildItemRowPath,
+  dedupeNamePaths,
+  findFormValueChangeSource,
+  getChangedPathsFromPayload,
+  getFieldIndexEntriesFromContext,
+  isNamePathPrefix,
+  isSameNamePath,
+  minimizeNamePaths,
+  parseDependencyPath,
+  parsePathKey,
+  type NamePath,
+} from '../utils/formValueDeps';
 import { linkageRulesRefresh } from './linkageRulesRefresh';
 
-type NamePath = Array<string | number>;
-
 type LinkageRefreshDeps = {
   wildcard: boolean;
   valuePaths: NamePath[];
@@ -40,75 +52,11 @@ type LinkageRefreshBinding = {
   dispose: () => void;
 };
 
-type FieldIndexEntry = {
-  name: string;
-  index: number;
-};
-
 const FORM_VALUES_CHANGE_EVENT = 'formValuesChange';
 const LINKAGE_REFRESH_BINDINGS_KEY = '__formValueDrivenLinkageRefreshBindings';
 
-function isSameNamePath(a: NamePath, b: NamePath) {
-  return a.length === b.length && a.every((seg, index) => seg === b[index]);
-}
-
-function isNamePathPrefix(prefix: NamePath, path: NamePath) {
-  if (prefix.length > path.length) return false;
-  return prefix.every((seg, index) => seg === path[index]);
-}
-
-function dedupeNamePaths(paths: NamePath[]) {
-  const byKey = new Map<string, NamePath>();
-  for (const path of paths) {
-    if (!path?.length) continue;
-    byKey.set(namePathToPathKey(path), path);
-  }
-  return Array.from(byKey.values());
-}
-
-function minimizeValueNamePaths(paths: NamePath[]) {
-  const deduped = dedupeNamePaths(paths);
-  return deduped.filter((path, index) => {
-    return !deduped.some((other, otherIndex) => otherIndex !== index && isNamePathPrefix(path, other));
-  });
-}
-
-function parseFieldIndexEntries(fieldIndex: unknown): FieldIndexEntry[] {
-  const arr = Array.isArray(fieldIndex) ? fieldIndex : [];
-  const entries: FieldIndexEntry[] = [];
-  for (const it of arr) {
-    if (typeof it !== 'string') continue;
-    const [name, indexStr] = it.split(':');
-    const index = Number(indexStr);
-    if (!name || Number.isNaN(index)) continue;
-    entries.push({ name, index });
-  }
-  return entries;
-}
-
-function getFieldIndexEntriesFromContext(ctx: any): FieldIndexEntry[] {
-  return parseFieldIndexEntries(ctx?.model?.context?.fieldIndex ?? ctx?.fieldIndex);
-}
-
-function buildItemRowPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const targetIndex = entries.length - 1 - parentDepth;
-  if (targetIndex < 0) return null;
-
-  const out: NamePath = [];
-  for (let i = 0; i <= targetIndex; i++) {
-    out.push(entries[i].name, entries[i].index);
-  }
-  return out;
-}
-
-function buildItemListRootPath(entries: FieldIndexEntry[], parentDepth: number): NamePath | null {
-  const rowPath = buildItemRowPath(entries, parentDepth);
-  if (!rowPath?.length) return null;
-  return rowPath.slice(0, -1);
-}
-
 function resolveItemDependencyPath(ctx: FlowContext, depPath: NamePath): LinkageRefreshDeps {
-  const entries = getFieldIndexEntriesFromContext(ctx as any);
+  const entries = getFieldIndexEntriesFromContext(ctx);
   if (!entries.length) {
     return { wildcard: true, valuePaths: [], structuralPaths: [] };
   }
@@ -171,8 +119,7 @@ function addRunjsUsageToCollector(script: string, collector: DepCollector) {
           collector.wildcard = true;
           continue;
         }
-        const segs = parsePathString(String(subPath)).filter((seg) => typeof seg !== 'object') as NamePath;
-        recordDep(segs, collector);
+        recordDep(parseDependencyPath(String(subPath)), collector);
         continue;
       }
       if (varName === 'item') {
@@ -233,13 +180,13 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
         wildcard = true;
         continue;
       }
-      valuePaths.push(pathKeyToNamePath(inner));
+      valuePaths.push(parsePathKey(inner));
       continue;
     }
 
     if (depKey === 'ctx:item' || depKey.startsWith('ctx:item:')) {
       const subPath = depKey === 'ctx:item' ? '' : depKey.slice('ctx:item:'.length);
-      const depPath = subPath ? (parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath) : [];
+      const depPath = subPath ? parseDependencyPath(subPath) : [];
       const resolved = resolveItemDependencyPath(ctx, depPath);
       wildcard ||= resolved.wildcard;
       valuePaths.push(...resolved.valuePaths);
@@ -249,7 +196,7 @@ function collectLinkageRefreshDeps(ctx: FlowContext, params: any): LinkageRefres
 
   return {
     wildcard,
-    valuePaths: minimizeValueNamePaths(valuePaths),
+    valuePaths: minimizeNamePaths(valuePaths),
     structuralPaths: dedupeNamePaths(structuralPaths),
   };
 }
@@ -258,44 +205,9 @@ function hasLinkageRefreshDeps(deps: LinkageRefreshDeps) {
   return deps.wildcard || deps.valuePaths.length > 0 || deps.structuralPaths.length > 0;
 }
 
-function getChangedPathsFromPayload(payload: any): NamePath[] {
-  const rawChangedPaths = Array.isArray(payload?.changedPaths) ? payload.changedPaths : [];
-  const out: NamePath[] = [];
-
-  for (const path of rawChangedPaths) {
-    if (Array.isArray(path)) {
-      if (path.length === 1 && typeof path[0] === 'string') {
-        const namePath = pathKeyToNamePath(path[0]);
-        if (namePath.length) out.push(namePath);
-        continue;
-      }
-      const segs = path.filter((seg) => typeof seg === 'string' || typeof seg === 'number') as NamePath;
-      if (segs.length) out.push(segs);
-      continue;
-    }
-    if (typeof path === 'string' && path) {
-      out.push(pathKeyToNamePath(path));
-    }
-  }
-
-  if (out.length) {
-    return out;
-  }
-
-  const changedValues = payload?.changedValues;
-  if (changedValues && typeof changedValues === 'object') {
-    for (const key of Object.keys(changedValues)) {
-      const namePath = pathKeyToNamePath(key);
-      if (namePath.length) out.push(namePath);
-    }
-  }
-
-  return out;
-}
-
 function linkageRefreshDepsMatchPayload(deps: LinkageRefreshDeps, payload: any) {
   if (!hasLinkageRefreshDeps(deps)) return false;
-  const changedPaths = getChangedPathsFromPayload(payload);
+  const changedPaths = getChangedPathsFromPayload(payload, { includeArrayChangedValues: true });
   if (deps.wildcard) return true;
   if (!changedPaths.length) return true;
 
@@ -330,28 +242,8 @@ function getLinkageRefreshBindings(model: any): Map<string, LinkageRefreshBindin
   return (model[LINKAGE_REFRESH_BINDINGS_KEY] ||= new Map<string, LinkageRefreshBinding>());
 }
 
-function isFormBlockForLinkageRefresh(model: any) {
-  if (!model || typeof model !== 'object') return false;
-  if (!model.emitter || typeof model.emitter.on !== 'function' || typeof model.emitter.off !== 'function') return false;
-  return !!model.formValueRuntime || !!model.context?.form || typeof model.context?.setFormValues === 'function';
-}
-
 function findFormBlockForLinkageRefresh(ctx: FlowContext): any | null {
-  const candidates: any[] = [];
-  const push = (model: any) => {
-    if (model && !candidates.includes(model)) candidates.push(model);
-  };
-
-  push((ctx.model as any)?.context?.blockModel);
-  push(ctx.model);
-
-  let cursor: any = (ctx.model as any)?.parent;
-  while (cursor) {
-    push(cursor);
-    cursor = cursor?.parent;
-  }
-
-  return candidates.find(isFormBlockForLinkageRefresh) || null;
+  return findFormValueChangeSource(ctx) as any;
 }
 
 function disposeLinkageRefreshBinding(model: any, key: string) {

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/SubTableColumnModel.tsx

@@ -26,6 +26,7 @@ import {
   observer,
   FlowModelProvider,
   FlowErrorFallback,
+  extractUsedVariablePaths,
 } from '@nocobase/flow-engine';
 import { TableColumnProps, Tooltip, Input, Space, Divider } from 'antd';
 import { ErrorBoundary } from 'react-error-boundary';
@@ -37,6 +38,14 @@ import { FieldDeletePlaceholder, CustomWidth, normalizeTableColumnWidth } from '
 import { buildDynamicNamePath } from '../../../blocks/form/dynamicNamePath';
 import { getSubTableRowIdentity } from './rowIdentity';
 import { getFieldBindingUse, rebuildFieldSubModel } from '../../../../internal/utils/rebuildFieldSubModel';
+import {
+  buildCurrentItemTitle,
+  createAssociationItemChainContextPropertyOptions,
+  createItemChainGetter,
+  createParentItemAccessorsFromContext,
+  createRootItemChain,
+  type ItemChain,
+} from '../itemChain';
 
 export const SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT = 'subTableColumn';
 
@@ -180,6 +189,25 @@ const handleModelName = (modelName) => {
   return modelName;
 };
 
+const DATA_SCOPE_FLOW_KEYS = ['selectSettings', 'cascadeSelectSettings'];
+
+function hasFormValueDrivenDataScope(filter: any) {
+  if (!filter) return false;
+  try {
+    const usage = extractUsedVariablePaths(filter) || {};
+    return ['item', 'formValues'].some((name) => Object.prototype.hasOwnProperty.call(usage, name));
+  } catch {
+    return false;
+  }
+}
+
+function hasFormValueDrivenDataScopeField(fieldModel: any) {
+  return DATA_SCOPE_FLOW_KEYS.some((flowKey) => {
+    const params = fieldModel?.getStepParams?.(flowKey, 'dataScope');
+    return hasFormValueDrivenDataScope(params?.filter);
+  });
+}
+
 const MemoFieldRenderer = React.memo(FieldModelRenderer, (prev, next) => {
   return prev.value === next.value && prev.model === next.model;
 });
@@ -348,7 +376,10 @@ const MemoCell: React.FC<CellProps> = React.memo(
           const fork: any = action.createFork({}, `${id}`);
           fork.context.defineProperty('currentObject', { get: () => record });
           if (rowFork) {
+            const itemOptions = rowFork.context.getPropertyOptions?.('item');
+            const { value: _value, ...itemOptionsWithoutValue } = (itemOptions || {}) as any;
             fork.context.defineProperty('item', {
+              ...itemOptionsWithoutValue,
               get: () => rowFork.context.item,
               cache: false,
             });
@@ -445,6 +476,57 @@ export class SubTableColumnModel<
   static renderMode = ModelRenderMode.RenderFunction;
   static fieldComponentContext = SUB_TABLE_COLUMN_FIELD_COMPONENT_CONTEXT;
 
+  private getAssociationField() {
+    return (this.parent as any)?.context?.collectionField;
+  }
+
+  private getParentFormValues() {
+    return (this.context?.blockModel as any)?.context?.formValues;
+  }
+
+  private createParentItemAccessors(parentItemAccessor?: () => ItemChain | undefined) {
+    const baseAccessors = createParentItemAccessorsFromContext({
+      parentContextAccessor: () => (this.parent as any)?.context,
+      fallbackParentPropertiesAccessor: () => this.getParentFormValues(),
+    });
+
+    if (!parentItemAccessor) {
+      return baseAccessors;
+    }
+
+    return {
+      parentPropertiesAccessor: (ctx?: any) =>
+        parentItemAccessor()?.value ?? baseAccessors.parentPropertiesAccessor(ctx),
+      parentItemMetaAccessor: baseAccessors.parentItemMetaAccessor,
+      parentItemResolverAccessor: baseAccessors.parentItemResolverAccessor,
+    };
+  }
+
+  private createRowItemContextPropertyOptions(
+    options: {
+      resolverPropertiesAccessor?: () => unknown;
+      parentItemAccessor?: () => ItemChain | undefined;
+      showParentIndex?: boolean;
+    } = {},
+  ) {
+    const associationField = this.getAssociationField();
+
+    return createAssociationItemChainContextPropertyOptions({
+      t: this.context.t,
+      title: buildCurrentItemTitle(this.context.t, associationField, this.props?.name),
+      showIndex: true,
+      showParentIndex:
+        options.showParentIndex ??
+        (Array.isArray((this.parent as any)?.context?.fieldIndex) &&
+          (this.parent as any).context.fieldIndex.length > 0),
+      collectionAccessor: () => (this.parent as any)?.collection ?? associationField?.targetCollection ?? null,
+      propertiesAccessor: (ctx) => ctx?.item?.value,
+      resolverPropertiesAccessor: options.resolverPropertiesAccessor ?? (() => undefined),
+      parentCollectionAccessor: () => associationField?.collection,
+      parentAccessors: this.createParentItemAccessors(options.parentItemAccessor),
+    });
+  }
+
   renderHiddenInConfig() {
     return <FieldWithoutPermissionPlaceholder targetModel={this} />;
   }
@@ -505,6 +587,14 @@ export class SubTableColumnModel<
     ).some(Boolean);
   }
 
+  get hasFormValueDrivenDataScopeColumn() {
+    return (
+      this.parent?.mapSubModels('columns', (column: SubTableColumnModel) => {
+        return hasFormValueDrivenDataScopeField(column?.subModels?.field);
+      }) || []
+    ).some(Boolean);
+  }
+
   onInit(options: any): void {
     super.onInit(options);
     this.context.defineProperty('resourceName', {
@@ -516,6 +606,10 @@ export class SubTableColumnModel<
     this.context.defineProperty('actionName', {
       get: () => 'view',
     });
+    this.context.defineProperty('item', {
+      get: () => undefined,
+      ...this.createRowItemContextPropertyOptions(),
+    });
     this.emitter.on('onSubModelAdded', (subModel: FieldModel) => {
       if (this.collectionField) {
         subModel.setProps(this.collectionField.getComponentProps());
@@ -673,25 +767,30 @@ export class SubTableColumnModel<
             value: [...baseArr, `${associationKey}:${rowIndex}`],
           });
         }
-        fork.context.defineProperty('item', {
-          get: () => {
-            const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
-            const rowRecord = getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
-            const parentItemCtx = (parentItem ?? this.context?.item) as any;
-            const isNew = rowRecord?.__is_new__;
-            const isStored = rowRecord?.__is_stored__;
+        const getRowRecord = () => {
+          const form = (fork.context as any)?.form || (this.context?.blockModel as any)?.context?.form;
+          return getLatestSubTableRowRecord(form, fork.context.fieldIndex, record);
+        };
+        const getParentItem = () => {
+          const parentItemCtx = (parentItem ?? (this.parent as any)?.context?.item) as ItemChain | undefined;
+          return parentItemCtx ?? createRootItemChain(this.getParentFormValues());
+        };
+        const getRowItem = createItemChainGetter({
+          valueAccessor: getRowRecord,
+          parentItemAccessor: getParentItem,
+          indexAccessor: () => (Number.isFinite(rowIndex) ? rowIndex : undefined),
+          lengthAccessor: () => {
             const list = (this.parent as any)?.props?.value;
-            const length = Array.isArray(list) ? list.length : undefined;
-            return {
-              index: Number.isFinite(rowIndex) ? rowIndex : undefined,
-              length,
-              __is_new__: isNew,
-              __is_stored__: isStored,
-              value: rowRecord,
-              parentItem: parentItemCtx,
-            };
+            return Array.isArray(list) ? list.length : undefined;
           },
-          cache: false,
+        });
+        fork.context.defineProperty('item', {
+          get: getRowItem,
+          ...this.createRowItemContextPropertyOptions({
+            resolverPropertiesAccessor: getRowRecord,
+            parentItemAccessor: getParentItem,
+            showParentIndex: baseArr.length > 0,
+          }),
         });
         return fork;
       })();
@@ -707,7 +806,7 @@ export class SubTableColumnModel<
           rowFork={rowFork}
           memoKey={cellModeKey}
           width={this.props.width}
-          commitOnChange={this.hasFormulaColumn}
+          commitOnChange={this.hasFormulaColumn || this.hasFormValueDrivenDataScopeColumn}
         />
       );
     };

package/src/flow/models/fields/AssociationFieldModel/SubTableFieldModel/__tests__/SubTableColumnModel.rowRecord.test.ts

@@ -21,6 +21,26 @@ import {
   isSubTableColumnReadPretty,
 } from '../SubTableColumnModel';
 
+function createMockCollection(name: string, fields: any[] = []) {
+  const collection: any = {
+    name,
+    title: name,
+    dataSourceKey: 'main',
+    filterTargetKey: 'id',
+    fields,
+    getFields: () => collection.fields,
+    getField: (fieldName: string) => collection.fields.find((field) => field.name === fieldName),
+  };
+
+  collection.fields.forEach((field) => {
+    field.collection = field.collection ?? collection;
+    field.filterable = field.filterable ?? true;
+    field.isAssociationField = field.isAssociationField ?? (() => false);
+  });
+
+  return collection;
+}
+
 describe('SubTableColumnModel row record helpers', () => {
   it('builds the row path from fieldIndex entries', () => {
     expect(buildRowPathFromFieldIndex(['roles:0'])).toEqual(['roles', 0]);
@@ -51,6 +71,171 @@ describe('SubTableColumnModel row record helpers', () => {
     expect(getLatestSubTableRowRecord(form, ['roles:0'], fallback)).toBe(fallback);
   });
 
+  it('provides current item meta for sub-table column data scope variables', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ SubTableColumnModel });
+
+    const tagsCollection = createMockCollection('tags', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'name', title: 'Name', type: 'string', interface: 'input' },
+    ]);
+    const rolesCollection = createMockCollection('roles', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'name', title: 'Name', type: 'string', interface: 'input' },
+      {
+        name: 'tags',
+        title: 'Tags',
+        type: 'hasMany',
+        interface: 'o2m',
+        target: 'tags',
+        targetCollection: tagsCollection,
+        isAssociationField: () => true,
+      },
+    ]);
+    const usersCollection = createMockCollection('users', [
+      { name: 'id', title: 'ID', type: 'integer', interface: 'integer' },
+      { name: 'nickname', title: 'Nickname', type: 'string', interface: 'input' },
+    ]);
+    const rolesField = {
+      name: 'roles',
+      title: 'Roles',
+      type: 'hasMany',
+      interface: 'o2m',
+      collection: usersCollection,
+      target: 'roles',
+      targetCollection: rolesCollection,
+      isAssociationField: () => true,
+    };
+
+    const form = {
+      getFieldValue: vi.fn((path: any) => {
+        if (JSON.stringify(path) === JSON.stringify(['roles', 0])) {
+          return { id: 11, name: 'Admin', tags: [{ id: 7 }] };
+        }
+      }),
+    };
+    const blockModel: any = engine.createModel({ use: 'FlowModel', uid: 'form-block', structure: {} as any });
+    blockModel.context.defineProperty('form', { value: form });
+    blockModel.context.defineProperty('formValues', {
+      value: {
+        id: 1,
+        nickname: 'Alice',
+        roles: [{ id: 11, name: 'Admin' }],
+      },
+    });
+
+    const subTableFieldModel: any = engine.createModel({
+      use: 'FlowModel',
+      uid: 'users.roles',
+      structure: {} as any,
+    });
+    subTableFieldModel.collection = rolesCollection;
+    subTableFieldModel.setProps({ value: [{ id: 11, name: 'Admin' }] });
+    subTableFieldModel.context.defineProperty('collectionField', { value: rolesField });
+    subTableFieldModel.context.defineProperty('fieldPath', { value: 'roles' });
+    subTableFieldModel.context.defineProperty('blockModel', { value: blockModel });
+
+    const column: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.tags',
+      stepParams: {
+        fieldSettings: {
+          init: {
+            fieldPath: 'roles.tags',
+          },
+        },
+      },
+      structure: {} as any,
+    });
+    column.setParent(subTableFieldModel);
+    column.context.defineProperty('blockModel', { value: blockModel });
+    column.subModels = { field: [] };
+
+    const designTimeItemOptions = column.context.getPropertyOptions('item');
+    expect(typeof designTimeItemOptions.meta).toBe('function');
+    const designTimeMeta = await designTimeItemOptions.meta();
+    expect(designTimeMeta.properties.value.title).toBe('Attributes');
+    expect(designTimeMeta.properties.parentItem.properties.value.title).toBe('Attributes');
+
+    const renderCell = column.renderItem();
+    renderCell({
+      id: 'cell-roles-tags-0',
+      rowIdx: 0,
+      record: { id: 11, name: 'Stale admin', tags: [{ id: 7 }] },
+      parentItem: {
+        value: { id: 1, nickname: 'Alice' },
+      },
+    });
+
+    const [rowFork] = Array.from(column.forks ?? []) as any[];
+    const rowItemOptions = rowFork.context.getPropertyOptions('item');
+    expect(typeof rowItemOptions.meta).toBe('function');
+    expect(rowItemOptions.resolveOnServer('value.tags.name')).toBe(true);
+
+    const rowMeta = await rowItemOptions.meta();
+    expect(rowMeta.properties.value.title).toBe('Attributes');
+    expect(rowMeta.properties.parentItem.properties.value.title).toBe('Attributes');
+    expect(rowFork.context.item).toMatchObject({
+      index: 0,
+      length: 1,
+      value: { id: 11, name: 'Admin', tags: [{ id: 7 }] },
+      parentItem: {
+        value: { id: 1, nickname: 'Alice' },
+      },
+    });
+  });
+
+  it('detects variable data scope columns for immediate row commits', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ SubTableColumnModel });
+
+    const inputColumn: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.name',
+      structure: {} as any,
+    });
+    const scopedColumn: any = engine.createModel({
+      use: 'SubTableColumnModel',
+      uid: 'users.roles.tags',
+      structure: {} as any,
+    });
+
+    inputColumn.subModels = {
+      field: {
+        getStepParams: vi.fn(() => undefined),
+      },
+    };
+    scopedColumn.subModels = {
+      field: {
+        getStepParams: vi.fn((flowKey: string, stepKey: string) => {
+          if (flowKey !== 'selectSettings' || stepKey !== 'dataScope') {
+            return undefined;
+          }
+          return {
+            filter: {
+              logic: '$and',
+              items: [{ path: 'name', operator: '$eq', value: '{{ ctx.item.value.name }}' }],
+            },
+          };
+        }),
+      },
+    };
+
+    const parent: any = engine.createModel({
+      use: 'FlowModel',
+      uid: 'users.roles-table',
+      structure: {} as any,
+    });
+    parent.mapSubModels = vi.fn((key: string, iterator: (column: SubTableColumnModel) => unknown) => {
+      if (key !== 'columns') return [];
+      return [inputColumn, scopedColumn].map(iterator);
+    });
+    inputColumn.setParent(parent);
+    scopedColumn.setParent(parent);
+
+    expect(inputColumn.hasFormValueDrivenDataScopeColumn).toBe(true);
+  });
+
   it('treats a display-only column pattern as read-pretty mode', () => {
     expect(isSubTableColumnReadPretty({ props: { pattern: 'readPretty' } })).toBe(true);
     expect(isSubTableColumnReadPretty({ props: { readPretty: true } })).toBe(true);