@sumaris-net/ngx-components 18.16.3 → 18.16.5

package/fesm2022/sumaris-net.ngx-components.mjs

@@ -162,6 +162,7 @@ const ENVIRONMENT = new InjectionToken('ENV');
 class Environment {
     name;
     version;
+    buildDate;
     production;
     // An URL to load external environment file (e.g. 'assets/environments/environment.json'
     externalEnvironmentUrl;
@@ -180,6 +181,8 @@ class Environment {
     peerDefaultPrefix;
     // Allow to select a peer by feature
     enableSelectPeerByFeature;
+    // Send app version headers (X-App-Version, X-App-Name) in HTTP requests
+    sendAppVersionHeaders;
     // Interval to check if web page must be reload, in millis
     checkAppVersionIntervalInSeconds;
     // Enable cache persistence ?
@@ -221,7 +224,6 @@ class Environment {
     account;
     entityEditor;
     feed;
-    buildDate;
 }
 
 const DATE_ISO_PATTERN = 'YYYY-MM-DDTHH:mm:ss.SSSZ';
@@ -3467,37 +3469,37 @@ class FormArrayHelper {
     }
     /**
      * @param value
-     * @param options
+     * @param opts
      */
-    add(value, options) {
+    add(value, opts) {
         return addValueInArray(this._formArray, this.createControl, this.equals, this.isEmpty, value, {
             allowManyNullValues: this.allowManyNullValues,
             allowDuplicateValue: this.allowDuplicatedValues,
-            ...options,
+            ...opts,
         });
     }
-    removeAt(index) {
+    removeAt(index, opts) {
         // Do not remove if last criterion
         if (!this._allowEmptyArray && this._formArray.length === 1) {
-            return clearValueInArray(this._formArray, this.isEmpty, index);
+            return clearValueInArray(this._formArray, this.isEmpty, index, opts);
         }
         else {
-            return removeValueInArray(this._formArray, this.isEmpty, index);
+            return removeValueInArray(this._formArray, index, opts);
         }
     }
-    resize(length, options) {
-        return resizeArray(this._formArray, this.createControl, length, options);
+    resize(length, opts) {
+        return resizeArray(this._formArray, this.createControl, length, opts);
     }
-    clearAt(index) {
-        return clearValueInArray(this._formArray, this.isEmpty, index);
+    clearAt(index, opts) {
+        return clearValueInArray(this._formArray, this.isEmpty, index, opts);
     }
     isLast(index) {
         return this._formArray.length - 1 === index;
     }
-    removeAllEmpty() {
+    removeAllEmpty(opts) {
         let index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));
         while (index !== -1) {
-            this.removeAt(index);
+            this.removeAt(index, opts);
             index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));
         }
     }
@@ -3521,11 +3523,11 @@ class FormArrayHelper {
      * Resize the FormArray, then patch values
      *
      * @param values
-     * @param options
+     * @param opts
      */
-    patchValue(values, options) {
+    patchValue(values, opts) {
         this.resize(values?.length || 0);
-        this._formArray.patchValue(values, options);
+        this._formArray.patchValue(values, opts);
     }
     disable(opts) {
         this._formArray.controls.forEach((c) => c.disable(opts));
@@ -3606,8 +3608,8 @@ class AppFormArray extends UntypedFormArray {
             // Clean all
             this.resize(0, { emitEvent: options?.emitEvent });
             // Recreate each control, with a default value
-            (values || []).forEach((value) => {
-                const control = this.createControl(value);
+            (values || []).forEach((value, index) => {
+                const control = this.createControl(value, index);
                 // Apply parent disabled state, before to push it into the array
                 // This is need to avoid parent form to be enabled, after calling AppFormArray.patchValue() (e.g. in table's row validator)
                 if (disabled && control.enabled)
@@ -3636,8 +3638,8 @@ class AppFormArray extends UntypedFormArray {
             // Clean all
             this.resize(0, { emitEvent: options?.emitEvent });
             // Recreate each control, with a default value
-            (values || []).forEach((value) => {
-                const control = this.createControl(value);
+            (values || []).forEach((value, index) => {
+                const control = this.createControl(value, index);
                 // Apply parent disabled state, before to push it into the array
                 // This is need to avoid parent form to be enabled, after calling AppFormArray.patchValue() (e.g. in table's row validator)
                 if (disabled && control.enabled)
@@ -3673,38 +3675,38 @@ class AppFormArray extends UntypedFormArray {
     }
     /**
      * @param value
-     * @param options
+     * @param opts
      */
-    add(value, options) {
-        addValueInArray(this, this.createControl, this.equals, this.isEmpty, value, { ...this.options, ...options });
+    add(value, opts) {
+        addValueInArray(this, this.createControl, this.equals, this.isEmpty, value, { ...this.options, ...opts });
     }
-    removeAt(index, options) {
+    removeAt(index, opts) {
         // Do not remove if last criterion
         if (this.options.allowEmptyArray === false && this.length === 1) {
-            this.clearAt(index, options);
+            this.clearAt(index, opts);
             return false;
         }
         else if (index < this.length) {
-            super.removeAt(index, options);
-            this.markAsDirty();
+            super.removeAt(index, opts);
+            this.markAsDirty(opts);
             return true;
         }
         return false;
     }
-    clearAt(index, options) {
+    clearAt(index, opts) {
         const control = this.at(index);
         if (this.isEmpty(control.value))
             return; // skip (not need to clear)
         if (control instanceof UntypedFormGroup) {
-            copyEntity2Form({}, control, options);
+            copyEntity2Form({}, control, opts);
         }
         else if (control instanceof UntypedFormArray) {
-            control.setValue([], options);
+            control.setValue([], opts);
         }
         else {
-            control.setValue(null, options);
+            control.setValue(null, opts);
         }
-        this.markAsDirty();
+        this.markAsDirty(opts);
     }
     isLast(index) {
         return this.length - 1 === index;
@@ -3779,7 +3781,7 @@ function adaptValueToControl(source, control, path) {
         }
         // Resizable array
         if (control instanceof AppFormArray) {
-            const exampleControl = control.createControl();
+            const exampleControl = control.createControl(undefined, control.length);
             return source.map((item, index) => adaptValueToControl(item, exampleControl, pathPrefix + '#' + index));
         }
         // Legacy array
@@ -4072,17 +4074,17 @@ function setControlEnabled(control, enabled, opts) {
         }
     }
 }
-function addValueInArray(arrayControl, createControl, equals, isEmpty, value, options) {
+function addValueInArray(arrayControl, createControl, equals, isEmpty, value, opts) {
     const disabled = arrayControl.disabled;
     let hasChanged = false;
     let index = -1;
     let isEmptyValue = isEmpty(value);
     // Search if value already exists
-    if (!isEmptyValue && options?.allowDuplicateValue !== true) {
+    if (!isEmptyValue && opts?.allowDuplicateValue !== true) {
         index = (arrayControl.value || []).findIndex((v) => equals(value, v));
     }
     // If value not exists, but last value is empty: reuse last value
-    if (index === -1 && options?.allowManyNullValues !== true && arrayControl.length > 0) {
+    if (index === -1 && opts?.allowManyNullValues !== true && arrayControl.length > 0) {
         const lastValue = arrayControl.at(arrayControl.length - 1).value;
         if (isEmpty(lastValue)) {
             index = arrayControl.length - 1;
@@ -4091,31 +4093,31 @@ function addValueInArray(arrayControl, createControl, equals, isEmpty, value, op
     // Replace the existing value
     if (index !== -1) {
         if (!isEmptyValue) {
-            arrayControl.at(index).patchValue(value, options);
+            arrayControl.at(index).patchValue(value, opts);
             hasChanged = true;
         }
     }
     else {
-        const control = createControl(value);
+        const control = createControl(value, arrayControl.length);
         // Apply parent disabled state, before to push it into the array
         // This is need to avoid parent form to be enabled
         if (disabled && control.enabled)
             control.disable({ emitEvent: false });
         else if (!disabled && control.disabled)
             control.enable({ emitEvent: false });
-        if (isNotNilOrNaN(options?.insertAt)) {
-            arrayControl.insert(options.insertAt, control, options);
+        if (isNotNilOrNaN(opts?.insertAt)) {
+            arrayControl.insert(opts.insertAt, control, opts);
         }
         else {
-            arrayControl.push(control, options);
+            arrayControl.push(control, opts);
         }
         hasChanged = true;
     }
     if (hasChanged) {
-        if (!options || options.emitEvent !== false) {
+        if (!opts || opts.emitEvent !== false) {
             // Mark array control dirty
             if (!isEmptyValue) {
-                arrayControl.markAsDirty();
+                arrayControl.markAsDirty(opts);
             }
         }
     }
@@ -4127,67 +4129,67 @@ function addValueInArray(arrayControl, createControl, equals, isEmpty, value, op
  * @param arrayControl
  * @param createControl
  * @param defaultValues
- * @param options
+ * @param opts
  */
-function initArrayControlsFromValues(arrayControl, createControl, defaultValues, options) {
+function initArrayControlsFromValues(arrayControl, createControl, defaultValues, opts) {
     if (arrayControl.length === 0 && (!defaultValues || defaultValues.length === 0))
         return false; // No changes need
     const disabled = arrayControl.disabled;
     while (arrayControl.length > 0) {
-        arrayControl.removeAt(arrayControl.length - 1, options);
+        arrayControl.removeAt(arrayControl.length - 1, opts);
     }
-    (defaultValues || []).forEach((value) => {
-        const control = createControl(value);
+    (defaultValues || []).forEach((value, index) => {
+        const control = createControl(value, index);
         // Apply parent disabled state, before to push it into the array
         // This is need to avoid parent form to be enabled
         if (disabled && control.enabled)
             control.disable({ emitEvent: false });
         else if (!disabled && control.disabled)
             control.enable({ emitEvent: false });
-        arrayControl.push(control, options);
+        arrayControl.push(control, opts);
     });
     return true; // Has some changes
 }
-function resizeArray(arrayControl, createControl, length, options) {
+function resizeArray(arrayControl, createControl, length, opts) {
     if (arrayControl.length === length)
         return false; // No changes need
     const disabled = arrayControl.disabled;
     // Reduce size
     while (arrayControl.length > length) {
-        arrayControl.removeAt(arrayControl.length - 1, options);
+        arrayControl.removeAt(arrayControl.length - 1, opts);
     }
     // Increase size
     while (arrayControl.length < length) {
-        const control = createControl();
+        const control = createControl(undefined, arrayControl.length);
         // Apply parent disabled state, before to push it into the array
         // This is need to avoid parent form to be enabled, after calling resizeArray()
         if (disabled && control.enabled)
             control.disable({ emitEvent: false });
         else if (!disabled && control.disabled)
             control.enable({ emitEvent: false });
-        arrayControl.push(control, options);
+        arrayControl.push(control, opts);
     }
     return true; // Has some changes
 }
-function removeValueInArray(arrayControl, isEmpty, index) {
-    arrayControl.removeAt(index);
-    arrayControl.markAsDirty();
+function removeValueInArray(arrayControl, index, opts) {
+    arrayControl.removeAt(index, opts);
+    arrayControl.markAsDirty(opts);
     return true;
 }
-function clearValueInArray(arrayControl, isEmpty, index) {
+function clearValueInArray(arrayControl, isEmpty, index, opts) {
     const control = arrayControl.at(index);
     if (isEmpty(control.value))
         return false; // skip (not need to clear)
     if (control instanceof UntypedFormGroup) {
-        copyEntity2Form({}, control);
+        copyEntity2Form({}, control, opts);
     }
     else if (control instanceof UntypedFormArray) {
-        control.setValue([]);
+        control.setValue([], opts);
     }
     else {
-        control.setValue(null);
+        control.setValue(null, opts);
     }
-    arrayControl.markAsDirty();
+    arrayControl.markAsDirty(opts);
     return true;
 }
 function markAllAsTouched(control, opts) {
@@ -12992,6 +12994,7 @@ const environment = Object.freeze({
     //offline: true,
     peerMinVersion: '1.8.0',
     enableSelectPeerByFeature: true,
+    sendAppVersionHeaders: true,
     defaultPeer: {
         host: 'localhost',
         port: 8081,
@@ -20110,6 +20113,9 @@ class NetworkService extends StartableObservableService {
     }
     /* -- Protected methods -- */
     addVersionHeader(opts) {
+        // Only add version headers if enabled in environment
+        if (!this.environment.sendAppVersionHeaders)
+            return opts;
         const updatedOpts = { ...opts };
         if (!updatedOpts.headers) {
             updatedOpts.headers = {};
@@ -20758,13 +20764,14 @@ class GraphqlService extends StartableService {
                 if (authorization.length > 0) {
                     headers = headers.append('Authorization', authorization);
                 }
-                // Add application version header
-                if (this.environment.version) {
-                    headers = headers.append('X-App-Version', this.environment.version);
-                }
-                // Add application name header
-                if (this.environment.defaultAppName) {
-                    headers = headers.append('X-App-Name', this.environment.defaultAppName);
+                // Add application version headers (if enabled)
+                if (this.environment.sendAppVersionHeaders) {
+                    if (this.environment.version) {
+                        headers = headers.append('X-App-Version', this.environment.version);
+                    }
+                    if (this.environment.defaultAppName) {
+                        headers = headers.append('X-App-Name', this.environment.defaultAppName);
+                    }
                 }
                 // Use the setContext method to set the HTTP headers.
                 operation.setContext({