cloud-web-corejs 1.1.0-dev.19 → 1.1.0-dev.21

package/src/components/xform/form-render/fieldControlMixin.js

@@ -0,0 +1,534 @@
+import cloneDeep from "lodash/cloneDeep";
+import {
+  collectFieldControlTargets, readFieldState, writeStateOptions, computeFieldStates,
+  resolveScriptStates, resolveRunMode, applyFieldState, isEntryVisible, sameValue,
+} from "@base/components/xform/form-render/fieldControlEngine";
+
+const TIMEOUT = 30000;
+function createRuntime() {
+  return {
+    epoch: 0, revision: 0, definitions: new WeakMap(), entries: [], byWidget: new WeakMap(),
+    mountStarted: false, mountedReady: false, readyCallback: null,
+    flowWidgets: [], schemas: new Set(), cancelRequests: new Set(), schemaErrors: new Map(),
+    watcher: null, timer: null, task: null, mountTask: null, mounting: false, destroyed: false,
+    dynamicStates: null, dirty: false, appliedRevision: -1, lastDependency: null,
+  };
+}
+
+export default {
+  data() {
+    return {
+      wfParam: null,
+      fieldControlStatus: "idle",
+      fieldControlError: "",
+      fieldControlInitialized: false,
+    };
+  },
+  created() {
+    this._fieldControl = createRuntime();
+  },
+  computed: {
+    fieldControlBlocked() {
+      // 仅准备期隐藏，避免用户在流程限制生效前操作。error 要保留已填内容，提交由 ensure 拦截。
+      return this.isFieldControlEnabled() && this.fieldControlStatus === "preparing";
+    },
+    fieldControlInteractionBlocked() {
+      // 错误时保留表单内容可见，但不允许继续编辑或触发字段/按钮副作用。
+      return this.isFieldControlEnabled()
+        && ["preparing", "error"].includes(this.fieldControlStatus);
+    },
+    fieldControlContextKey() {
+      const info = this.wfParam?.wfInfo || {};
+      return JSON.stringify([
+        !!this.wfParam?.hasWf, info.taskStep, info.taskDefinitionKey, info.nodeCode,
+        info.modelOrders, info.toModify, this.bdService, this.$store?.getters?.companyCode,
+      ]);
+    },
+  },
+  watch: {
+    fieldControlContextKey() {
+      const runtime = this._fieldControl;
+      if (!runtime || !this.isFieldControlEnabled()) return;
+      if (!this.fieldControlInitialized) {
+        if (runtime.mounting || runtime.task) runtime.revision++;
+        return;
+      }
+      const previousMode = runtime.mode;
+      runtime.mode = resolveRunMode(this.formConfig, !!this.wfParam?.hasWf);
+      this.stopFieldControlWatcher();
+      if (previousMode !== runtime.mode || runtime.mode === "continuous") {
+        // 流程节点是权限边界，不能在防抖/后台请求期间继续使用旧节点状态。
+        this.invalidateFieldControl({ immediate: true, blockInteraction: true });
+      } else {
+        runtime.revision++;
+        this.applyFieldControlStates(runtime.dynamicStates);
+      }
+      this.setupFieldControlWatcher();
+    },
+  },
+  beforeDestroy() {
+    this.disposeFieldControl();
+  },
+  methods: {
+    isFieldControlEnabled() {
+      return !!this.formConfig?.dynamicFieldEnabled;
+    },
+    getFieldControlRuntime() {
+      if (!this._fieldControl) this._fieldControl = createRuntime();
+      return this._fieldControl;
+    },
+    prepareFieldControlTargets() {
+      const runtime = this.getFieldControlRuntime();
+      const entries = collectFieldControlTargets(this.widgetList);
+      const widgets = this.getFieldControlWidgets();
+      runtime.entries = entries;
+      runtime.byWidget = new WeakMap();
+      entries.forEach(entry => runtime.byWidget.set(entry.widget, entry));
+      runtime.flowWidgets = Array.from(new Set([...widgets, ...entries.map(e => e.widget)]));
+      runtime.flowWidgets.forEach(widget => {
+        if (!widget.options || runtime.definitions.has(widget)) return;
+        const state = {};
+        ["hidden", "required", "readonly", "disabled"].forEach(key => { state[key] = widget.options[key]; });
+        runtime.definitions.set(widget, state);
+      });
+    },
+    // 动态列/结构晚于首次采集时，先登记未改写的定义，再走动态→流程。
+    syncFieldControlAfterStructure() {
+      if (!this.isFieldControlEnabled()) return false;
+      this.prepareFieldControlTargets();
+      const runtime = this.getFieldControlRuntime();
+      if (this.fieldControlInitialized) {
+        this.applyFieldControlStates(runtime.dynamicStates);
+      } else if (runtime.mounting || runtime.task) {
+        runtime.revision++;
+        runtime.dirty = true;
+      }
+      return true;
+    },
+    createFieldControlProjection(widget) {
+      const runtime = this.getFieldControlRuntime();
+      return { ...widget, options: { ...widget.options, ...runtime.definitions.get(widget) } };
+    },
+    getFieldControlBaseline() {
+      const result = Object.create(null);
+      this.getFieldControlRuntime().entries.forEach(entry => {
+        const projected = this.createFieldControlProjection(entry.widget);
+        this.handleWidgetShowRule(projected);
+        result[entry.key] = readFieldState(projected);
+      });
+      return result;
+    },
+    async showControlledForm(callback) {
+      const runtime = this.getFieldControlRuntime();
+      this.fieldControlStatus = "preparing";
+      runtime.mounting = true;
+      runtime.mountStarted = true;
+      runtime.readyCallback = callback || runtime.readyCallback;
+      const task = (async () => {
+        await this.waitFieldControlTask(this.handleBeforeMounted());
+        if (runtime.destroyed || runtime !== this.getFieldControlRuntime()) return;
+        this.showFormContent = true;
+        await this.$nextTick();
+        await this.waitFieldControlTask(this.handleOnMounted());
+        if (this.formConfig.isLoadEntity) {
+          await this.waitFieldControlTask(this.handleCustomEvent(this.formConfig.formScriptSuccess));
+        }
+        if (runtime.destroyed || runtime !== this.getFieldControlRuntime()) return;
+        runtime.mountedReady = true;
+        await this.$nextTick();
+        await this.waitFieldControlSchemas();
+        this.prepareFieldControlTargets();
+        runtime.mounting = false;
+        await this.initializeFieldControl();
+        this.finishFieldControlMount();
+      })();
+      runtime.mountTask = task;
+      try { await task; } catch (error) {
+        this.failFieldControl(error, runtime);
+      } finally {
+        runtime.mounting = false;
+        if (runtime.mountTask === task) runtime.mountTask = null;
+      }
+    },
+    finishFieldControlMount() {
+      const runtime = this.getFieldControlRuntime();
+      this.handleShowHideRule();
+      const callback = runtime.readyCallback;
+      runtime.readyCallback = null;
+      if (callback) callback();
+    },
+    waitFieldControlTask(task) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("字段规则初始化超时，请重试")), TIMEOUT);
+        Promise.resolve(task).then(value => { clearTimeout(timer); resolve(value); },
+          error => { clearTimeout(timer); reject(error); });
+      });
+    },
+    trackFieldControlSchema(task, retry, owner) {
+      const runtime = this.getFieldControlRuntime();
+      const epoch = runtime.epoch;
+      // 注册时即阻挡操作并废弃旧规则结果，不能等结构请求完成。
+      this.fieldControlInitialized = false;
+      this.fieldControlStatus = "preparing";
+      runtime.revision++;
+      this.stopFieldControlWatcher();
+      const tracked = this.waitFieldControlTask(task).then(value => {
+        if (epoch !== runtime.epoch || runtime.destroyed) return value;
+        runtime.schemaErrors.delete(owner);
+        return value;
+      }).catch(error => {
+        if (epoch === runtime.epoch && !runtime.destroyed) {
+          runtime.schemaErrors.set(owner, { error, retry });
+          this.failFieldControl(error, runtime);
+        }
+        throw error;
+      }).finally(() => { runtime.schemas.delete(tracked); });
+      runtime.schemas.add(tracked);
+      tracked.catch(() => {});
+      if (!runtime.mounting) {
+        tracked.then(() => {
+          if (epoch === runtime.epoch && !runtime.destroyed) return this.initializeFieldControl();
+        }).catch(error => this.failFieldControl(error, runtime));
+      }
+      return tracked;
+    },
+    async waitFieldControlSchemas() {
+      const runtime = this.getFieldControlRuntime();
+      while (runtime.schemas.size) await Promise.all(Array.from(runtime.schemas));
+      if (runtime.schemaErrors.size) throw Array.from(runtime.schemaErrors.values())[0].error;
+    },
+    async initializeFieldControl() {
+      if (!this.isFieldControlEnabled()) return;
+      const runtime = this.getFieldControlRuntime();
+      if (runtime.destroyed) throw new Error("表单已关闭");
+      this.fieldControlStatus = "preparing";
+      this.fieldControlError = "";
+      await this.waitFieldControlSchemas();
+      if (runtime.destroyed || runtime !== this.getFieldControlRuntime()) throw new Error("表单已更新，请重试");
+      this.prepareFieldControlTargets();
+      runtime.mode = resolveRunMode(this.formConfig, !!this.wfParam?.hasWf);
+      runtime.dynamicStates = null;
+      runtime.revision++;
+      runtime.dirty = true;
+      await this.refreshFieldControl();
+      this.setupFieldControlWatcher();
+    },
+    async retryFieldControl() {
+      const runtime = this.getFieldControlRuntime();
+      this.fieldControlError = "";
+      this.fieldControlStatus = "preparing";
+      try {
+        if (!runtime.mountedReady && runtime.mountStarted) {
+          await this.showControlledForm(runtime.readyCallback);
+          return;
+        }
+        const failed = Array.from(runtime.schemaErrors.values());
+        await Promise.all(failed.map(item => item.retry()));
+        await this.initializeFieldControl();
+        if (runtime.mountedReady) this.finishFieldControlMount();
+      } catch (error) { this.failFieldControl(error, runtime); }
+    },
+    fieldControlDependency() {
+      if (this.formConfig.dynamicFieldSourceType === "script") {
+        return (this.formConfig.dynamicFieldTriggerFields || []).map(key => this.formModel[key]);
+      }
+      const keys = new Set();
+      (this.formConfig.dynamicFieldRules || []).forEach(rule =>
+        (rule.conditions || []).forEach(condition => keys.add(condition.field)));
+      return Array.from(keys).map(key => this.formModel[key]);
+    },
+    stopFieldControlWatcher() {
+      const runtime = this.getFieldControlRuntime();
+      if (runtime.watcher) runtime.watcher();
+      if (runtime.timer) clearTimeout(runtime.timer);
+      runtime.watcher = null;
+      runtime.timer = null;
+    },
+    setupFieldControlWatcher() {
+      const runtime = this.getFieldControlRuntime();
+      this.stopFieldControlWatcher();
+      if (runtime.mode !== "continuous") return;
+      runtime.lastDependency = cloneDeep(this.fieldControlDependency());
+      runtime.watcher = this.$watch(() => this.fieldControlDependency(), () => {
+        if (!sameValue(runtime.lastDependency, this.fieldControlDependency())) this.invalidateFieldControl();
+      }, { deep: true, sync: true });
+    },
+    invalidateFieldControl(options = {}) {
+      const runtime = this.getFieldControlRuntime();
+      const immediate = options.immediate === true;
+      if (options.blockInteraction) {
+        this.fieldControlStatus = "preparing";
+        this.fieldControlError = "";
+      }
+      runtime.revision++;
+      runtime.dirty = true;
+      if (runtime.timer) clearTimeout(runtime.timer);
+      const refresh = () => {
+        runtime.timer = null;
+        this.refreshFieldControl().catch(error => this.failFieldControl(error, runtime));
+      };
+      if (immediate) refresh();
+      else runtime.timer = setTimeout(refresh, 120);
+    },
+    async refreshFieldControl() {
+      if (!this.isFieldControlEnabled()) return;
+      const runtime = this.getFieldControlRuntime();
+      if (runtime.timer) clearTimeout(runtime.timer);
+      runtime.timer = null;
+      if (runtime.task) return runtime.task;
+      const epoch = runtime.epoch;
+      const task = (async () => {
+        await this.waitFieldControlSchemas();
+        let attempts = 0;
+        do {
+          if (++attempts > 5) throw new Error("动态规则持续变化或循环赋值，请检查规则后重试");
+          if (runtime.destroyed || epoch !== runtime.epoch) throw new Error("表单已更新，请重试");
+          const revision = runtime.revision;
+          const baseline = this.getFieldControlBaseline();
+          const dependency = cloneDeep(this.fieldControlDependency());
+          let states;
+          let effects = {};
+          if (this.formConfig.dynamicFieldSourceType === "script") {
+            const result = await this.requestFieldControlStates();
+            if (runtime.destroyed || epoch !== runtime.epoch) throw new Error("表单已更新，请重试");
+            if (revision !== runtime.revision) continue;
+            if (runtime.mode === "continuous" && !sameValue(dependency, this.fieldControlDependency())) {
+              runtime.revision++;
+              continue;
+            }
+            ({ states, effects } = resolveScriptStates(result, baseline, !!this.formConfig.dynamicFieldAllowValue));
+          } else {
+            states = computeFieldStates(this.formConfig.dynamicFieldRules || [], baseline, this.formModel || {});
+          }
+          if (revision !== runtime.revision) continue;
+          this.applyFieldControlEffects(effects);
+          await this.$nextTick();
+          if (runtime.destroyed || epoch !== runtime.epoch) throw new Error("表单已更新，请重试");
+          // 首次只执行一次；持续模式才追踪赋值引发的依赖变化。
+          if (runtime.mode === "continuous" && !sameValue(dependency, this.fieldControlDependency())) {
+            runtime.revision++;
+            continue;
+          }
+          if (revision !== runtime.revision) continue;
+          runtime.dynamicStates = states;
+          this.applyFieldControlStates(states);
+          await this.$nextTick();
+          this.syncFieldControlValidation();
+          runtime.appliedRevision = revision;
+          runtime.lastDependency = cloneDeep(this.fieldControlDependency());
+          runtime.dirty = revision !== runtime.revision;
+        } while (runtime.dirty || runtime.appliedRevision !== runtime.revision);
+        this.fieldControlInitialized = true;
+        this.fieldControlStatus = "ready";
+        this.fieldControlError = "";
+      })();
+      runtime.task = task;
+      try { return await task; } catch (error) {
+        if (epoch === runtime.epoch && !runtime.destroyed) this.failFieldControl(error, runtime);
+        throw error;
+      } finally {
+        if (runtime.task === task) runtime.task = null;
+      }
+    },
+    requestFieldControlStates() {
+      const runtime = this.getFieldControlRuntime();
+      const config = this.formConfig;
+      if (!config.dynamicFieldScriptCode) return Promise.reject(new Error("请配置动态规则脚本编码"));
+      const extra = this.handleCustomEvent(config.dynamicFieldScriptParam) || {};
+      const info = this.wfParam?.wfInfo || {};
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error, value) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          runtime.cancelRequests.delete(cancel);
+          if (error) reject(error); else resolve(value);
+        };
+        const cancel = () => finish(new Error("表单已更新，请重试"));
+        const timer = setTimeout(() => finish(new Error("后台动态规则超时，请重试")), TIMEOUT);
+        runtime.cancelRequests.add(cancel);
+        try {
+          const request = this.formHttp({
+            scriptCode: config.dynamicFieldScriptCode,
+            isLoading: false,
+            data: {
+              ...extra,
+              formData: cloneDeep(this.formModel),
+              context: {
+                hasWf: !!this.wfParam?.hasWf, taskStep: info.taskStep,
+                taskDefinitionKey: info.taskDefinitionKey || info.nodeCode,
+                modelOrders: info.modelOrders, toModify: info.toModify,
+              },
+            },
+            success: response => finish(null, response?.objx?.fieldStates),
+            fail: () => finish(new Error("后台动态规则执行失败，请重试")),
+            error: error => finish(error instanceof Error ? error : new Error("后台动态规则请求失败")),
+          });
+          if (request && request.catch) request.catch(error => finish(error));
+        } catch (error) { finish(error); }
+      });
+    },
+    applyFieldControlEffects(effects) {
+      const runtime = this.getFieldControlRuntime();
+      Object.keys(effects).forEach(key => {
+        const entry = runtime.entries.find(item => item.key === key);
+        if (!entry || entry.isContainer) throw new Error("容器不支持动态赋值或选项：" + key);
+        if (effects[key].options !== undefined
+            && !["select", "checkbox", "radio", "cascader", "status"].includes(entry.widget.type)) {
+          throw new Error("组件不支持动态选项：" + key);
+        }
+      });
+      Object.keys(effects).forEach(key => {
+        const entry = runtime.entries.find(item => item.key === key);
+        const effect = effects[key];
+        if (!entry || entry.isContainer) throw new Error("容器不支持动态赋值或选项：" + key);
+        const ref = this.getWidgetRef(entry.refKey);
+        if (effect.options !== undefined) {
+          if (!["select", "checkbox", "radio", "cascader", "status"].includes(entry.widget.type)) {
+            throw new Error("组件不支持动态选项：" + key);
+          }
+          const optionKey = entry.widget.type === "status" ? "statusParam" : "optionItems";
+          if (!sameValue(entry.widget.options[optionKey], effect.options)) {
+            if (ref && ref.setOptionItems) ref.setOptionItems(cloneDeep(effect.options));
+            else this.$set(entry.widget.options, optionKey, cloneDeep(effect.options));
+          }
+        }
+        if (effect.value !== undefined && !sameValue(this.formModel[key], effect.value)) {
+          if (ref && ref.setValue) ref.setValue(cloneDeep(effect.value));
+          else this.$set(this.formModel, key, cloneDeep(effect.value));
+        }
+      });
+    },
+    applyFieldControlStates(states) {
+      const runtime = this.getFieldControlRuntime();
+      this.widgetEditOnWf = this.hanldeWfWidgetNew0();
+      let editable = false;
+      runtime.flowWidgets.forEach(widget => {
+        const entry = runtime.byWidget.get(widget);
+        const projected = this.createFieldControlProjection(widget);
+        this.handleWidgetShowRule(projected);
+        if (entry && states?.[entry.key]) writeStateOptions(projected.options, states[entry.key]);
+        this.applyWorkflowFieldControl(projected);
+        if (widget.formItemFlag && this.disabledMode) projected.options.disabled = true;
+        const effective = readFieldState(projected);
+        // 非输入按钮不在动态目标范围，但仍应用流程自身的 disabled。
+        if (!widget.formItemFlag && widget.category !== "container" && projected.options.disabled !== undefined) {
+          effective.disabled = projected.options.disabled;
+        }
+        const target = entry || { widget, refKey: widget.options.name, isContainer: widget.category === "container" };
+        applyFieldState(target, effective, name => this.getWidgetRef(name));
+        if (widget.formItemFlag && !projected.options.hidden && !projected.options.disabled && !projected.options.readonly) editable = true;
+      });
+      this.wfModifyEnabled = !!this.wfParam?.wfInfo?.toModify && editable && !this.getReadMode();
+      this.syncFieldControlValidation();
+    },
+    syncFieldControlValidation() {
+      const runtime = this.getFieldControlRuntime();
+      runtime.entries.forEach(entry => {
+        if (entry.isContainer) return;
+        const ref = this.getWidgetRef(entry.refKey);
+        if (!ref || ref.field !== entry.widget) return;
+        if (!isEntryVisible(entry)) {
+          if (ref.clearFieldRules) ref.clearFieldRules();
+        } else if (ref.buildFieldRules) ref.buildFieldRules();
+      });
+    },
+    isFieldControlFieldVisible(widget) {
+      const entry = this.getFieldControlRuntime().byWidget.get(widget);
+      return !entry || isEntryVisible(entry);
+    },
+    failFieldControl(error, runtime = this.getFieldControlRuntime()) {
+      if (runtime.destroyed || runtime !== this.getFieldControlRuntime()) return;
+      this.fieldControlStatus = "error";
+      this.fieldControlError = error?.message || "字段规则执行失败，请重试";
+      // 即使动态重算失败，也要用最后一份可信动态状态重新收口当前流程限制。
+      // 交互由 fieldControlInteractionBlocked 独立阻断，不污染定义基线。
+      if (runtime.flowWidgets.length) {
+        try { this.applyFieldControlStates(runtime.dynamicStates); } catch (applyError) { /* 保留原始失败 */ }
+      }
+    },
+    async ensureFieldControlReady() {
+      if (!this.isFieldControlEnabled()) return;
+      const runtime = this.getFieldControlRuntime();
+      if (runtime.mountTask) await runtime.mountTask;
+      if (runtime.destroyed) throw new Error("表单已关闭");
+      if (this.fieldControlStatus === "error") throw new Error(this.fieldControlError);
+      if (!this.fieldControlInitialized) await this.initializeFieldControl();
+      if (this.fieldControlStatus === "error") throw new Error(this.fieldControlError);
+      if (runtime.mode === "continuous" && !sameValue(runtime.lastDependency, this.fieldControlDependency())) {
+        runtime.revision++;
+        runtime.dirty = true;
+      }
+      // 提交不等防抖；旧 task 结束后若仍 dirty 必须再算一轮，不能把过期结果交给校验。
+      while (runtime.dirty || runtime.task) {
+        if (runtime.destroyed) throw new Error("表单已关闭");
+        if (this.fieldControlStatus === "error") throw new Error(this.fieldControlError);
+        if (runtime.timer) {
+          clearTimeout(runtime.timer);
+          runtime.timer = null;
+        }
+        await this.refreshFieldControl();
+        await this.$nextTick();
+      }
+    },
+    guardFieldControlWorkflow(option) {
+      if (!this.isFieldControlEnabled()) return option;
+      const snapshots = {};
+      const wrapped = { ...option };
+      [["onStart", "onBeforeStartSubmit", "start"], ["onClickAgree", "onBeforeAgree", "agree"]]
+        .forEach(([begin, submit, key]) => {
+          [begin, submit].forEach(hook => {
+            const original = option[hook];
+            wrapped[hook] = async (done, ...args) => {
+              try {
+                await this.ensureFieldControlReady();
+                if (hook === begin) snapshots[key] = this.captureFieldControlSubmission();
+                else await this.assertFieldControlSubmission(snapshots[key]);
+                let completed = false;
+                const once = (...values) => {
+                  if (completed) return;
+                  completed = true;
+                  done(...values);
+                };
+                // 保留原钩子的校验范围，不为直接审批额外引入整单必填。
+                if (original) await original.call(option, once, ...args);
+                else once();
+              } catch (error) { this.$message.error(error.message); }
+            };
+          });
+        });
+      return wrapped;
+    },
+    captureFieldControlSubmission() {
+      if (!this.isFieldControlEnabled()) return null;
+      return {
+        data: cloneDeep(this.formModel), context: this.fieldControlContextKey,
+        revision: this.getFieldControlRuntime().revision,
+      };
+    },
+    async assertFieldControlSubmission(snapshot) {
+      if (!snapshot) return;
+      await this.ensureFieldControlReady();
+      if (!sameValue(snapshot.data, this.formModel) || snapshot.context !== this.fieldControlContextKey
+          || snapshot.revision !== this.getFieldControlRuntime().revision) {
+        throw new Error("确认期间表单或流程已变化，请重新保存");
+      }
+    },
+    disposeFieldControl() {
+      const runtime = this.getFieldControlRuntime();
+      this.stopFieldControlWatcher();
+      runtime.epoch++;
+      runtime.destroyed = true;
+      runtime.cancelRequests.forEach(cancel => cancel());
+      runtime.cancelRequests.clear();
+    },
+    resetFieldControl() {
+      this.disposeFieldControl();
+      this._fieldControl = createRuntime();
+      this.fieldControlInitialized = false;
+      this.fieldControlStatus = "idle";
+      this.fieldControlError = "";
+    },
+  },
+};