@nocobase/client-v2 2.2.0-alpha.1 → 2.2.0-alpha.3

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

@@ -38,12 +38,18 @@ type FormBlockModel = FlowModel & {
   getAclActionName?: () => string;
 };
 
+export type FormValuePatch = {
+  path: NamePath;
+  value: unknown;
+};
+
 export class FormValueRuntime {
   private readonly model: FormBlockModel;
   private readonly getForm: () => FormInstance;
 
   private readonly valuesMirror = observable({});
   private readonly explicitSet = new Set<string>();
+  private readonly userEditedSet = new Set<string>();
   private readonly lastDefaultValueByPathKey = new Map<string, any>();
   private readonly lastWriteMetaByPathKey = new Map<string, FormValueWriteMeta>();
   private readonly observableBindings = new Map<string, ObservableBinding>();
@@ -59,6 +65,8 @@ export class FormValueRuntime {
   private lastObservedToken = 0;
 
   private readonly formValuesProxy: any;
+  private readonly mountedFieldModelsByPathKey = new Map<string, Set<FlowModel>>();
+  private readonly mountedFieldModelPathKeys = new WeakMap<FlowModel, Set<string>>();
 
   private mountedListener?: (payload: { model: FlowModel }) => void;
   private unmountedListener?: (payload: { model: FlowModel }) => void;
@@ -99,6 +107,7 @@ export class FormValueRuntime {
       getFormValueAtPath: (namePath) => this.getFormValueAtPath(namePath),
       setFormValues: (callerCtx, patch, ruleOptions) => this.setFormValues(callerCtx, patch, ruleOptions),
       findExplicitHit: (pathKey) => this.findExplicitHit(pathKey),
+      findUserEditedHit: (pathKey) => this.findUserEditedHit(pathKey),
       lastDefaultValueByPathKey: this.lastDefaultValueByPathKey,
       lastWriteMetaByPathKey: this.lastWriteMetaByPathKey,
       observableBindings: this.observableBindings,
@@ -117,6 +126,7 @@ export class FormValueRuntime {
    *
    * - mode=default → source=default（遵循 explicit/空值覆盖语义）
    * - mode=assign  → source=system（不受 explicit 影响，依赖变化时持续生效）
+   * - mode=override → source=override（首次覆盖已有值，用户修改后停止）
    */
   syncAssignRules(items: FormAssignRuleItem[]) {
     this.ruleEngine.syncAssignRules(items);
@@ -137,6 +147,58 @@ 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) => {
+      if (!item || typeof item !== 'object') return undefined;
+      if (Array.isArray(item) || _.isPlainObject(item)) return undefined;
+      return item;
+    });
+  }
+
   canApplyDefaultValuePatch(namePath: NamePath, resolved: any) {
     if (!namePath?.length) return false;
     if (typeof resolved === 'undefined') return false;
@@ -153,19 +215,24 @@ export class FormValueRuntime {
 
     const canOverwrite = isEmptyValue(current) || currentEqualsLastDefault;
     if (!canOverwrite && _.isEqual(current, nextSnapshot)) {
-      this.lastDefaultValueByPathKey.set(pathKey, nextSnapshot);
+      this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(nextSnapshot));
       return false;
     }
 
     return canOverwrite;
   }
 
+  canApplyOverrideValuePatch(namePath: NamePath) {
+    if (!namePath?.length) return false;
+    return !this.findUserEditedHit(namePathToPathKey(namePath));
+  }
+
   recordDefaultValuePatch(namePath: NamePath, value?: any) {
     if (!namePath?.length) return;
     const pathKey = namePathToPathKey(namePath);
     const snapshot =
       arguments.length >= 2 ? (isObservable(value) ? toJS(value) : value) : this.getFormValueAtPath(namePath);
-    this.lastDefaultValueByPathKey.set(pathKey, snapshot);
+    this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(snapshot));
     const current = this.getFormValueAtPath(namePath);
     const currentSnapshot = isObservable(current) ? toJS(current) : current;
     if (_.isEqual(currentSnapshot, snapshot)) {
@@ -195,9 +262,11 @@ export class FormValueRuntime {
 
     if (!this.mountedListener && !this.unmountedListener) {
       this.mountedListener = ({ model }: { model: FlowModel }) => {
+        this.indexMountedFieldModelTree(model);
         this.ruleEngine.onModelMounted(model);
       };
       this.unmountedListener = ({ model }: { model: FlowModel }) => {
+        this.unindexMountedFieldModelTree(model);
         this.ruleEngine.onModelUnmounted(model);
       };
 
@@ -205,10 +274,12 @@ export class FormValueRuntime {
       engineEmitter.on('model:unmounted', this.unmountedListener);
     }
 
+    this.rebuildMountedFieldModelIndex();
+
     if (options?.sync) {
       const snapshot = this.getFormValuesSnapshot();
       if (snapshot && typeof snapshot === 'object') {
-        _.merge(this.valuesMirror, snapshot);
+        _.merge(this.valuesMirror, this.toMirrorSnapshot(snapshot));
         this.bumpChangeTick();
       }
       this.ruleEngine.enable();
@@ -228,6 +299,7 @@ export class FormValueRuntime {
     }
 
     this.ruleEngine.dispose();
+    this.mountedFieldModelsByPathKey.clear();
 
     for (const binding of this.observableBindings.values()) {
       binding.dispose();
@@ -241,6 +313,7 @@ export class FormValueRuntime {
     if (this.disposed) return;
 
     this.explicitSet.clear();
+    this.userEditedSet.clear();
     this.lastDefaultValueByPathKey.clear();
     this.lastWriteMetaByPathKey.clear();
     this.txWriteCounts.clear();
@@ -258,7 +331,7 @@ export class FormValueRuntime {
       delete (this.valuesMirror as Record<string, any>)[key];
     }
     if (snapshot && typeof snapshot === 'object') {
-      _.merge(this.valuesMirror, snapshot);
+      _.merge(this.valuesMirror, this.toMirrorSnapshot(snapshot));
     }
 
     this.writeSeq += 1;
@@ -266,6 +339,13 @@ export class FormValueRuntime {
     this.ruleEngine.rescheduleAllRules();
   }
 
+  resetUserEditedState() {
+    if (this.disposed) return;
+
+    this.userEditedSet.clear();
+    this.ruleEngine.rescheduleAllRules();
+  }
+
   isSuppressed() {
     return this.suppressFormCallbackDepth > 0;
   }
@@ -292,7 +372,7 @@ export class FormValueRuntime {
         this.writeSeq += 1;
         bumpedWriteSeq = true;
       }
-      _.set(this.valuesMirror, namePath, nextValue);
+      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(nextValue));
       changedPaths.push(namePath);
       const isMeaningfulTouched =
         field?.touched === true && !this.shouldIgnoreSyntheticTouchedInit(namePath, prevValue, nextValue);
@@ -311,6 +391,7 @@ export class FormValueRuntime {
     if (!suppressed && touchedChangedPathKeys.size) {
       for (const key of touchedChangedPathKeys) {
         this.markExplicit(key);
+        this.markUserEdited(key);
       }
     }
 
@@ -374,6 +455,11 @@ export class FormValueRuntime {
       this.explicitSet.delete(key);
     }
 
+    for (const key of Array.from(this.userEditedSet)) {
+      if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
+      this.userEditedSet.delete(key);
+    }
+
     for (const key of Array.from(this.lastDefaultValueByPathKey.keys())) {
       if (!this.isDeletedArrayItemPath(key, snapshot)) continue;
       this.lastDefaultValueByPathKey.delete(key);
@@ -444,6 +530,7 @@ export class FormValueRuntime {
       if (!nextIndexByIdentity.size) continue;
 
       this.reconcileArrayItemSet(this.explicitSet, path, prevValue, nextIndexByIdentity);
+      this.reconcileArrayItemSet(this.userEditedSet, path, prevValue, nextIndexByIdentity);
       this.reconcileArrayItemMap(this.lastDefaultValueByPathKey, path, prevValue, nextIndexByIdentity);
       this.reconcileArrayItemMap(this.lastWriteMetaByPathKey, path, prevValue, nextIndexByIdentity);
       this.reconcileObservableBindings(path, prevValue, nextIndexByIdentity);
@@ -647,7 +734,7 @@ export class FormValueRuntime {
         this.writeSeq += 1;
         bumpedWriteSeq = true;
       }
-      _.set(this.valuesMirror, p, nextValue);
+      _.set(this.valuesMirror, p, this.toMirrorSnapshot(nextValue));
       hasMirrorChange = true;
       actuallyChangedPaths.push(p);
     }
@@ -665,7 +752,11 @@ export class FormValueRuntime {
 
     // 非 default 来源写入：需要使默认值永久失效（explicit）
     for (const p of explicitPathsToMark) {
-      this.markExplicit(namePathToPathKey(p));
+      const pathKey = namePathToPathKey(p);
+      this.markExplicit(pathKey);
+      if (source === 'user') {
+        this.markUserEdited(pathKey);
+      }
     }
 
     if (hasMirrorChange) {
@@ -726,6 +817,9 @@ export class FormValueRuntime {
             seen,
           );
         }
+        if (prevValue.length !== nextValue.length) {
+          return nestedCount + (this.pushExplicitPath(basePath, explicitPaths, seen) ? 1 : 0);
+        }
         return nestedCount;
       }
 
@@ -870,7 +964,8 @@ export class FormValueRuntime {
             } else {
               form.setFieldsValue?.({ [pathKey]: value });
             }
-            _.set(this.valuesMirror, [pathKey], value);
+            _.set(this.valuesMirror, [pathKey], this.toMirrorSnapshot(value));
+            this.syncMountedFieldModelValue([pathKey], value);
           }
           this.bumpChangeTick();
         } finally {
@@ -885,6 +980,9 @@ export class FormValueRuntime {
         if (markExplicit) {
           for (const k of patchKeys) {
             this.markExplicit(k);
+            if (source === 'user') {
+              this.markUserEdited(k);
+            }
           }
         }
 
@@ -969,7 +1067,8 @@ export class FormValueRuntime {
       try {
         for (const { namePath, value } of filteredToWrite) {
           form.setFieldValue?.(namePath, value);
-          _.set(this.valuesMirror, namePath, value);
+          _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(value));
+          this.syncMountedFieldModelValue(namePath, value);
           changedPaths.push(namePath);
         }
         this.bumpChangeTick();
@@ -984,13 +1083,16 @@ export class FormValueRuntime {
       if (markExplicit) {
         for (const { pathKey } of filteredToWrite) {
           this.markExplicit(pathKey);
+          if (source === 'user') {
+            this.markUserEdited(pathKey);
+          }
         }
       }
 
       if (source === 'default') {
         for (const { namePath, pathKey } of filteredToWrite) {
           const current = this.getFormValueAtPath(namePath);
-          this.lastDefaultValueByPathKey.set(pathKey, current);
+          this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(current));
         }
       }
 
@@ -1052,6 +1154,7 @@ export class FormValueRuntime {
     if (this.disposed) return;
     const form = this.getForm?.();
     if (!form) return;
+    if (source === 'override' && this.findUserEditedHit(pathKey)) return;
 
     const prevValue = _.get(this.valuesMirror, namePath);
     if (_.isEqual(prevValue, nextValue)) return;
@@ -1062,7 +1165,8 @@ export class FormValueRuntime {
     this.suppressFormCallbackDepth++;
     try {
       form.setFieldValue?.(namePath, nextValue);
-      _.set(this.valuesMirror, namePath, nextValue);
+      _.set(this.valuesMirror, namePath, this.toMirrorSnapshot(nextValue));
+      this.syncMountedFieldModelValue(namePath, nextValue);
       this.bumpChangeTick();
     } finally {
       this.suppressFormCallbackDepth--;
@@ -1098,7 +1202,10 @@ export class FormValueRuntime {
     }
     this.emitFormValuesChange(payload);
 
-    if (source === 'default' && this.isExplicit(pathKey)) {
+    if (
+      (source === 'default' && this.isExplicit(pathKey)) ||
+      (source === 'override' && this.findUserEditedHit(pathKey))
+    ) {
       const existing = this.observableBindings.get(pathKey);
       if (existing) {
         existing.dispose();
@@ -1107,7 +1214,7 @@ export class FormValueRuntime {
     }
 
     if (source === 'default') {
-      this.lastDefaultValueByPathKey.set(pathKey, this.getFormValueAtPath(namePath));
+      this.lastDefaultValueByPathKey.set(pathKey, this.toMirrorSnapshot(this.getFormValueAtPath(namePath)));
     }
   }
 
@@ -1133,6 +1240,148 @@ export class FormValueRuntime {
     this.model.emitter?.emit?.('formValuesChange', payload);
   }
 
+  private syncMountedFieldModelValue(namePath: NamePath, value: unknown) {
+    const targetKey = namePathToPathKey(namePath);
+    if (!targetKey) return;
+
+    const models = this.mountedFieldModelsByPathKey.get(targetKey);
+    if (!models?.size) return;
+
+    const visited = new Set<FlowModel>();
+    for (const model of Array.from(models)) {
+      this.syncMountedFieldModelValueForModel(model, value, visited);
+    }
+  }
+
+  private syncMountedFieldModelValueForModel(
+    model: FlowModel | null | undefined,
+    value: unknown,
+    visited: Set<FlowModel>,
+  ) {
+    if (!model || visited.has(model)) return;
+    visited.add(model);
+    if (!this.isMountedModelInThisForm(model)) return;
+
+    const nextProps = { value };
+    model.setProps?.(nextProps);
+    const fieldModel = (model as FlowModel & { subModels?: { field?: FlowModel } }).subModels?.field;
+    fieldModel?.setProps?.(nextProps);
+  }
+
+  private rebuildMountedFieldModelIndex() {
+    this.mountedFieldModelsByPathKey.clear();
+    const engine = this.model?.context?.engine;
+    if (!engine || typeof engine.forEachModel !== 'function') return;
+
+    engine.forEachModel((model: FlowModel) => {
+      this.indexMountedFieldModelTree(model);
+    });
+  }
+
+  private indexMountedFieldModelTree(model: FlowModel | null | undefined) {
+    this.visitModelAndForks(model, (item) => this.indexMountedFieldModel(item));
+  }
+
+  private unindexMountedFieldModelTree(model: FlowModel | null | undefined) {
+    this.visitModelAndForks(model, (item) => this.unindexMountedFieldModel(item));
+  }
+
+  private visitModelAndForks(model: FlowModel | null | undefined, visit: (model: FlowModel) => void) {
+    if (!model) return;
+    const visited = new Set<FlowModel>();
+    const walk = (item: FlowModel | null | undefined) => {
+      if (!item || visited.has(item)) return;
+      visited.add(item);
+      visit(item);
+      const forks = (item as FlowModel & { forks?: { forEach?: (cb: (fork: FlowModel) => void) => void } }).forks;
+      forks?.forEach?.((fork) => walk(fork));
+    };
+    walk(model);
+  }
+
+  private indexMountedFieldModel(model: FlowModel) {
+    if (!this.isMountedModelInThisForm(model)) return;
+
+    const pathKeys = new Set<string>();
+    for (const path of this.getMountedModelNamePaths(model)) {
+      const key = namePathToPathKey(path);
+      if (key) pathKeys.add(key);
+    }
+    if (!pathKeys.size) return;
+
+    this.unindexMountedFieldModel(model);
+    this.mountedFieldModelPathKeys.set(model, pathKeys);
+
+    for (const key of pathKeys) {
+      const models = this.mountedFieldModelsByPathKey.get(key) || new Set<FlowModel>();
+      models.add(model);
+      this.mountedFieldModelsByPathKey.set(key, models);
+    }
+  }
+
+  private unindexMountedFieldModel(model: FlowModel) {
+    const pathKeys = this.mountedFieldModelPathKeys.get(model);
+    if (!pathKeys) return;
+
+    for (const key of pathKeys) {
+      const models = this.mountedFieldModelsByPathKey.get(key);
+      if (!models) continue;
+      models.delete(model);
+      if (!models.size) {
+        this.mountedFieldModelsByPathKey.delete(key);
+      }
+    }
+
+    this.mountedFieldModelPathKeys.delete(model);
+  }
+
+  private isMountedModelInThisForm(model: FlowModel) {
+    const blockModel = (model.context as { blockModel?: FlowModel } | undefined)?.blockModel;
+    return !!blockModel && String(blockModel.uid) === String(this.model.uid);
+  }
+
+  private getMountedModelNamePaths(model: FlowModel): NamePath[] {
+    const paths: NamePath[] = [];
+    const push = (value: unknown) => {
+      const path = this.normalizeNamePathValue(value);
+      if (path?.length) paths.push(path);
+    };
+
+    push((model.context as { fieldPathArray?: unknown } | undefined)?.fieldPathArray);
+
+    const props = typeof model.getProps === 'function' ? model.getProps() : (model as { props?: unknown }).props;
+    if (props && typeof props === 'object') {
+      push((props as { name?: unknown }).name);
+    }
+
+    try {
+      const init = model.getStepParams?.('fieldSettings', 'init');
+      if (init && typeof init === 'object') {
+        push((init as { fieldPath?: unknown }).fieldPath);
+      }
+    } catch {
+      // ignore models without field settings
+    }
+
+    const seen = new Set<string>();
+    return paths.filter((path) => {
+      const key = namePathToPathKey(path);
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  private normalizeNamePathValue(value: unknown): NamePath | null {
+    if (Array.isArray(value)) {
+      const path = value.filter((seg): seg is string | number => typeof seg === 'string' || typeof seg === 'number');
+      return path.length === value.length ? path : null;
+    }
+    if (typeof value === 'number') return [value];
+    if (typeof value === 'string' && value) return pathKeyToNamePath(value);
+    return null;
+  }
+
   private markExplicit(pathKey: string) {
     if (this.explicitSet.has(pathKey)) return;
     this.explicitSet.add(pathKey);
@@ -1154,6 +1403,18 @@ export class FormValueRuntime {
     }
   }
 
+  private markUserEdited(pathKey: string) {
+    if (this.userEditedSet.has(pathKey)) return;
+    this.userEditedSet.add(pathKey);
+
+    for (const [k, binding] of Array.from(this.observableBindings.entries())) {
+      if (binding.source !== 'override') continue;
+      if (!this.findUserEditedHit(k)) continue;
+      binding.dispose();
+      this.observableBindings.delete(k);
+    }
+  }
+
   private normalizeObservedNamePath(name: NamePath | string | number | undefined): NamePath | null {
     if (Array.isArray(name)) return name as NamePath;
     if (typeof name === 'number') return [name];
@@ -1216,4 +1477,78 @@ export class FormValueRuntime {
     }
     return null;
   }
+
+  private findUserEditedHit(pathKey: string): string | null {
+    if (this.userEditedSet.has(pathKey)) return pathKey;
+    const namePath = pathKeyToNamePath(pathKey);
+    const prefix: NamePath = [];
+
+    for (let i = 0; i < namePath.length; i++) {
+      prefix.push(namePath[i]);
+      const key = namePathToPathKey(prefix as any);
+      if (!this.userEditedSet.has(key)) continue;
+
+      const nextSeg = namePath[i + 1];
+      if (typeof nextSeg === 'number') {
+        continue;
+      }
+      return key;
+    }
+    for (const key of this.userEditedSet) {
+      if (!this.isDescendantPathKey(key, pathKey)) continue;
+      return key;
+    }
+    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);
+    const parentPath = pathKeyToNamePath(parentKey);
+    if (candidatePath.length <= parentPath.length) return false;
+    return parentPath.every((seg, index) => candidatePath[index] === seg);
+  }
 }

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

@@ -9,7 +9,7 @@
 
 export type NamePath = Array<string | number>;
 
-export type ValueSource = 'default' | 'linkage' | 'user' | 'system';
+export type ValueSource = 'default' | 'linkage' | 'user' | 'system' | 'override';
 
 export type Patch =
   | Record<string, any>
@@ -57,7 +57,7 @@ export interface FormValuesChangePayload {
   allValuesSnapshot?: any;
 }
 
-export type AssignMode = 'default' | 'assign';
+export type AssignMode = 'default' | 'assign' | 'override';
 
 export type FormAssignRuleItem = {
   key?: string;