@nocobase/client-v2 2.1.0-alpha.24 → 2.1.0-alpha.26

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

@@ -17,6 +17,7 @@ import { namePathToPathKey, parsePathString, pathKeyToNamePath } from './path';
 import type { FormAssignRuleItem, FormValueWriteMeta, NamePath, Patch, SetOptions, ValueSource } from './types';
 import { createTxId, isEmptyValue } from './utils';
 import { isToManyAssociationField } from '../../../../internal/utils/modelUtils';
+import { getSubTableRowIdentity } from '../../../fields/AssociationFieldModel/SubTableFieldModel/rowIdentity';
 
 /** Symbol to indicate rule value resolution should be skipped */
 const SKIP_RULE_VALUE = Symbol('SKIP_RULE_VALUE');
@@ -51,6 +52,7 @@ type RuntimeRule = {
 
 type ObservableBinding = {
   source: ValueSource;
+  pathKey: string;
   dispose: () => void;
 };
 
@@ -1172,7 +1174,6 @@ export class RuleEngine {
 
     const ruleContext = this.prepareRuleContext(rule);
     const { baseCtx, targetNamePath, targetKey, clearDeps, disposeBinding } = ruleContext;
-
     if (!this.shouldRunRule(rule, targetNamePath, targetKey, baseCtx)) {
       clearDeps(state);
       disposeBinding();
@@ -1487,18 +1488,59 @@ export class RuleEngine {
     // 编辑态默认值规则：
     // - 顶层编辑表单：不应用默认值
     // - 子表单：仅对“新增行/新增对象”（__is_new__ = true）应用默认值
-    let item: any;
+    return this.getItemContext(baseCtx)?.__is_new__ === true;
+  }
+
+  private isStaleToManyItemContext(baseCtx: any): boolean {
+    const item = this.getItemContext(baseCtx);
+    if (!Number.isFinite(item?.index) || !Number.isFinite(item?.length)) return false;
+    return item.index < 0 || item.index >= item.length;
+  }
+
+  private getItemContext(baseCtx: any) {
     try {
-      item = baseCtx?.item;
+      return baseCtx?.item;
     } catch {
-      item = undefined;
+      return undefined;
     }
+  }
 
-    if (!item || typeof item !== 'object') {
-      return false;
+  private getRowTargetKey(baseCtx: any, rowPath: NamePath): string | string[] {
+    let collection = this.getRootCollection() || this.getCollectionFromContext(baseCtx);
+    let field: any;
+    for (const seg of rowPath) {
+      if (typeof seg === 'number') continue;
+      if (typeof seg !== 'string' || !seg || !collection?.getField) break;
+
+      field = collection?.getField?.(seg);
+      if (!field?.isAssociationField?.()) break;
+      collection = field?.targetCollection;
     }
 
-    return item.__is_new__ === true;
+    const raw = field?.targetCollection?.filterTargetKey ?? field?.targetCollection?.filterByTk ?? field?.targetKey;
+    if (Array.isArray(raw)) {
+      const keys = raw.filter((key): key is string => typeof key === 'string' && !!key);
+      return keys.length ? keys : 'id';
+    }
+    return typeof raw === 'string' && raw ? raw : 'id';
+  }
+
+  private isMismatchedToManyItemContext(baseCtx: any, targetNamePath: NamePath): boolean {
+    const item = this.getItemContext(baseCtx);
+    if (!item) return false;
+
+    for (let i = targetNamePath.length - 1; i >= 0; i--) {
+      if (typeof targetNamePath[i] !== 'number') continue;
+
+      const rowPath = targetNamePath.slice(0, i + 1);
+      const targetKey = this.getRowTargetKey(baseCtx, rowPath);
+      const currentRow = this.options.getFormValueAtPath(rowPath);
+      const currentIdentity = getSubTableRowIdentity(currentRow, targetKey);
+      const itemIdentity = getSubTableRowIdentity(item.value, targetKey);
+      return !!currentIdentity && !!itemIdentity && currentIdentity !== itemIdentity;
+    }
+
+    return false;
   }
 
   private shouldRunRule(
@@ -1509,6 +1551,8 @@ export class RuleEngine {
   ): boolean {
     if (!rule.getEnabled()) return false;
     if (!targetNamePath || !targetKey) return false;
+    if (this.isStaleToManyItemContext(baseCtx)) return false;
+    if (this.isMismatchedToManyItemContext(baseCtx, targetNamePath)) return false;
     if (rule.source === 'default') {
       if (!this.shouldApplyDefaultRuleInCurrentState(baseCtx)) return false;
       if (this.options.findExplicitHit(targetKey)) return false;
@@ -1808,6 +1852,19 @@ export class RuleEngine {
       }
     })();
 
+    // Row/grid rules resolve target paths through fieldIndex (for example `roles.title`
+    // -> `roles[1].title`). When a row is deleted or reordered, the rule must reschedule
+    // even if its value/condition does not reference ctx.item directly.
+    const fieldIndex = baseCtx?.model?.context?.fieldIndex ?? baseCtx?.fieldIndex;
+    const shouldWatchFieldIndex = Array.isArray(fieldIndex) && fieldIndex.some((it) => typeof it === 'string');
+    if (shouldWatchFieldIndex) {
+      const fieldIndexDisposer = reaction(
+        () => this.getFieldIndexSignature(baseCtx),
+        () => this.scheduleRule(rule.id),
+      );
+      state.depDisposers.push(fieldIndexDisposer);
+    }
+
     for (const depKey of deps) {
       if (depKey === 'fv:*') {
         continue;
@@ -1841,14 +1898,9 @@ export class RuleEngine {
       const subPath = sep >= 0 ? rest.slice(sep + 1) : '';
       const depPath = subPath ? (parsePathString(subPath).filter((seg) => typeof seg !== 'object') as NamePath) : [];
 
-      // 特殊变量：item 为 RuleEngine 注入的计算属性（不直接存在于 baseCtx 上），其 parentItem/index 链依赖 fieldIndex。
+      // 特殊变量：item 为 RuleEngine 注入的计算属性（不直接存在于 baseCtx 上）。
+      // fieldIndex 的变化已统一在上面监听，这里只补 item 自身取值的依赖。
       if (varName === 'item') {
-        const fieldIndexDisposer = reaction(
-          () => this.getFieldIndexSignature(baseCtx),
-          () => this.scheduleRule(rule.id),
-        );
-        state.depDisposers.push(fieldIndexDisposer);
-
         if (depPath.length) {
           const trackingFormValues = this.options.createTrackingFormValues({ deps: new Set(), wildcard: false });
           const itemValueDisposer = reaction(

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

@@ -16,6 +16,7 @@ import { createFormValuesProxy } from './deps';
 import { createFormPatcher } from './form-patch';
 import { namePathToPathKey, pathKeyToNamePath, resolveDynamicNamePath } from './path';
 import { RuleEngine } from './rules';
+import { getSubTableRowIdentity } from '../../../fields/AssociationFieldModel/SubTableFieldModel/rowIdentity';
 import type {
   FormAssignRuleItem,
   FormValueWriteMeta,
@@ -25,10 +26,11 @@ import type {
   SetOptions,
   ValueSource,
 } from './types';
-import { createTxId, MAX_WRITES_PER_PATH_PER_TX } from './utils';
+import { createTxId, isEmptyValue, MAX_WRITES_PER_PATH_PER_TX } from './utils';
 
 type ObservableBinding = {
   source: ValueSource;
+  pathKey: string;
   dispose: () => void;
 };
 
@@ -241,6 +243,7 @@ export class FormValueRuntime {
 
     const changedPaths: NamePath[] = [];
     const touchedChangedPathKeys = new Set<string>();
+    let hasMeaningfulTouchedChange = false;
     let bumpedWriteSeq = false;
     for (const field of changedFields || []) {
       const name = field?.name;
@@ -259,8 +262,11 @@ export class FormValueRuntime {
       }
       _.set(this.valuesMirror, namePath, nextValue);
       changedPaths.push(namePath);
-      if (field?.touched === true) {
+      const isMeaningfulTouched =
+        field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
+      if (isMeaningfulTouched) {
         touchedChangedPathKeys.add(namePathToPathKey(namePath));
+        hasMeaningfulTouchedChange = true;
       }
     }
 
@@ -279,7 +285,7 @@ export class FormValueRuntime {
       return;
     }
 
-    const isUser = changedFields.some((f) => f?.touched === true);
+    const isUser = hasMeaningfulTouchedChange;
     const source: ValueSource = isUser ? 'user' : 'system';
 
     const writeSeq = this.writeSeq;
@@ -299,16 +305,267 @@ export class FormValueRuntime {
     });
   }
 
+  private shouldIgnoreSyntheticTouchedInit(namePath: NamePath, prevValue: any, nextValue: any) {
+    if (!namePath?.length) return false;
+    if (typeof prevValue !== 'undefined') return false;
+    if (!isEmptyValue(nextValue)) return false;
+
+    for (let i = namePath.length - 1; i >= 0; i--) {
+      if (typeof namePath[i] !== 'number') continue;
+      const rowPath = namePath.slice(0, i + 1);
+      const rowValue = this.getFormValueAtPath(rowPath);
+      return !!rowValue?.__is_new__;
+    }
+
+    return false;
+  }
+
+  private isDeletedArrayItemPath(path: NamePath | string, snapshot: any) {
+    const namePath = Array.isArray(path) ? path : pathKeyToNamePath(path);
+    if (!namePath?.length) return false;
+
+    for (let i = namePath.length - 1; i >= 0; i--) {
+      if (typeof namePath[i] !== 'number') continue;
+      const rowPath = namePath.slice(0, i + 1);
+      return typeof _.get(snapshot, rowPath as any) === 'undefined';
+    }
+
+    return false;
+  }
+
+  private pruneDeletedArrayItemState(snapshot: any) {
+    for (const key of Array.from(this.explicitSet)) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      this.explicitSet.delete(key);
+    }
+
+    for (const key of Array.from(this.lastDefaultValueByPathKey.keys())) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      this.lastDefaultValueByPathKey.delete(key);
+    }
+
+    for (const key of Array.from(this.lastWriteMetaByPathKey.keys())) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      this.lastWriteMetaByPathKey.delete(key);
+    }
+
+    for (const [key, binding] of Array.from(this.observableBindings.entries())) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      binding.dispose();
+      this.observableBindings.delete(key);
+    }
+  }
+
+  private getArrayItemTargetKey(arrayPath?: NamePath): string | string[] {
+    let collection = this.model?.context?.collection;
+    let field: any;
+    for (const seg of arrayPath || []) {
+      if (typeof seg === 'number') continue;
+      if (typeof seg !== 'string' || !collection?.getField) break;
+
+      field = collection?.getField?.(seg);
+      if (!field?.isAssociationField?.()) break;
+      collection = field?.targetCollection;
+    }
+
+    const raw = field?.targetCollection?.filterTargetKey ?? field?.targetCollection?.filterByTk ?? field?.targetKey;
+    if (Array.isArray(raw)) {
+      const keys = raw.filter((key): key is string => typeof key === 'string' && !!key);
+      return keys.length ? keys : 'id';
+    }
+    return typeof raw === 'string' && raw ? raw : 'id';
+  }
+
+  private getArrayItemIdentity(item: any, arrayPath?: NamePath) {
+    return getSubTableRowIdentity(item, this.getArrayItemTargetKey(arrayPath));
+  }
+
+  private reconcileArrayItemState(rawChangedPaths: NamePath[], changedValues: any, snapshot: any) {
+    const seenPathKeys = new Set<string>();
+
+    for (const path of rawChangedPaths || []) {
+      if (!path?.length) continue;
+      const pathKey = namePathToPathKey(path);
+      if (seenPathKeys.has(pathKey)) continue;
+      seenPathKeys.add(pathKey);
+
+      const prevValue = _.get(this.valuesMirror, path as any);
+      const nextValue = this.getObservedChangedValue(path, changedValues, snapshot);
+      if (!Array.isArray(prevValue) || !Array.isArray(nextValue)) continue;
+
+      const nextIndexByIdentity = new Map<string, number>();
+      nextValue.forEach((item, index) => {
+        const identity = this.getArrayItemIdentity(item, path);
+        if (identity) {
+          nextIndexByIdentity.set(identity, index);
+        }
+      });
+
+      if (!nextIndexByIdentity.size) continue;
+
+      this.reconcileArrayItemSet(this.explicitSet, path, prevValue, nextIndexByIdentity);
+      this.reconcileArrayItemMap(this.lastDefaultValueByPathKey, path, prevValue, nextIndexByIdentity);
+      this.reconcileArrayItemMap(this.lastWriteMetaByPathKey, path, prevValue, nextIndexByIdentity);
+      this.reconcileObservableBindings(path, prevValue, nextIndexByIdentity);
+    }
+  }
+
+  private getReconciledArrayItemPath(
+    pathKey: string,
+    arrayPath: NamePath,
+    prevItems: any[],
+    nextIndexByIdentity: Map<string, number>,
+  ) {
+    const namePath = pathKeyToNamePath(pathKey);
+    if (namePath.length <= arrayPath.length) return { action: 'keep' as const };
+
+    for (let i = 0; i < arrayPath.length; i++) {
+      if (namePath[i] !== arrayPath[i]) return { action: 'keep' as const };
+    }
+
+    const oldIndex = namePath[arrayPath.length];
+    if (typeof oldIndex !== 'number') return { action: 'keep' as const };
+
+    const identity = this.getArrayItemIdentity(prevItems[oldIndex], arrayPath);
+    if (!identity) return { action: 'keep' as const };
+
+    const nextIndex = nextIndexByIdentity.get(identity);
+    if (nextIndex == null) return { action: 'delete' as const };
+    if (nextIndex === oldIndex) return { action: 'keep' as const };
+
+    const nextPath = [...namePath];
+    nextPath[arrayPath.length] = nextIndex;
+    return { action: 'move' as const, key: namePathToPathKey(nextPath) };
+  }
+
+  private reconcileArrayItemSet(
+    target: Set<string>,
+    arrayPath: NamePath,
+    prevItems: any[],
+    nextIndexByIdentity: Map<string, number>,
+  ) {
+    const nextEntries = new Set<string>();
+    let changed = false;
+
+    for (const key of target) {
+      const result = this.getReconciledArrayItemPath(key, arrayPath, prevItems, nextIndexByIdentity);
+      if (result.action === 'delete') {
+        changed = true;
+        continue;
+      }
+      if (result.action === 'move') {
+        changed = true;
+        nextEntries.add(result.key);
+        continue;
+      }
+      nextEntries.add(key);
+    }
+
+    if (!changed) return;
+    target.clear();
+    for (const key of nextEntries) {
+      target.add(key);
+    }
+  }
+
+  private reconcileArrayItemMap<T>(
+    target: Map<string, T>,
+    arrayPath: NamePath,
+    prevItems: any[],
+    nextIndexByIdentity: Map<string, number>,
+  ) {
+    const nextEntries = new Map<string, T>();
+    let changed = false;
+
+    for (const [key, value] of target) {
+      const result = this.getReconciledArrayItemPath(key, arrayPath, prevItems, nextIndexByIdentity);
+      if (result.action === 'delete') {
+        changed = true;
+        continue;
+      }
+      if (result.action === 'move') {
+        changed = true;
+        nextEntries.set(result.key, value);
+        continue;
+      }
+      nextEntries.set(key, value);
+    }
+
+    if (!changed) return;
+    target.clear();
+    for (const [key, value] of nextEntries) {
+      target.set(key, value);
+    }
+  }
+
+  private reconcileObservableBindings(arrayPath: NamePath, prevItems: any[], nextIndexByIdentity: Map<string, number>) {
+    const nextEntries = new Map<string, ObservableBinding>();
+    let changed = false;
+
+    for (const [key, binding] of this.observableBindings) {
+      const result = this.getReconciledArrayItemPath(key, arrayPath, prevItems, nextIndexByIdentity);
+      if (result.action === 'delete') {
+        changed = true;
+        binding.dispose();
+        continue;
+      }
+      if (result.action === 'move') {
+        changed = true;
+        binding.pathKey = result.key;
+        nextEntries.set(result.key, binding);
+        continue;
+      }
+      nextEntries.set(key, binding);
+    }
+
+    if (!changed) return;
+    this.observableBindings.clear();
+    for (const [key, binding] of nextEntries) {
+      this.observableBindings.set(key, binding);
+    }
+  }
+
+  private getObservedChangedValue(path: NamePath, changedValues: any, snapshot: any) {
+    if (path?.length === 1) {
+      const key = path[0];
+      if (
+        (typeof key === 'string' || typeof key === 'number') &&
+        changedValues &&
+        Object.prototype.hasOwnProperty.call(changedValues, key)
+      ) {
+        return changedValues[key];
+      }
+    }
+
+    return _.get(snapshot, path as any);
+  }
+
+  private getObservedSnapshot(changedValues: any, snapshot: any) {
+    if (!changedValues || typeof changedValues !== 'object') return snapshot;
+    if (!snapshot || typeof snapshot !== 'object') return changedValues;
+
+    let observed = snapshot;
+    for (const key of Object.keys(changedValues)) {
+      if (observed === snapshot) {
+        observed = Array.isArray(snapshot) ? [...snapshot] : { ...snapshot };
+      }
+      _.set(observed, [key], changedValues[key]);
+    }
+
+    return observed;
+  }
+
   handleFormValuesChange(changedValues: any, allValues: any) {
     if (this.disposed) return;
     if (this.isSuppressed()) {
       return;
     }
 
+    const changedValuePaths: NamePath[] = Object.keys(changedValues || {}).map((k) => [k]);
     const rawChangedPaths: NamePath[] =
       this.lastObservedChangedPaths && this.lastObservedChangedPaths.length
         ? this.lastObservedChangedPaths
-        : Object.keys(changedValues || {}).map((k) => [k]);
+        : changedValuePaths;
 
     const source: ValueSource = this.lastObservedSource ?? 'user';
 
@@ -316,16 +573,21 @@ export class FormValueRuntime {
     this.lastObservedChangedPaths = null;
     this.lastObservedSource = null;
 
-    const snapshot = allValues && typeof allValues === 'object' ? allValues : this.getFormValuesSnapshot();
+    const rawSnapshot = allValues && typeof allValues === 'object' ? allValues : this.getFormValuesSnapshot();
+    const snapshot = this.getObservedSnapshot(changedValues, rawSnapshot);
+    this.reconcileArrayItemState([...rawChangedPaths, ...changedValuePaths], changedValues, snapshot);
+    this.pruneDeletedArrayItemState(snapshot);
 
-    const explicitPaths = this.deriveExplicitPaths(rawChangedPaths, snapshot, this.valuesMirror);
+    const explicitPaths = this.deriveExplicitPaths(rawChangedPaths, changedValues, snapshot, this.valuesMirror).filter(
+      (path) => !this.isDeletedArrayItemPath(path, snapshot),
+    );
 
     let hasMirrorChange = false;
     let bumpedWriteSeq = false;
     const actuallyChangedPaths: NamePath[] = [];
     for (const p of rawChangedPaths) {
       if (!p?.length) continue;
-      const nextValue = _.get(snapshot, p);
+      const nextValue = this.getObservedChangedValue(p, changedValues, snapshot);
       const prevValue = _.get(this.valuesMirror, p);
       if (_.isEqual(prevValue, nextValue)) continue;
       if (!bumpedWriteSeq) {
@@ -364,14 +626,14 @@ export class FormValueRuntime {
     });
   }
 
-  private deriveExplicitPaths(rawChangedPaths: NamePath[], snapshot: any, valuesMirrorBefore: any): NamePath[] {
+  private deriveExplicitPaths(rawChangedPaths: NamePath[], changedValues: any, snapshot: any, valuesMirrorBefore: any) {
     const explicitPaths: NamePath[] = [];
     const seen = new Set<string>();
 
     for (const path of rawChangedPaths || []) {
       if (!path?.length) continue;
       const prevValue = _.get(valuesMirrorBefore, path as any);
-      const nextValue = _.get(snapshot, path as any);
+      const nextValue = this.getObservedChangedValue(path, changedValues, snapshot);
       this.collectExplicitDiffPaths(prevValue, nextValue, path, explicitPaths, seen);
     }
 
@@ -667,19 +929,30 @@ export class FormValueRuntime {
         }
       }
 
-      for (const { namePath, rawValue, pathKey } of filteredToWrite) {
+      for (const { rawValue, pathKey } of filteredToWrite) {
         if (!isObservable(rawValue)) continue;
         const obs = rawValue;
 
+        const binding: ObservableBinding = { source, pathKey, dispose: () => {} };
         const disposer = observe(obs, () => {
-          this.applyBoundValue(callerCtx, namePath, pathKey, toJS(obs), source, linkageScopeDepth, linkageTxId);
+          const currentPathKey = binding.pathKey;
+          this.applyBoundValue(
+            callerCtx,
+            pathKeyToNamePath(currentPathKey),
+            currentPathKey,
+            toJS(obs),
+            source,
+            linkageScopeDepth,
+            linkageTxId,
+          );
         });
+        binding.dispose = disposer;
 
         const existing = this.observableBindings.get(pathKey);
         if (existing) {
           existing.dispose();
         }
-        this.observableBindings.set(pathKey, { source, dispose: disposer });
+        this.observableBindings.set(pathKey, binding);
       }
 
       if (triggerEvent) {

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

@@ -34,6 +34,7 @@ import { SubTableFieldModel } from '.';
 import { FieldModel } from '../../../base/FieldModel';
 import { FieldDeletePlaceholder, CustomWidth } from '../../../blocks/table/TableColumnModel';
 import { buildDynamicNamePath } from '../../../blocks/form/dynamicNamePath';
+import { getSubTableRowIdentity } from './rowIdentity';
 
 const SubTableRowRuleBinder: React.FC<{ model: any }> = ({ model }) => {
   React.useEffect(() => {
@@ -355,7 +356,11 @@ const MemoCell: React.FC<CellProps> = React.memo(
   },
   (prev, next) => {
     return (
-      prev.value === next.value && prev.id === next.id && prev.memoKey === next.memoKey && prev.width === next.width
+      prev.value === next.value &&
+      prev.id === next.id &&
+      prev.memoKey === next.memoKey &&
+      prev.width === next.width &&
+      prev.rowIdx === next.rowIdx
     );
   },
 );
@@ -548,7 +553,10 @@ export class SubTableColumnModel<
       const baseFieldIndex = parentFieldIndex ?? (this.parent as any)?.context?.fieldIndex ?? this.context?.fieldIndex;
       const baseArr = Array.isArray(baseFieldIndex) ? baseFieldIndex : [];
       const baseIndexKey = baseArr.length ? baseArr.join('|') : 'root';
-      const rowForkKey = `row:${baseIndexKey}:${String(rowIdx)}`;
+      const filterTargetKey =
+        (this.parent as any)?.collection?.filterTargetKey ?? (this.parent as any)?.context?.collection?.filterTargetKey;
+      const rowIdentity = getSubTableRowIdentity(record, filterTargetKey) ?? `row:${String(rowIdx)}`;
+      const rowForkKey = `row:${baseIndexKey}:${rowIdentity}:${String(rowIdx)}`;
       const rowFork: any = (() => {
         const fork = this.createFork({}, rowForkKey);
         const associationFieldPath =