cabloy 5.1.207 → 5.1.209

package/zova/src/suite-vendor/a-zova/modules/a-form/src/component/form/controller.tsx

@@ -12,7 +12,7 @@ import {
 } from '@tanstack/vue-form';
 import { useSelector } from '@tanstack/vue-store';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { VNode } from 'vue';
+import { markRaw, nextTick, VNode } from 'vue';
 import { z } from 'zod';
 import { $ZodIssue } from 'zod/v4/core';
 import { cast, deepEqual, deepExtend, objectAssignReactive, UseScope } from 'zova';
@@ -31,9 +31,15 @@ import {
   TypeFormSchemaScene,
 } from 'zova-module-a-openapi';
 
+import type { ISchemaRefreshContext } from '../../lib/schemaRefresh.js';
 import type { IResolvedFormLayoutNode, IResolvedFormLayoutTab } from '../../types/formLayout.js';
 
 import { BeanControllerFormBase } from '../../lib/beanControllerFormBase.js';
+import {
+  createSchemaRefreshContract,
+  schemaRefreshFingerprint,
+  SchemaRefreshTracker,
+} from '../../lib/schemaRefresh.js';
 import {
   IFormScope,
   RevalidateLogicProps,
@@ -56,6 +62,7 @@ export interface ControllerFormProps<TFormData extends {} = {}, TSubmitMeta = ne
   data?: TFormData;
   schema?: SchemaObject;
   schemaScene?: TypeFormSchemaScene;
+  localePresentationRefresh?: { identity: string };
   zodSchema?: z.ZodObject<any>;
   validateOnDynamic?: boolean;
   validateOnDynamicLogic?: RevalidateLogicProps;
@@ -69,6 +76,7 @@ export interface ControllerFormProps<TFormData extends {} = {}, TSubmitMeta = ne
   onSubmitData?: TypeFormOnSubmit<TFormData, TSubmitMeta>;
   onShowError?: TypeFormOnShowError<TFormData, TSubmitMeta>;
   onChanged?: (data: TFormData) => void;
+  onSchemaRefreshed?: (data: TFormData) => void;
   slotDefault?: (form: ControllerForm<TFormData, TSubmitMeta>) => VNode;
   slotHeader?: (form: ControllerForm<TFormData, TSubmitMeta>) => VNode;
   slotBody?: (children: VNode, form: ControllerForm<TFormData, TSubmitMeta>) => VNode;
@@ -91,6 +99,11 @@ export class ControllerForm<
   properties: ISchemaObjectExtensionField[] | undefined;
   zovaJsx: ZovaJsx;
   fieldCelEnv: typeof celEnvBase;
+  schemaRefresh: Omit<ISchemaRefreshContext, 'configuration' | 'eligible'>;
+  private _schemaRefreshTracker = markRaw(new SchemaRefreshTracker());
+  private _schemaRefreshEpoch = 0;
+  private _schemaRefreshPending = false;
+  private _schemaRefreshDisposed = false;
 
   @UseScope()
   $$scopeOpenapi: ScopeModuleAOpenapi;
@@ -114,6 +127,37 @@ export class ControllerForm<
     this.properties = this.$computed(() => {
       return this.$sdk.loadSchemaProperties(this.schema, this.$props.schemaScene);
     });
+    this.schemaRefresh = this.$computed(() => {
+      const locale = this.app.meta.locale.current;
+      const schema = this.schema;
+      const policy = this.$props.localePresentationRefresh;
+      const contract = schema
+        ? createSchemaRefreshContract(schema, this.properties ?? [], reference => {
+            return this.$sdk.getSchema(reference).data;
+          })
+        : { ready: !policy, fields: {} };
+      if (schema && this.$sdk.selector !== locale) contract.ready = false;
+      return {
+        locale,
+        identity: policy?.identity,
+        epoch: this._schemaRefreshEpoch,
+        scene: schemaRefreshFingerprint([
+          this.$props.schemaScene,
+          this.formMeta,
+          this.formProvider,
+          this.$props.zodSchema,
+          this.$props.validateOnDynamic,
+          this.$props.validateOnDynamicLogic,
+        ]),
+        enabled: !!policy && !this.$props.zodSchema,
+        contract,
+      };
+    });
+    this.$watch(
+      () => this.schemaRefresh.contract,
+      contract => this._schemaRefreshTracker.prune(contract),
+      { flush: 'sync' },
+    );
     this.fieldCelEnv = this._getFieldCelEnv();
     this.zovaJsx = this.bean._newBeanSimple(
       ZovaJsx,
@@ -124,6 +168,7 @@ export class ControllerForm<
     this.$watch(
       () => this.$props.data,
       (newValue, oldValue) => {
+        ++this._schemaRefreshEpoch;
         if (deepEqual(newValue, oldValue)) return;
         this.reset(this.$props.data);
       },
@@ -138,7 +183,47 @@ export class ControllerForm<
     return !error && this.formState.isValid;
   }
 
+  protected __dispose__() {
+    this._schemaRefreshDisposed = true;
+    ++this._schemaRefreshEpoch;
+    this._schemaRefreshTracker.clear();
+  }
+
+  public hasSchemaRefresh(name: string) {
+    return this._schemaRefreshTracker.has(name);
+  }
+
+  public consumeSchemaRefresh(name: string, configuration: string, eligible: boolean) {
+    return this._schemaRefreshTracker.consume(name, {
+      ...this.schemaRefresh,
+      configuration,
+      eligible,
+    });
+  }
+
+  public schemaFieldRefreshed() {
+    if (this._schemaRefreshPending || !this.$props.onSchemaRefreshed) return;
+    this._schemaRefreshPending = true;
+    const epoch = this._schemaRefreshEpoch;
+    const locale = this.app.meta.locale.current;
+    const { identity, scene } = this.schemaRefresh;
+    void nextTick(() => {
+      this._schemaRefreshPending = false;
+      if (
+        !this._schemaRefreshDisposed &&
+        epoch === this._schemaRefreshEpoch &&
+        locale === this.app.meta.locale.current &&
+        identity === this.schemaRefresh.identity &&
+        scene === this.schemaRefresh.scene &&
+        this.schemaRefresh.contract.ready
+      ) {
+        this.$props.onSchemaRefreshed?.(this.form.state.values);
+      }
+    });
+  }
+
   public reset(values?: TFormData, opts?: { keepDefaultValues?: boolean }): TFormData {
+    ++this._schemaRefreshEpoch;
     this.form.reset(values ?? ({} as TFormData), opts);
     return this.form.state.values;
   }

package/zova/src/suite-vendor/a-zova/modules/a-form/src/component/formField/controller.tsx

@@ -3,12 +3,13 @@ import { useField } from '@tanstack/vue-form';
 import { useSelector } from '@tanstack/vue-store';
 import { markRaw } from 'vue';
 import z from 'zod';
-import { BeanControllerBase, deepEqual, IComponentOptions, Use } from 'zova';
+import { BeanControllerBase, IComponentOptions, Use } from 'zova';
 import { Controller } from 'zova-module-a-bean';
 import { BeanBehaviorsHolder, IBehaviorItem } from 'zova-module-a-behavior';
 
 import type { ControllerForm } from '../form/controller.jsx';
 
+import { schemaRefreshFingerprint } from '../../lib/schemaRefresh.js';
 import { TypeFormField } from '../../types/form.js';
 import {
   constFieldProps,
@@ -29,6 +30,11 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
   static $componentOptions: IComponentOptions = { inheritAttrs: false };
 
   private _formField: TypeFormField;
+  private _initialized = false;
+  private _mounted = false;
+  private _disposed = false;
+  private _readyNotified = false;
+  private _remount = false;
   public propsBucket: IFormFieldRenderContextPropsBucket<TParentData>;
 
   @Use({ injectionScope: 'host' })
@@ -44,6 +50,7 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
     // provide
     this.bean._setBean('$$formField', this);
     // field
+    this._remount = this.$$form.hasSchemaRefresh(this.name);
     this._formField = this._createField();
     // propsBucket
     this.propsBucket = this.$computed(() => {
@@ -51,18 +58,14 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
     });
     // defaultValue
     // this._handleDefaultValue();
-    // watch
+    this.$controllerMounted(() => {
+      this._mounted = true;
+      this._refreshField();
+    });
     this.$watch(
-      () => this.property,
-      (newValue, oldValue) => {
-        if (deepEqual(newValue, oldValue)) return;
-        // defaultValue
-        // this._handleDefaultValue();
-        const options = this._getFormFieldOptions();
-        this._formField.api.update(options as any);
-        this.form.resetField(this.name);
-        this.$props.onFieldStateReady?.(this);
-      },
+      () => [this.$$form.schemaRefresh, this._getRefreshConfiguration()],
+      () => this._refreshField(),
+      { flush: 'post' },
     );
     // behaviors
     await this.$$beanBehaviorsHolder.initialize({
@@ -81,7 +84,77 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
         },
       );
     }
-    this.$props.onFieldStateReady?.(this);
+    this._initialized = true;
+    this._refreshField();
+  }
+
+  protected __dispose__() {
+    this._disposed = true;
+  }
+
+  private _getRefreshConfiguration() {
+    const props = this.$props;
+    return schemaRefreshFingerprint([
+      props.name,
+      props.render,
+      props.options,
+      props.readonly,
+      props.required,
+      props.sys,
+      props.validators,
+      props.behaviors,
+      !!props.onEffect,
+      !!props.slotDefault,
+    ]);
+  }
+
+  private _refreshField() {
+    if (
+      !this._initialized ||
+      this._disposed ||
+      (process.env.CLIENT && this._remount && !this._mounted) ||
+      !this.$$form.schemaRefresh.contract.ready
+    ) {
+      return;
+    }
+    const props = this.$props;
+    // Basic Input owns its binding slot; direct custom slots remain opaque.
+    const inputBindingSlot =
+      props[constFieldProps] === true &&
+      (props.render
+        ? this.$$form.getRenderProvider(props.render)
+        : this.formProvider.components?.Input) === 'basic-input:formFieldInput';
+    const eligible =
+      !props.sys &&
+      !props.behaviors &&
+      !props.onEffect &&
+      (!props.slotDefault || inputBindingSlot) &&
+      Object.values(props.validators ?? {}).every(value => typeof value === 'boolean');
+    const refresh = this.$$form.consumeSchemaRefresh(
+      this.name,
+      this._getRefreshConfiguration(),
+      eligible,
+    );
+    if (refresh.changed) {
+      const value = this.form.getFieldValue(this.name);
+      this.field.api.update(this._getFormFieldOptions() as any);
+      this.form.resetField(this.name);
+      if (refresh.preserve) {
+        this.form.setFieldValue(this.name, value, {
+          dontUpdateMeta: true,
+          dontRunListeners: true,
+          dontValidate: true,
+        });
+        this.field.api.validateSync('change', {});
+      }
+    } else if (this._remount && !this._readyNotified) {
+      this.field.api.update(this._getFormFieldOptions() as any);
+    }
+    if (refresh.changed || !this._readyNotified) {
+      this._readyNotified = true;
+      this.$props.onFieldStateReady?.(this);
+    }
+    if (refresh.changed) this.$$form.schemaFieldRefreshed();
   }
 
   public get form() {
@@ -141,6 +214,8 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
 
   private _createField() {
     const options = this._getFormFieldOptions();
+    // A remount must not seed over a live null/undefined before refresh eligibility is known.
+    if (this._remount) delete options.defaultValue;
     const field = markRaw(useField(options as any)) as any;
     const fieldState = useSelector(field.api.store, state => state) as any;
     return { api: field.api, state: fieldState };