@gravitee/ui-particles-angular 17.7.1-fix-apim-12804-endpoint-group-headers-sync-e307a3e → 17.7.1-improve-displayif-disabledif-84d4eec

package/fesm2022/gravitee-ui-particles-angular.mjs

@@ -3000,15 +3000,8 @@ class GioFormlyJsonSchemaService {
             mappedField.expressions = {
                 ...mappedField.expressions,
                 hide: field => {
-                    let parentField = field;
-                    while (parentField.parent) {
-                        parentField = parentField.parent;
-                    }
                     try {
-                        return !displayIf({
-                            value: parentField.model,
-                            context,
-                        });
+                        return !displayIf({ field, context });
                     }
                     catch (e) {
                         // Ignore the error and display the field
@@ -3108,15 +3101,8 @@ class GioFormlyJsonSchemaService {
                     // if the parent is already disabled there is no need to change anything at the child level
                     return false;
                 }
-                let parentField = field;
-                while (parentField.parent) {
-                    parentField = parentField.parent;
-                }
                 try {
-                    const isDisabled = disableIf({
-                        value: parentField.model,
-                        context,
-                    });
+                    const isDisabled = disableIf({ field, context });
                     // Useful when full form is re-enabled to sync the fromControl enable/disable state
                     isDisabled ? field.formControl?.disable({ emitEvent: false }) : field.formControl?.enable({ emitEvent: false });
                     return isDisabled;
@@ -3276,18 +3262,90 @@ const getGioIf = (gioIf) => {
     if (isNil($eq) || !isObject($eq)) {
         return undefined;
     }
-    return objectToCheck => {
-        if (isEmpty(objectToCheck)) {
+    return ({ field, context }) => {
+        if (!field) {
             return false;
         }
         return Object.entries($eq)
             .map(([k, v]) => ({ path: k, eqValue: castArray(v) }))
             .every(({ path, eqValue }) => {
-            const value = get(objectToCheck, path);
+            const value = resolveGioIfPath(path, field, context);
             return eqValue.includes(value);
         });
     };
 };
+/**
+ * Resolves a `displayIf` / `disableIf` path against the form state.
+ *
+ * Path syntax (backward compatible):
+ *   - `value.<dotPath>` / `context.<dotPath>` → root model / external context (legacy)
+ *   - `./<dotPath>`                          → current scope (`field.model`)
+ *   - `../<dotPath>` (any depth)             → walks up the ancestor chain by one
+ *                                              scope per `..`, where a "scope" is an
+ *                                              ancestor whose `model` differs from
+ *                                              the previous one (Formly wrappers that
+ *                                              share the same model are skipped).
+ *
+ * Relative paths let conditions inside an array item (or a sub-object of an item)
+ * reference siblings or item-level fields, which is impossible with `value.` since
+ * the array index of the current row is unknown.
+ */
+const resolveGioIfPath = (path, field, context) => {
+    if (path === 'value' || path.startsWith('value.')) {
+        const root = getRootModel(field);
+        return path === 'value' ? root : get(root, path.slice('value.'.length));
+    }
+    if (path === 'context' || path.startsWith('context.')) {
+        return path === 'context' ? context : get(context, path.slice('context.'.length));
+    }
+    if (path.startsWith('./') || path.startsWith('../') || path === '.' || path === '..') {
+        let upCount = 0;
+        let rest = path;
+        let consumed = true;
+        while (consumed) {
+            consumed = false;
+            if (rest.startsWith('../')) {
+                upCount++;
+                rest = rest.slice(3);
+                consumed = true;
+            }
+            else if (rest === '..') {
+                upCount++;
+                rest = '';
+            }
+            else if (rest.startsWith('./')) {
+                rest = rest.slice(2);
+                consumed = true;
+            }
+            else if (rest === '.') {
+                rest = '';
+            }
+        }
+        const scope = getModelChain(field)[upCount];
+        return rest === '' ? scope : get(scope, rest);
+    }
+    return undefined;
+};
+const getRootModel = (field) => {
+    let cur = field;
+    while (cur.parent)
+        cur = cur.parent;
+    return cur.model;
+};
+const getModelChain = (field) => {
+    const chain = [];
+    let cur = field;
+    let last = MODEL_CHAIN_SENTINEL;
+    while (cur) {
+        if (cur.model !== last) {
+            chain.push(cur.model);
+            last = cur.model;
+        }
+        cur = cur.parent;
+    }
+    return chain;
+};
+const MODEL_CHAIN_SENTINEL = Symbol('model-chain-sentinel');
 
 /*
  * Copyright (C) 2023 The Gravitee team (http://gravitee.io)
@@ -3331,8 +3389,6 @@ class GioFormJsonSchemaComponent {
         this.touched = false;
         this.isValid$ = new ReplaySubject(1); // Wait JsonSchema to be loaded to check if it's valid
         this.stateChanges$ = new Subject();
-        this.isWritingValue = false;
-        this.isStable = false;
         if (ngControl) {
             // Setting the value accessor directly (instead of using
             // the providers `NG_VALUE_ACCESSOR`) to avoid running into a circular import.
@@ -3379,9 +3435,9 @@ class GioFormJsonSchemaComponent {
         // Sync control value with default value (without emit event) as long as the component is not ready
         // When formly is initialised, it emits several values as it builds up step by step.
         this.formGroup.valueChanges
-            .pipe(distinctUntilChanged(isEqual), filter(() => this.isReady && !this.isWritingValue && this.isStable), tap(value => {
+            .pipe(distinctUntilChanged(isEqual), tap(value => {
             this.ngControl?.control?.reset(value, { emitEvent: false });
-        }), takeUntil(this.unsubscribe$))
+        }), takeUntil(this.ready), takeUntil(this.unsubscribe$))
             .subscribe();
         // Avoid ExpressionChangedAfterItHasBeenCheckedError on project
         this.changeDetectorRef.markForCheck();
@@ -3439,14 +3495,7 @@ class GioFormJsonSchemaComponent {
     }
     // From ControlValueAccessor
     writeValue(value) {
-        this.isWritingValue = true;
-        this.isStable = false;
         this.model = cloneDeep(value) ?? {};
-        setTimeout(() => {
-            this.isWritingValue = false;
-            this.isStable = true;
-            this.changeDetectorRef.markForCheck();
-        }, 0);
     }
     // From ControlValueAccessor
     registerOnChange(fn) {