@sumaris-net/ngx-components 4.0.0-rc9 → 18.0.0

package/esm2022/src/app/core/form/array/form-array.mjs

@@ -0,0 +1,325 @@
+import { UntypedFormArray, UntypedFormGroup } from '@angular/forms';
+import { toBoolean } from '../../../shared/functions';
+import { addValueInArray, clearValueInArray, copyEntity2Form, removeValueInArray, resizeArray } from '../../../shared/forms';
+import { SharedFormArrayValidators } from '../../../shared/validator/validators';
+export class FormArrayHelper {
+    _formArray;
+    createControl;
+    equals;
+    isEmpty;
+    static getOrCreateArray(formBuilder, form, arrayName) {
+        const disabled = form.disabled;
+        let arrayControl = form.get(arrayName);
+        if (!arrayControl) {
+            arrayControl = formBuilder.array([]);
+            // 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 && arrayControl.enabled)
+                arrayControl.disable({ emitEvent: false });
+            form.addControl(arrayName, arrayControl);
+        }
+        return arrayControl;
+    }
+    _allowEmptyArray;
+    _allowManyNullValues;
+    _allowDuplicatedValues;
+    _validators;
+    get allowEmptyArray() {
+        return this._allowEmptyArray;
+    }
+    set allowEmptyArray(value) {
+        this.setAllowEmptyArray(value);
+    }
+    get allowManyNullValues() {
+        return this._allowManyNullValues;
+    }
+    set allowManyNullValues(value) {
+        this._allowManyNullValues = value;
+    }
+    get allowDuplicatedValues() {
+        return this._allowDuplicatedValues;
+    }
+    set allowDuplicatedValues(value) {
+        this._allowDuplicatedValues = value;
+    }
+    get formArray() {
+        return this._formArray;
+    }
+    constructor(_formArray, createControl, equals, isEmpty, options) {
+        this._formArray = _formArray;
+        this.createControl = createControl;
+        this.equals = equals;
+        this.isEmpty = isEmpty;
+        this._validators = options && options.validators;
+        // empty array not allow by default
+        this.setAllowEmptyArray(toBoolean(options?.allowEmptyArray, false));
+        this._allowManyNullValues = toBoolean(options?.allowManyNullValues, false);
+        this._allowDuplicatedValues = toBoolean(options?.allowDuplicatedValues, false);
+    }
+    /**
+     * @param value
+     * @param options
+     */
+    add(value, options) {
+        return addValueInArray(this._formArray, this.createControl, this.equals, this.isEmpty, value, {
+            allowManyNullValues: this.allowManyNullValues,
+            allowDuplicateValue: this.allowDuplicatedValues,
+            ...options,
+        });
+    }
+    removeAt(index) {
+        // Do not remove if last criterion
+        if (!this._allowEmptyArray && this._formArray.length === 1) {
+            return clearValueInArray(this._formArray, this.isEmpty, index);
+        }
+        else {
+            return removeValueInArray(this._formArray, this.isEmpty, index);
+        }
+    }
+    resize(length, options) {
+        return resizeArray(this._formArray, this.createControl, length, options);
+    }
+    clearAt(index) {
+        return clearValueInArray(this._formArray, this.isEmpty, index);
+    }
+    isLast(index) {
+        return this._formArray.length - 1 === index;
+    }
+    removeAllEmpty() {
+        let index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));
+        while (index !== -1) {
+            this.removeAt(index);
+            index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));
+        }
+    }
+    size() {
+        return this._formArray.length;
+    }
+    at(index) {
+        return this._formArray.at(index);
+    }
+    /**
+     * Resize the FormArray, then set values
+     *
+     * @param values
+     * @param options
+     */
+    setValue(values, options) {
+        this.resize(values?.length || 0);
+        this._formArray.setValue(values, options);
+    }
+    /**
+     * Resize the FormArray, then patch values
+     *
+     * @param values
+     * @param options
+     */
+    patchValue(values, options) {
+        this.resize(values?.length || 0);
+        this._formArray.patchValue(values, options);
+    }
+    disable(opts) {
+        this._formArray.controls.forEach((c) => c.disable(opts));
+    }
+    enable(opts) {
+        this._formArray.controls.forEach((c) => c.enable(opts));
+    }
+    forEach(ite) {
+        const size = this.size();
+        for (let i = 0; i < size; i++) {
+            const control = this._formArray.at(i);
+            if (control)
+                ite(control);
+        }
+    }
+    /* -- internal methods -- */
+    setAllowEmptyArray(value) {
+        if (this._allowEmptyArray === value)
+            return; // Skip if same
+        this._allowEmptyArray = value;
+        // Set required (or reste) min length validator
+        if (this._allowEmptyArray) {
+            this._formArray.setValidators(this._validators || null);
+        }
+        else {
+            this._formArray.setValidators((this._validators || []).concat(SharedFormArrayValidators.requiredArrayMinLength(1)));
+        }
+    }
+}
+export class AppFormArray extends UntypedFormArray {
+    createControl;
+    equals;
+    isEmpty;
+    options;
+    get allowEmptyArray() {
+        return this.options.allowEmptyArray;
+    }
+    set allowEmptyArray(value) {
+        this.setAllowEmptyArray(value);
+    }
+    get allowManyNullValues() {
+        return this.options.allowManyNullValues;
+    }
+    set allowManyNullValues(value) {
+        this.options.allowManyNullValues = value;
+    }
+    get allowDuplicateValue() {
+        return this.options.allowDuplicateValue;
+    }
+    set allowDuplicateValue(value) {
+        this.options.allowDuplicateValue = value;
+    }
+    constructor(createControl, equals, isEmpty, options) {
+        super([], options);
+        this.createControl = createControl;
+        this.equals = equals;
+        this.isEmpty = isEmpty;
+        this.options = {
+            allowEmptyArray: true,
+            allowReuseControls: true,
+            allowManyNullValues: false,
+            allowDuplicateValue: false,
+            ...options,
+        };
+        this.setAllowEmptyArray(this.options.allowEmptyArray);
+    }
+    /**
+     * WIll rebuild the array, using the given values
+     *
+     * @param values
+     * @param options
+     */
+    setValue(values, options) {
+        if (values === undefined)
+            throw new Error("'undefined' value not allowed in AppFormArray.setValue(). Use 'null' or '[]' to clear the array");
+        if (this.options.allowReuseControls === false) {
+            const disabled = this.disabled;
+            // Clean all
+            this.resize(0, { emitEvent: options?.emitEvent });
+            // Recreate each control, with a default value
+            (values || []).forEach((value) => {
+                const control = this.createControl(value);
+                // 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)
+                    control.disable({ emitEvent: false });
+                else if (!disabled && control.disabled)
+                    control.enable({ emitEvent: false });
+                this.push(control, options);
+            });
+        }
+        else {
+            this.resize(values?.length || 0, { emitEvent: false });
+            super.setValue(values, options);
+        }
+    }
+    patchValue(values, options) {
+        // --- /!\ From official Angular doc of 'FormGroup.patchValue()' :
+        //   Even though the `value` argument type doesn't allow `null` and `undefined` values, the
+        //   `patchValue` can be called recursively and inner data structures might have these values, so
+        //   we just ignore such cases when a field containing FormGroup instance receives `null` or
+        //   `undefined` as a value.
+        // ---
+        if (values == null)
+            return; // Ignore
+        if (this.options.allowReuseControls === false) {
+            const disabled = this.disabled;
+            // Clean all
+            this.resize(0, { emitEvent: options?.emitEvent });
+            // Recreate each control, with a default value
+            (values || []).forEach((value) => {
+                const control = this.createControl(value);
+                // 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)
+                    control.disable({ emitEvent: false });
+                else if (!disabled && control.disabled)
+                    control.enable({ emitEvent: false });
+                this.push(control, options);
+            });
+        }
+        else {
+            this.resize(values?.length || 0, { emitEvent: false });
+            super.patchValue(values, options);
+        }
+    }
+    resize(length, options) {
+        return resizeArray(this, this.createControl, length, options);
+    }
+    disable(opts) {
+        super.disable(opts);
+        this.controls.forEach((c) => c.disable(opts));
+    }
+    enable(opts) {
+        super.enable(opts);
+        this.controls.forEach((c) => c.enable(opts));
+    }
+    forEach(ite) {
+        const size = this.length;
+        for (let i = 0; i < size; i++) {
+            const control = this.at(i);
+            if (control)
+                ite(control);
+        }
+    }
+    /**
+     * @param value
+     * @param options
+     */
+    add(value, options) {
+        addValueInArray(this, this.createControl, this.equals, this.isEmpty, value, { ...this.options, ...options });
+    }
+    removeAt(index, options) {
+        // Do not remove if last criterion
+        if (this.options.allowEmptyArray === false && this.length === 1) {
+            this.clearAt(index, options);
+            return false;
+        }
+        else if (index < this.length) {
+            super.removeAt(index, options);
+            this.markAsDirty();
+            return true;
+        }
+        return false;
+    }
+    clearAt(index, options) {
+        const control = this.at(index);
+        if (this.isEmpty(control.value))
+            return; // skip (not need to clear)
+        if (control instanceof UntypedFormGroup) {
+            copyEntity2Form({}, control, options);
+        }
+        else if (control instanceof UntypedFormArray) {
+            control.setValue([], options);
+        }
+        else {
+            control.setValue(null, options);
+        }
+        this.markAsDirty();
+    }
+    isLast(index) {
+        return this.length - 1 === index;
+    }
+    removeAllEmpty() {
+        let index = this.controls.findIndex((c) => this.isEmpty(c.value));
+        while (index !== -1) {
+            this.removeAt(index);
+            index = this.controls.findIndex((c) => this.isEmpty(c.value));
+        }
+    }
+    /* -- internal -- */
+    setAllowEmptyArray(value) {
+        if (this.options.allowEmptyArray === value)
+            return; // Skip if same
+        this.options.allowEmptyArray = value;
+        // Set required (or reset) min length validator
+        if (this.options.allowEmptyArray) {
+            this.setValidators(this.options.validators || null);
+        }
+        else {
+            const validators = this.options?.validators || [];
+            this.setValidators((Array.isArray(validators) ? validators : [validators]).concat(SharedFormArrayValidators.requiredArrayMinLength(1)));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-array.js","sourceRoot":"","sources":["../../../../../../../src/app/core/form/array/form-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity } from '../../services/model/entity.model';\nimport { AbstractControl, AbstractControlOptions, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, ValidatorFn } from '@angular/forms';\nimport { toBoolean } from '../../../shared/functions';\nimport { addValueInArray, clearValueInArray, copyEntity2Form, removeValueInArray, resizeArray } from '../../../shared/forms';\nimport { SharedFormArrayValidators } from '../../../shared/validator/validators';\n\nexport interface FormArrayHelperOptions {\n  allowEmptyArray: boolean; // false by default /!\\ TRUE in the AppFormArray\n  allowManyNullValues?: boolean; // false by default\n  allowDuplicatedValues?: boolean; // false by default\n  validators?: ValidatorFn[];\n}\n\nexport class FormArrayHelper<T = Entity<any>, C extends AbstractControl = AbstractControl> {\n  static getOrCreateArray(formBuilder: UntypedFormBuilder, form: UntypedFormGroup, arrayName: string): UntypedFormArray {\n    const disabled = form.disabled;\n    let arrayControl = form.get(arrayName) as UntypedFormArray;\n    if (!arrayControl) {\n      arrayControl = formBuilder.array([]);\n\n      // Apply parent disabled state, before to push it into the array\n      // This is need to avoid parent form to be enabled, after calling resizeArray()\n      if (disabled && arrayControl.enabled) arrayControl.disable({ emitEvent: false });\n\n      form.addControl(arrayName, arrayControl);\n    }\n    return arrayControl;\n  }\n\n  private _allowEmptyArray: boolean;\n  private _allowManyNullValues: boolean;\n  private _allowDuplicatedValues: boolean;\n\n  private readonly _validators: ValidatorFn[];\n\n  get allowEmptyArray(): boolean {\n    return this._allowEmptyArray;\n  }\n\n  set allowEmptyArray(value: boolean) {\n    this.setAllowEmptyArray(value);\n  }\n\n  get allowManyNullValues(): boolean {\n    return this._allowManyNullValues;\n  }\n\n  set allowManyNullValues(value: boolean) {\n    this._allowManyNullValues = value;\n  }\n\n  get allowDuplicatedValues(): boolean {\n    return this._allowDuplicatedValues;\n  }\n\n  set allowDuplicatedValues(value: boolean) {\n    this._allowDuplicatedValues = value;\n  }\n\n  get formArray(): UntypedFormArray {\n    return this._formArray;\n  }\n\n  constructor(\n    private readonly _formArray: UntypedFormArray,\n    private createControl: (value?: T) => C,\n    private equals: (v1: T, v2: T) => boolean,\n    private isEmpty: (value: T) => boolean,\n    options?: FormArrayHelperOptions\n  ) {\n    this._validators = options && options.validators;\n\n    // empty array not allow by default\n    this.setAllowEmptyArray(toBoolean(options?.allowEmptyArray, false));\n    this._allowManyNullValues = toBoolean(options?.allowManyNullValues, false);\n    this._allowDuplicatedValues = toBoolean(options?.allowDuplicatedValues, false);\n  }\n\n  /**\n   * @param value\n   * @param options\n   */\n  add(value?: T, options?: { emitEvent: boolean; insertAt?: number }): boolean {\n    return addValueInArray(this._formArray, this.createControl, this.equals, this.isEmpty, value, {\n      allowManyNullValues: this.allowManyNullValues,\n      allowDuplicateValue: this.allowDuplicatedValues,\n      ...options,\n    });\n  }\n\n  removeAt(index: number) {\n    // Do not remove if last criterion\n    if (!this._allowEmptyArray && this._formArray.length === 1) {\n      return clearValueInArray(this._formArray, this.isEmpty, index);\n    } else {\n      return removeValueInArray(this._formArray, this.isEmpty, index);\n    }\n  }\n\n  resize(length: number, options?: { emitEvent?: boolean }): boolean {\n    return resizeArray(this._formArray, this.createControl, length, options);\n  }\n\n  clearAt(index: number): boolean {\n    return clearValueInArray(this._formArray, this.isEmpty, index);\n  }\n\n  isLast(index: number): boolean {\n    return this._formArray.length - 1 === index;\n  }\n\n  removeAllEmpty() {\n    let index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));\n    while (index !== -1) {\n      this.removeAt(index);\n      index = this._formArray.controls.findIndex((c) => this.isEmpty(c.value));\n    }\n  }\n\n  size(): number {\n    return this._formArray.length;\n  }\n\n  at(index: number): C {\n    return this._formArray.at(index) as C;\n  }\n\n  /**\n   * Resize the FormArray, then set values\n   *\n   * @param values\n   * @param options\n   */\n  setValue(\n    values: T[],\n    options?: {\n      onlySelf?: boolean;\n      emitEvent?: boolean;\n    }\n  ): void {\n    this.resize(values?.length || 0);\n    this._formArray.setValue(values, options);\n  }\n\n  /**\n   * Resize the FormArray, then patch values\n   *\n   * @param values\n   * @param options\n   */\n  patchValue(\n    values: T[],\n    options?: {\n      onlySelf?: boolean;\n      emitEvent?: boolean;\n    }\n  ): void {\n    this.resize(values?.length || 0);\n    this._formArray.patchValue(values, options);\n  }\n\n  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    this._formArray.controls.forEach((c) => c.disable(opts));\n  }\n\n  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    this._formArray.controls.forEach((c) => c.enable(opts));\n  }\n\n  forEach(ite: (control: C) => void) {\n    const size = this.size();\n    for (let i = 0; i < size; i++) {\n      const control = this._formArray.at(i) as C;\n      if (control) ite(control);\n    }\n  }\n\n  /* -- internal methods -- */\n\n  protected setAllowEmptyArray(value: boolean) {\n    if (this._allowEmptyArray === value) return; // Skip if same\n\n    this._allowEmptyArray = value;\n\n    // Set required (or reste) min length validator\n    if (this._allowEmptyArray) {\n      this._formArray.setValidators(this._validators || null);\n    } else {\n      this._formArray.setValidators((this._validators || []).concat(SharedFormArrayValidators.requiredArrayMinLength(1)));\n    }\n  }\n}\n\nexport declare interface AppFormArrayOptions extends AbstractControlOptions {\n  allowEmptyArray?: boolean; // true by default\n  allowReuseControls?: boolean; // true by default\n  allowManyNullValues?: boolean; // false by default\n  allowDuplicateValue?: boolean; // false by default\n}\n\nexport class AppFormArray<T = Entity<any>, C extends AbstractControl = AbstractControl> extends UntypedFormArray {\n  private readonly options: AppFormArrayOptions;\n\n  get allowEmptyArray(): boolean {\n    return this.options.allowEmptyArray;\n  }\n\n  set allowEmptyArray(value: boolean) {\n    this.setAllowEmptyArray(value);\n  }\n\n  get allowManyNullValues(): boolean {\n    return this.options.allowManyNullValues;\n  }\n\n  set allowManyNullValues(value: boolean) {\n    this.options.allowManyNullValues = value;\n  }\n\n  get allowDuplicateValue(): boolean {\n    return this.options.allowDuplicateValue;\n  }\n\n  set allowDuplicateValue(value: boolean) {\n    this.options.allowDuplicateValue = value;\n  }\n\n  constructor(\n    public createControl: (value?: T) => C,\n    private equals: (v1: T, v2: T) => boolean,\n    private isEmpty: (value: T) => boolean,\n    options?: AppFormArrayOptions | undefined | null\n  ) {\n    super([], options);\n    this.options = {\n      allowEmptyArray: true,\n      allowReuseControls: true,\n      allowManyNullValues: false,\n      allowDuplicateValue: false,\n      ...options,\n    };\n    this.setAllowEmptyArray(this.options.allowEmptyArray);\n  }\n\n  /**\n   * WIll rebuild the array, using the given values\n   *\n   * @param values\n   * @param options\n   */\n  setValue(\n    values: any[],\n    options?: {\n      onlySelf?: boolean;\n      emitEvent?: boolean;\n    }\n  ): void {\n    if (values === undefined) throw new Error(\"'undefined' value not allowed in AppFormArray.setValue(). Use 'null' or '[]' to clear the array\");\n\n    if (this.options.allowReuseControls === false) {\n      const disabled = this.disabled;\n\n      // Clean all\n      this.resize(0, { emitEvent: options?.emitEvent });\n\n      // Recreate each control, with a default value\n      (values || []).forEach((value) => {\n        const control = this.createControl(value);\n\n        // Apply parent disabled state, before to push it into the array\n        // This is need to avoid parent form to be enabled, after calling AppFormArray.patchValue() (e.g. in table's row validator)\n        if (disabled && control.enabled) control.disable({ emitEvent: false });\n        else if (!disabled && control.disabled) control.enable({ emitEvent: false });\n\n        this.push(control, options);\n      });\n    } else {\n      this.resize(values?.length || 0, { emitEvent: false });\n      super.setValue(values, options);\n    }\n  }\n\n  patchValue(\n    values: any[] | null | undefined,\n    options?: {\n      onlySelf?: boolean;\n      emitEvent?: boolean;\n    }\n  ): void {\n    // --- /!\\ From official Angular doc of 'FormGroup.patchValue()' :\n    //   Even though the `value` argument type doesn't allow `null` and `undefined` values, the\n    //   `patchValue` can be called recursively and inner data structures might have these values, so\n    //   we just ignore such cases when a field containing FormGroup instance receives `null` or\n    //   `undefined` as a value.\n    // ---\n    if (values == null) return; // Ignore\n\n    if (this.options.allowReuseControls === false) {\n      const disabled = this.disabled;\n\n      // Clean all\n      this.resize(0, { emitEvent: options?.emitEvent });\n\n      // Recreate each control, with a default value\n      (values || []).forEach((value) => {\n        const control = this.createControl(value);\n\n        // Apply parent disabled state, before to push it into the array\n        // This is need to avoid parent form to be enabled, after calling AppFormArray.patchValue() (e.g. in table's row validator)\n        if (disabled && control.enabled) control.disable({ emitEvent: false });\n        else if (!disabled && control.disabled) control.enable({ emitEvent: false });\n\n        this.push(control, options);\n      });\n    } else {\n      this.resize(values?.length || 0, { emitEvent: false });\n      super.patchValue(values, options);\n    }\n  }\n\n  resize(length: number, options?: { emitEvent?: boolean }): boolean {\n    return resizeArray(this, this.createControl, length, options);\n  }\n\n  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    super.disable(opts);\n    this.controls.forEach((c) => c.disable(opts));\n  }\n\n  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    super.enable(opts);\n    this.controls.forEach((c) => c.enable(opts));\n  }\n\n  forEach(ite: (control: C) => void) {\n    const size = this.length;\n    for (let i = 0; i < size; i++) {\n      const control = this.at(i) as C;\n      if (control) ite(control);\n    }\n  }\n\n  /**\n   * @param value\n   * @param options\n   */\n  add(value?: T, options?: { emitEvent: boolean; insertAt?: number }) {\n    addValueInArray(this, this.createControl, this.equals, this.isEmpty, value, { ...this.options, ...options });\n  }\n\n  removeAt(index: number, options?: { emitEvent: boolean }) {\n    // Do not remove if last criterion\n    if (this.options.allowEmptyArray === false && this.length === 1) {\n      this.clearAt(index, options);\n      return false;\n    } else if (index < this.length) {\n      super.removeAt(index, options);\n      this.markAsDirty();\n      return true;\n    }\n    return false;\n  }\n\n  clearAt(index: number, options?: { emitEvent: boolean }) {\n    const control = this.at(index);\n    if (this.isEmpty(control.value)) return; // skip (not need to clear)\n\n    if (control instanceof UntypedFormGroup) {\n      copyEntity2Form({}, control, options);\n    } else if (control instanceof UntypedFormArray) {\n      control.setValue([], options);\n    } else {\n      control.setValue(null, options);\n    }\n    this.markAsDirty();\n  }\n\n  isLast(index: number): boolean {\n    return this.length - 1 === index;\n  }\n\n  removeAllEmpty() {\n    let index = this.controls.findIndex((c) => this.isEmpty(c.value));\n    while (index !== -1) {\n      this.removeAt(index);\n      index = this.controls.findIndex((c) => this.isEmpty(c.value));\n    }\n  }\n\n  /* -- internal -- */\n\n  protected setAllowEmptyArray(value: boolean) {\n    if (this.options.allowEmptyArray === value) return; // Skip if same\n\n    this.options.allowEmptyArray = value;\n\n    // Set required (or reset) min length validator\n    if (this.options.allowEmptyArray) {\n      this.setValidators(this.options.validators || null);\n    } else {\n      const validators = this.options?.validators || [];\n      this.setValidators((Array.isArray(validators) ? validators : [validators]).concat(SharedFormArrayValidators.requiredArrayMinLength(1)));\n    }\n  }\n}\n"]}

package/esm2022/src/app/core/form/array/testing/form-array-test.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { CommonModule } from '@angular/common';
+import { SharedModule } from '../../../../shared/shared.module';
+import { CoreModule } from '../../../core.module';
+import { ArrayFormTestPage } from './form-array.test';
+import { RouterModule } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class FormArrayTestModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormArrayTestModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.8", ngImport: i0, type: FormArrayTestModule, declarations: [ArrayFormTestPage], imports: [CommonModule, SharedModule, CoreModule, i1.TranslateModule], exports: [ArrayFormTestPage, RouterModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormArrayTestModule, imports: [CommonModule, SharedModule, CoreModule, TranslateModule.forChild(), RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormArrayTestModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SharedModule, CoreModule, TranslateModule.forChild()],
+                    declarations: [ArrayFormTestPage],
+                    exports: [ArrayFormTestPage, RouterModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/core/form/array/testing/form-array.test.mjs

@@ -0,0 +1,94 @@
+import { Component } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { isNilOrBlank, trimEmptyToNull } from '../../../../shared/functions';
+import { AppForm } from '../../form.class';
+import { AppFormArray } from '../form-array';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../../services/platform.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@ionic/angular";
+import * as i5 from "@angular/material/form-field";
+import * as i6 from "@angular/material/input";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/button";
+import * as i9 from "@ngx-translate/core";
+import * as i10 from "../../../../shared/pipes/form.pipes";
+export class ArrayFormTestPage extends AppForm {
+    formBuilder;
+    platform;
+    injection;
+    cd;
+    subscription = new Subscription();
+    get defaultFormArray() {
+        return this.form.get('default');
+    }
+    get notEmptyFormArray() {
+        return this.form.get('notEmpty');
+    }
+    get nullValuesFormArray() {
+        return this.form.get('nullValues');
+    }
+    get duplicatedValuesFormArray() {
+        return this.form.get('duplicatedValues');
+    }
+    get valueToAddControl() {
+        return this.form?.get('valueToAdd');
+    }
+    constructor(formBuilder, platform, injection, cd) {
+        super(injection, formBuilder.group({
+            default: new AppFormArray((value) => this.formBuilder.control(value), (v1, v2) => v1 === v2, (value) => isNilOrBlank(value)),
+            notEmpty: new AppFormArray((value) => this.formBuilder.control(value), (v1, v2) => v1 === v2, (value) => isNilOrBlank(value), {
+                allowEmptyArray: false,
+            }),
+            nullValues: new AppFormArray((value) => this.formBuilder.control(value), (v1, v2) => v1 === v2, (value) => isNilOrBlank(value), {
+                allowEmptyArray: false,
+                allowManyNullValues: true,
+            }),
+            duplicatedValues: new AppFormArray((value) => this.formBuilder.control(value), (v1, v2) => v1 === v2, (value) => isNilOrBlank(value), {
+                allowEmptyArray: false,
+                allowManyNullValues: true,
+                allowDuplicateValue: true,
+            }),
+            // Value to add
+            valueToAdd: formBuilder.control(null, []),
+        }));
+        this.formBuilder = formBuilder;
+        this.platform = platform;
+        this.injection = injection;
+        this.cd = cd;
+    }
+    ngOnInit() {
+        setTimeout(() => this.loadData(), 250);
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    // Load the form with data
+    async loadData() {
+        this.setValue({
+            default: ['TESTING_1', 'TESTING_2'],
+            notEmpty: ['TESTING_1', 'TESTING_2'],
+            nullValues: ['TESTING_1', null, 'TESTING_4'],
+            duplicatedValues: ['TESTING_1', null, 'TESTING_1'],
+            // Add with value
+            valueToAdd: null,
+        });
+    }
+    setFormArrayValue(formArray, values) {
+        const arrayValues = Array.isArray(values) ? values : values?.split(',').map(trimEmptyToNull);
+        formArray.patchValue(arrayValues);
+        this.markAsDirty();
+    }
+    /* -- protected methods -- */
+    markForCheck() {
+        this.cd.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ArrayFormTestPage, deps: [{ token: i1.UntypedFormBuilder }, { token: i2.PlatformService }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.8", type: ArrayFormTestPage, selector: "app-array-test", usesInheritance: true, ngImport: i0, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Form Array test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content>\n  <form class=\"form-container ion-padding\" [formGroup]=\"form\">\n    <ion-grid>\n      <ion-row>\n        <!-- Default -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: defaultFormArray, title: 'Default behavior', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Not empty array -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: notEmptyFormArray, title: 'Not empty array', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow null values -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: nullValuesFormArray,\n                title: 'Allow many null values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow duplicated value -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: duplicatedValuesFormArray,\n                title: 'Allow duplicated values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n      </ion-row>\n    </ion-grid>\n  </form>\n</ion-content>\n\n<ng-template\n  #arrayCard\n  let-formArray\n  let-title=\"title\"\n  let-showAddToolbar=\"showAddToolbar\"\n  let-showResizeToolbar=\"showResizeToolbar\"\n  let-showSetValue=\"showSetValue\"\n>\n  <ion-card>\n    <ion-card-header>\n      <ion-card-title>{{ title }}</ion-card-title>\n    </ion-card-header>\n    <ion-card-content>\n      @for (\n        control of (formArray | formGetArray).controls;\n        track i;\n        let i = $index;\n        let first = $first;\n        let last = $last\n      ) {\n        <ion-row>\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value #{{ i + 1 }}</mat-label>\n              <input matInput [formControl]=\"control | formGetControl\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            @if (last && !showAddToolbar) {\n              <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n                <mat-icon>add</mat-icon>\n              </button>\n            }\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_DELETE' | translate\"\n              (click)=\"formArray.removeAt(i) && markAsDirty()\"\n            >\n              <mat-icon>close</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      }\n\n      @if (formArray.length === 0 && !showAddToolbar) {\n        <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n          <mat-icon>add</mat-icon>\n        </button>\n      }\n    </ion-card-content>\n\n    @if (showAddToolbar || showResizeToolbar || showSetValue) {\n      <ion-toolbar>\n        <!-- Set array value -->\n        <ion-row *ngIf=\"showSetValue\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Set Value</mat-label>\n              <input\n                #setValueInput\n                matInput\n                type=\"text\"\n                placeholder=\"Comma separated values\"\n                (keydown.enter)=\"setFormArrayValue(formArray, setValueInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              title=\"Set value\"\n              (click)=\"setFormArrayValue(formArray, setValueInput.value)\"\n            >\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Resize the array -->\n        <ion-row *ngIf=\"showResizeToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Resize</mat-label>\n              <input\n                #sizeInput\n                matInput\n                type=\"number\"\n                step=\"1\"\n                min=\"0\"\n                placeholder=\"New array length\"\n                (keydown.enter)=\"formArray.resize(sizeInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button type=\"button\" mat-icon-button title=\"Resize\" (click)=\"formArray.resize(sizeInput.value)\">\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Add a item with a value -->\n        <ion-row *ngIf=\"showAddToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value to add</mat-label>\n              <input #valueInput matInput type=\"text\" (keydown.enter)=\"formArray.add(valueInput.value)\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_ADD' | translate\"\n              (click)=\"formArray.add(valueInput.value)\"\n            >\n              <mat-icon>add</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      </ion-toolbar>\n    }\n  </ion-card>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i4.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i4.IonCard, selector: "ion-card", inputs: ["button", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { kind: "component", type: i4.IonCardContent, selector: "ion-card-content", inputs: ["mode"] }, { kind: "component", type: i4.IonCardHeader, selector: "ion-card-header", inputs: ["color", "mode", "translucent"] }, { kind: "component", type: i4.IonCardTitle, selector: "ion-card-title", inputs: ["color", "mode"] }, { kind: "component", type: i4.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { kind: "component", type: i4.IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i4.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: i4.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i4.IonRow, selector: "ion-row" }, { kind: "component", type: i4.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i4.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: i4.IonBackButton, selector: "ion-back-button" }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatLabel, selector: "mat-label" }, { kind: "directive", type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i8.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "pipe", type: i9.TranslatePipe, name: "translate" }, { kind: "pipe", type: i10.FormGetControlPipe, name: "formGetControl" }, { kind: "pipe", type: i10.FormGetArrayPipe, name: "formGetArray" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ArrayFormTestPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-array-test', template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Form Array test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content>\n  <form class=\"form-container ion-padding\" [formGroup]=\"form\">\n    <ion-grid>\n      <ion-row>\n        <!-- Default -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: defaultFormArray, title: 'Default behavior', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Not empty array -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: notEmptyFormArray, title: 'Not empty array', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow null values -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: nullValuesFormArray,\n                title: 'Allow many null values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow duplicated value -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: duplicatedValuesFormArray,\n                title: 'Allow duplicated values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n      </ion-row>\n    </ion-grid>\n  </form>\n</ion-content>\n\n<ng-template\n  #arrayCard\n  let-formArray\n  let-title=\"title\"\n  let-showAddToolbar=\"showAddToolbar\"\n  let-showResizeToolbar=\"showResizeToolbar\"\n  let-showSetValue=\"showSetValue\"\n>\n  <ion-card>\n    <ion-card-header>\n      <ion-card-title>{{ title }}</ion-card-title>\n    </ion-card-header>\n    <ion-card-content>\n      @for (\n        control of (formArray | formGetArray).controls;\n        track i;\n        let i = $index;\n        let first = $first;\n        let last = $last\n      ) {\n        <ion-row>\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value #{{ i + 1 }}</mat-label>\n              <input matInput [formControl]=\"control | formGetControl\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            @if (last && !showAddToolbar) {\n              <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n                <mat-icon>add</mat-icon>\n              </button>\n            }\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_DELETE' | translate\"\n              (click)=\"formArray.removeAt(i) && markAsDirty()\"\n            >\n              <mat-icon>close</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      }\n\n      @if (formArray.length === 0 && !showAddToolbar) {\n        <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n          <mat-icon>add</mat-icon>\n        </button>\n      }\n    </ion-card-content>\n\n    @if (showAddToolbar || showResizeToolbar || showSetValue) {\n      <ion-toolbar>\n        <!-- Set array value -->\n        <ion-row *ngIf=\"showSetValue\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Set Value</mat-label>\n              <input\n                #setValueInput\n                matInput\n                type=\"text\"\n                placeholder=\"Comma separated values\"\n                (keydown.enter)=\"setFormArrayValue(formArray, setValueInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              title=\"Set value\"\n              (click)=\"setFormArrayValue(formArray, setValueInput.value)\"\n            >\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Resize the array -->\n        <ion-row *ngIf=\"showResizeToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Resize</mat-label>\n              <input\n                #sizeInput\n                matInput\n                type=\"number\"\n                step=\"1\"\n                min=\"0\"\n                placeholder=\"New array length\"\n                (keydown.enter)=\"formArray.resize(sizeInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button type=\"button\" mat-icon-button title=\"Resize\" (click)=\"formArray.resize(sizeInput.value)\">\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Add a item with a value -->\n        <ion-row *ngIf=\"showAddToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value to add</mat-label>\n              <input #valueInput matInput type=\"text\" (keydown.enter)=\"formArray.add(valueInput.value)\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_ADD' | translate\"\n              (click)=\"formArray.add(valueInput.value)\"\n            >\n              <mat-icon>add</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      </ion-toolbar>\n    }\n  </ion-card>\n</ng-template>\n" }]
+        }], ctorParameters: () => [{ type: i1.UntypedFormBuilder }, { type: i2.PlatformService }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-array.test.js","sourceRoot":"","sources":["../../../../../../../../src/app/core/form/array/testing/form-array.test.ts","../../../../../../../../src/app/core/form/array/testing/form-array.test.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, Injector, OnDestroy, OnInit } from '@angular/core';\nimport { UntypedFormBuilder, UntypedFormControl } from '@angular/forms';\n\nimport { PlatformService } from '../../../services/platform.service';\nimport { Subscription } from 'rxjs';\nimport { isNilOrBlank, trimEmptyToNull } from '../../../../shared/functions';\nimport { AppForm } from '../../form.class';\nimport { AppFormArray } from '../form-array';\n\n@Component({\n  selector: 'app-array-test',\n  templateUrl: './form-array.test.html',\n})\nexport class ArrayFormTestPage extends AppForm<any> implements OnInit, OnDestroy {\n  private subscription = new Subscription();\n\n  get defaultFormArray(): AppFormArray<any, any> {\n    return this.form.get('default') as AppFormArray<any, any>;\n  }\n\n  get notEmptyFormArray(): AppFormArray<any, any> {\n    return this.form.get('notEmpty') as AppFormArray<any, any>;\n  }\n\n  get nullValuesFormArray(): AppFormArray<any, any> {\n    return this.form.get('nullValues') as AppFormArray<any, any>;\n  }\n\n  get duplicatedValuesFormArray(): AppFormArray<any, any> {\n    return this.form.get('duplicatedValues') as AppFormArray<any, any>;\n  }\n\n  get valueToAddControl(): UntypedFormControl {\n    return this.form?.get('valueToAdd') as UntypedFormControl;\n  }\n\n  constructor(\n    protected formBuilder: UntypedFormBuilder,\n    protected platform: PlatformService,\n    protected injection: Injector,\n    protected cd: ChangeDetectorRef\n  ) {\n    super(\n      injection,\n      formBuilder.group({\n        default: new AppFormArray(\n          (value) => this.formBuilder.control(value),\n          (v1, v2) => v1 === v2,\n          (value) => isNilOrBlank(value)\n        ),\n\n        notEmpty: new AppFormArray(\n          (value) => this.formBuilder.control(value),\n          (v1, v2) => v1 === v2,\n          (value) => isNilOrBlank(value),\n          {\n            allowEmptyArray: false,\n          }\n        ),\n\n        nullValues: new AppFormArray(\n          (value) => this.formBuilder.control(value),\n          (v1, v2) => v1 === v2,\n          (value) => isNilOrBlank(value),\n          {\n            allowEmptyArray: false,\n            allowManyNullValues: true,\n          }\n        ),\n\n        duplicatedValues: new AppFormArray(\n          (value) => this.formBuilder.control(value),\n          (v1, v2) => v1 === v2,\n          (value) => isNilOrBlank(value),\n          {\n            allowEmptyArray: false,\n            allowManyNullValues: true,\n            allowDuplicateValue: true,\n          }\n        ),\n\n        // Value to add\n        valueToAdd: formBuilder.control(null, []),\n      })\n    );\n  }\n\n  ngOnInit() {\n    setTimeout(() => this.loadData(), 250);\n  }\n\n  ngOnDestroy() {\n    this.subscription.unsubscribe();\n  }\n\n  // Load the form with data\n  async loadData() {\n    this.setValue({\n      default: ['TESTING_1', 'TESTING_2'],\n      notEmpty: ['TESTING_1', 'TESTING_2'],\n      nullValues: ['TESTING_1', null, 'TESTING_4'],\n      duplicatedValues: ['TESTING_1', null, 'TESTING_1'],\n      // Add with value\n      valueToAdd: null,\n    });\n  }\n\n  protected setFormArrayValue(formArray: AppFormArray<any, any>, values: string | string[]) {\n    const arrayValues = Array.isArray(values) ? values : values?.split(',').map(trimEmptyToNull);\n    formArray.patchValue(arrayValues);\n    this.markAsDirty();\n  }\n\n  /* -- protected methods -- */\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n}\n","<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Form Array test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content>\n  <form class=\"form-container ion-padding\" [formGroup]=\"form\">\n    <ion-grid>\n      <ion-row>\n        <!-- Default -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: defaultFormArray, title: 'Default behavior', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Not empty array -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: { $implicit: notEmptyFormArray, title: 'Not empty array', showSetValue: true }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow null values -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: nullValuesFormArray,\n                title: 'Allow many null values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n\n        <!-- Allow duplicated value -->\n        <ion-col size=\"6\">\n          <ng-container\n            *ngTemplateOutlet=\"\n              arrayCard;\n              context: {\n                $implicit: duplicatedValuesFormArray,\n                title: 'Allow duplicated values',\n                showAddToolbar: true,\n                showResizeToolbar: true,\n                showSetValue: true\n              }\n            \"\n          ></ng-container>\n        </ion-col>\n      </ion-row>\n    </ion-grid>\n  </form>\n</ion-content>\n\n<ng-template\n  #arrayCard\n  let-formArray\n  let-title=\"title\"\n  let-showAddToolbar=\"showAddToolbar\"\n  let-showResizeToolbar=\"showResizeToolbar\"\n  let-showSetValue=\"showSetValue\"\n>\n  <ion-card>\n    <ion-card-header>\n      <ion-card-title>{{ title }}</ion-card-title>\n    </ion-card-header>\n    <ion-card-content>\n      @for (\n        control of (formArray | formGetArray).controls;\n        track i;\n        let i = $index;\n        let first = $first;\n        let last = $last\n      ) {\n        <ion-row>\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value #{{ i + 1 }}</mat-label>\n              <input matInput [formControl]=\"control | formGetControl\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            @if (last && !showAddToolbar) {\n              <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n                <mat-icon>add</mat-icon>\n              </button>\n            }\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_DELETE' | translate\"\n              (click)=\"formArray.removeAt(i) && markAsDirty()\"\n            >\n              <mat-icon>close</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      }\n\n      @if (formArray.length === 0 && !showAddToolbar) {\n        <button type=\"button\" mat-icon-button [title]=\"'COMMON.BTN_ADD' | translate\" (click)=\"formArray.add()\">\n          <mat-icon>add</mat-icon>\n        </button>\n      }\n    </ion-card-content>\n\n    @if (showAddToolbar || showResizeToolbar || showSetValue) {\n      <ion-toolbar>\n        <!-- Set array value -->\n        <ion-row *ngIf=\"showSetValue\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Set Value</mat-label>\n              <input\n                #setValueInput\n                matInput\n                type=\"text\"\n                placeholder=\"Comma separated values\"\n                (keydown.enter)=\"setFormArrayValue(formArray, setValueInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              title=\"Set value\"\n              (click)=\"setFormArrayValue(formArray, setValueInput.value)\"\n            >\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Resize the array -->\n        <ion-row *ngIf=\"showResizeToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Resize</mat-label>\n              <input\n                #sizeInput\n                matInput\n                type=\"number\"\n                step=\"1\"\n                min=\"0\"\n                placeholder=\"New array length\"\n                (keydown.enter)=\"formArray.resize(sizeInput.value)\"\n              />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button type=\"button\" mat-icon-button title=\"Resize\" (click)=\"formArray.resize(sizeInput.value)\">\n              <mat-icon>checkmark</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n\n        <!-- Add a item with a value -->\n        <ion-row *ngIf=\"showAddToolbar\">\n          <ion-col>\n            <mat-form-field>\n              <mat-label>Value to add</mat-label>\n              <input #valueInput matInput type=\"text\" (keydown.enter)=\"formArray.add(valueInput.value)\" />\n            </mat-form-field>\n          </ion-col>\n          <ion-col size=\"auto\">\n            <button\n              type=\"button\"\n              mat-icon-button\n              [title]=\"'COMMON.BTN_ADD' | translate\"\n              (click)=\"formArray.add(valueInput.value)\"\n            >\n              <mat-icon>add</mat-icon>\n            </button>\n          </ion-col>\n        </ion-row>\n      </ion-toolbar>\n    }\n  </ion-card>\n</ng-template>\n"]}