@sumaris-net/ngx-components 18.14.0 → 18.14.1

package/esm2022/src/app/core/form/form.utils.mjs

@@ -0,0 +1,232 @@
+import { round, toBoolean } from '../../shared/functions';
+import { filterNumberInput, selectInputContent, selectInputContentFromEvent } from '../../shared/inputs';
+import { waitFor } from '../../shared/observables';
+import { addValueInArray, clearValueInArray, copyEntity2Form, disableAndClearControl, disableAndClearControls, disableControl, disableControls, enableControl, enableControls, filterFormErrors, filterFormErrorsByPath, filterFormErrorsByPrefix, getControlFromPath, getFormErrors, getFormValueFromEntity, logFormErrors, markAllAsTouched, markAsUntouched, removeValueInArray, resizeArray, setControlEnabled, setControlsEnabled, setFormErrors, updateValueAndValidity, waitIdle, waitWhilePending, } from '../../shared/forms';
+/**
+ * A form that do nothing
+ */
+export class AppNullForm {
+    invalid = false;
+    valid = false;
+    dirty = false;
+    empty = true;
+    pending = false;
+    error = null;
+    enabled = false;
+    loading = false;
+    touched = false;
+    get disabled() {
+        return !this.enabled;
+    }
+    get untouched() {
+        return !this.touched;
+    }
+    disable(opts) { }
+    enable(opts) { }
+    markAsPristine(opts) { }
+    markAsUntouched(opts) { }
+    markAsTouched(opts) { }
+    markAllAsTouched(opts) { }
+    markAsDirty(opts) { }
+    markAsLoading(opts) { }
+    markAsLoaded(opts) { }
+    markAsReady(opts) { }
+    waitIdle(opts) {
+        return Promise.reject(false);
+    }
+    ready() {
+        return Promise.reject(true);
+    }
+}
+export class AppFormProvider {
+    getterFn;
+    static NULL_FORM = new AppNullForm();
+    constructor(getterFn) {
+        this.getterFn = getterFn;
+    }
+    get delegate() {
+        return this.getterFn() || AppFormProvider.NULL_FORM;
+    }
+    waitDelegate(opts) {
+        let content;
+        return waitFor(() => {
+            content = this.getterFn();
+            return !!content;
+        }, opts).then((_) => content);
+    }
+    /* -- delegated methods -- */
+    get enabled() {
+        return this.delegate.enabled;
+    }
+    get disabled() {
+        return this.delegate.disabled;
+    }
+    get error() {
+        return this.delegate.error;
+    }
+    get invalid() {
+        return this.delegate.invalid;
+    }
+    get valid() {
+        return this.delegate.valid;
+    }
+    get dirty() {
+        return this.delegate.dirty;
+    }
+    get empty() {
+        return this.delegate.empty;
+    }
+    get pending() {
+        return this.delegate.pending;
+    }
+    get loading() {
+        return this.delegate.loading;
+    }
+    get touched() {
+        return this.delegate.touched;
+    }
+    get untouched() {
+        return this.delegate.untouched;
+    }
+    ready() {
+        return this.delegate.ready();
+    }
+    waitIdle(opts) {
+        return this.delegate.waitIdle();
+    }
+    disable(opts) {
+        return this.delegate.disable(opts);
+    }
+    enable(opts) {
+        return this.delegate.enable(opts);
+    }
+    markAsPristine(opts) {
+        return this.delegate.markAsPristine(opts);
+    }
+    markAsUntouched(opts) {
+        return this.delegate.markAsUntouched(opts);
+    }
+    markAsTouched(opts) {
+        return this.delegate.markAsTouched(opts);
+    }
+    markAllAsTouched(opts) {
+        return this.delegate.markAllAsTouched(opts);
+    }
+    markAsDirty(opts) {
+        return this.delegate.markAsDirty(opts);
+    }
+    markAsLoading(opts) {
+        return this.delegate.markAsLoading(opts);
+    }
+    markAsLoaded(opts) {
+        return this.delegate.markAsLoaded(opts);
+    }
+    markAsReady(opts) {
+        return this.delegate.markAsReady(opts);
+    }
+    async save() {
+        if (AppFormUtils.canSave(this.delegate)) {
+            return this.delegate.save();
+        }
+        return true;
+    }
+}
+/**
+ * Helper class, for angular forms
+ */
+export class AppFormUtils {
+    static copyEntity2Form = copyEntity2Form;
+    static getFormValueFromEntity = getFormValueFromEntity;
+    /**
+     * Retrieves a control from the provided form/control structure using a dot-separated path.
+     *
+     * @param {AbstractControl} form - The root form group, form array, or control to start searching from.
+     * @param {string} path - The dot-separated path specifying the control. For example, 'groupName.controlName' or 'arrayName.0.controlName'.
+     * @param {boolean} [strict=true] - If true, throws an error if the full path cannot be resolved; if false, returns the last valid control encountered.
+     * @return {AbstractControl} - The control at the specified path or the closest valid control if strict mode is disabled.
+     * @throws {Error} - Throws an error if the path cannot be resolved and strict mode is enabled.
+     */
+    static getControlFromPath = getControlFromPath;
+    static filterNumberInput = filterNumberInput;
+    static enableControls = enableControls;
+    static enableControl = enableControl;
+    static disableControl = disableControl;
+    static disableControls = disableControls;
+    static disableAndClearControl = disableAndClearControl;
+    static disableAndClearControls = disableAndClearControls;
+    static setControlEnabled = setControlEnabled;
+    static setControlsEnabled = setControlsEnabled;
+    static selectInputContentFromEvent = selectInputContentFromEvent;
+    static selectInputContent = selectInputContent;
+    /**
+     * @deprecated use markAllAsTouched() instead (naming was wrong)
+     */
+    static markAsTouched = markAllAsTouched;
+    /**
+     * Marks the control and all its descendant controls as touched.
+     * See also:
+     * - `markAsTouched()`
+     */
+    static markAllAsTouched = markAllAsTouched;
+    static markAsUntouched = markAsUntouched;
+    static waitWhilePending = waitWhilePending;
+    static waitIdle = waitIdle;
+    static updateValueAndValidity = updateValueAndValidity;
+    static isForm(object) {
+        return object instanceof AppFormProvider || ('dirty' in object && 'enabled' in object && 'valid' in object);
+    }
+    static canSave(object) {
+        return 'save' in object && AppFormUtils.isForm(object);
+    }
+    // ArrayForm
+    static addValueInArray = addValueInArray;
+    static removeValueInArray = removeValueInArray;
+    static resizeArray = resizeArray;
+    static clearValueInArray = clearValueInArray;
+    // Calculated fields
+    static calculatedSuffix = 'Calculated';
+    static isControlHasInput = isControlHasInput;
+    static setCalculatedValue = setCalculatedValue;
+    static resetCalculatedValue = resetCalculatedValue;
+    // Form errors
+    static logFormErrors = logFormErrors;
+    static filterErrorsByPrefix = filterFormErrorsByPrefix;
+    static filterErrorsByPath = filterFormErrorsByPath;
+    static filterErrors = filterFormErrors;
+    /**
+     * Retrieves all validation errors from a given form control, including its child controls if it is a form group or array.
+     *
+     * @param {AbstractControl} control - The form control to retrieve errors from. This can be a form group, a form array, or a simple form control.
+     * @param {Object} [opts] - Optional configurations for error retrieval.
+     * @param {string} [opts.controlName] - The name or path of the control being processed, used for structuring error keys in the result.
+     * @param {FormErrors} [opts.result] - The object to which errors will be added, allowing for aggregation and persistence between calls.
+     * @param {boolean} [opts.recursive=true] - Whether to recursively collect errors from child controls within a form group or array. Defaults to true.
+     * @return {FormErrors} The collected errors as a key-value object where keys represent control names or paths and values represent their respective errors. Returns `undefined` if the provided control is valid and has no errors.
+     */
+    static getFormErrors = getFormErrors;
+    /**
+     * Sets form errors on an AbstractControl, including nested controls within form groups or arrays.
+     *
+     * @param {AbstractControl} control - The form control, form group, or form array to apply the errors to.
+     * @param {FormErrors} errors - An object representing the errors to be set on the control or its children.
+     * @return {void} Does not return a value.
+     */
+    static setFormErrors = setFormErrors;
+}
+export function isControlHasInput(controls, controlName) {
+    // true if the control has a value and its 'calculated' control has the value 'false'
+    return controls[controlName].value && !toBoolean(controls[controlName + AppFormUtils.calculatedSuffix].value, false);
+}
+export function setCalculatedValue(controls, controlName, value) {
+    // set value to control
+    controls[controlName].setValue(round(value));
+    // set 'calculated' control to 'true'
+    controls[controlName + AppFormUtils.calculatedSuffix].setValue(true);
+}
+export function resetCalculatedValue(controls, controlName) {
+    if (!isControlHasInput(controls, controlName)) {
+        // set undefined only if control already calculated
+        AppFormUtils.setCalculatedValue(controls, controlName, undefined);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.utils.js","sourceRoot":"","sources":["../../../../../../src/app/core/form/form.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl } from '@angular/forms';\nimport { round, toBoolean } from '../../shared/functions';\nimport { filterNumberInput, selectInputContent, selectInputContentFromEvent } from '../../shared/inputs';\nimport { waitFor, WaitForOptions } from '../../shared/observables';\nimport {\n  addValueInArray,\n  clearValueInArray,\n  copyEntity2Form,\n  disableAndClearControl,\n  disableAndClearControls,\n  disableControl,\n  disableControls,\n  enableControl,\n  enableControls,\n  filterFormErrors,\n  filterFormErrorsByPath,\n  filterFormErrorsByPrefix,\n  getControlFromPath,\n  getFormErrors,\n  getFormValueFromEntity,\n  logFormErrors,\n  markAllAsTouched,\n  markAsUntouched,\n  removeValueInArray,\n  resizeArray,\n  setControlEnabled,\n  setControlsEnabled,\n  setFormErrors,\n  updateValueAndValidity,\n  waitIdle,\n  waitWhilePending,\n} from '../../shared/forms';\n\nexport declare type IAppFormGetter = () => IAppForm;\n\nexport declare interface OnReady {\n  ngOnReady();\n}\n\nexport interface IAppForm<T = any> {\n  // From Angular form\n  invalid: boolean;\n  valid: boolean;\n  dirty: boolean;\n  pending: boolean;\n  error: string;\n  enabled: boolean;\n  disabled: boolean;\n  touched: boolean;\n  untouched: boolean;\n  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n\n  // Specific to IAppForm\n  empty?: boolean;\n  loading?: boolean;\n  loaded?: boolean;\n  destroyed?: boolean;\n  ready(): Promise<void>;\n  waitIdle(opts?: WaitForOptions): Promise<any>;\n\n  // Optional functions\n  setValue?: (data: T, opts?: { onlySelf?: boolean; emitEvent?: boolean }) => Promise<void> | void;\n  patchValue?: (data: T, opts?: { onlySelf?: boolean; emitEvent?: boolean }) => Promise<void> | void;\n  reset?: (data?: T, opts?: { onlySelf?: boolean; emitEvent?: boolean }) => void;\n  getValue?: () => Promise<T> | T;\n\n  markAsPristine(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAsUntouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAsTouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAllAsTouched(opts?: { emitEvent?: boolean }): void;\n  markAsDirty(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAsLoading(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAsLoaded(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n  markAsReady(opts?: { onlySelf?: boolean; emitEvent?: boolean }): void;\n}\n\nexport interface CanSave {\n  dirty: boolean;\n  valid: boolean;\n  save(): Promise<boolean>;\n}\n\nexport interface CanLeave extends CanSave {\n  cancel(event?: Event): Promise<void>;\n  deactivate?: () => Promise<void>;\n}\n\n/**\n * A form that do nothing\n */\nexport class AppNullForm implements IAppForm {\n  readonly invalid = false;\n  readonly valid = false;\n  readonly dirty = false;\n  readonly empty = true;\n  readonly pending = false;\n  readonly error = null;\n  readonly enabled = false;\n  readonly loading = false;\n  readonly touched = false;\n  get disabled(): boolean {\n    return !this.enabled;\n  }\n  get untouched(): boolean {\n    return !this.touched;\n  }\n\n  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n\n  markAsPristine(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAsUntouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAsTouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAllAsTouched(opts?: { emitEvent?: boolean }) {}\n  markAsDirty(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAsLoading(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAsLoaded(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n  markAsReady(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {}\n\n  waitIdle(opts?: WaitForOptions): Promise<any> {\n    return Promise.reject(false);\n  }\n  ready(): Promise<any> {\n    return Promise.reject(true);\n  }\n}\n\nexport class AppFormProvider<F extends IAppForm = IAppForm> implements IAppForm {\n  static NULL_FORM = new AppNullForm();\n\n  constructor(private getterFn: () => F) {}\n\n  private get delegate(): IAppForm {\n    return this.getterFn() || AppFormProvider.NULL_FORM;\n  }\n\n  waitDelegate(opts?: WaitForOptions): Promise<F> {\n    let content: F;\n    return waitFor(() => {\n      content = this.getterFn();\n      return !!content;\n    }, opts).then((_) => content);\n  }\n\n  /* -- delegated methods -- */\n\n  get enabled(): boolean {\n    return this.delegate.enabled;\n  }\n  get disabled(): boolean {\n    return this.delegate.disabled;\n  }\n  get error(): string {\n    return this.delegate.error;\n  }\n  get invalid(): boolean {\n    return this.delegate.invalid;\n  }\n  get valid(): boolean {\n    return this.delegate.valid;\n  }\n  get dirty(): boolean {\n    return this.delegate.dirty;\n  }\n  get empty(): boolean {\n    return this.delegate.empty;\n  }\n  get pending(): boolean {\n    return this.delegate.pending;\n  }\n  get loading(): boolean {\n    return this.delegate.loading;\n  }\n  get touched(): boolean {\n    return this.delegate.touched;\n  }\n  get untouched(): boolean {\n    return this.delegate.untouched;\n  }\n  ready(): Promise<any> {\n    return this.delegate.ready();\n  }\n  waitIdle(opts?: WaitForOptions): Promise<any> {\n    return this.delegate.waitIdle();\n  }\n  disable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.disable(opts);\n  }\n  enable(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.enable(opts);\n  }\n  markAsPristine(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsPristine(opts);\n  }\n  markAsUntouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsUntouched(opts);\n  }\n  markAsTouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsTouched(opts);\n  }\n  markAllAsTouched(opts?: { emitEvent?: boolean }) {\n    return this.delegate.markAllAsTouched(opts);\n  }\n  markAsDirty(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsDirty(opts);\n  }\n  markAsLoading(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsLoading(opts);\n  }\n  markAsLoaded(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsLoaded(opts);\n  }\n  markAsReady(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    return this.delegate.markAsReady(opts);\n  }\n\n  async save(): Promise<boolean> {\n    if (AppFormUtils.canSave(this.delegate)) {\n      return this.delegate.save();\n    }\n    return true;\n  }\n}\n\n/**\n * Helper class, for angular forms\n */\nexport class AppFormUtils {\n  static copyEntity2Form = copyEntity2Form;\n  static getFormValueFromEntity = getFormValueFromEntity;\n\n  /**\n   * Retrieves a control from the provided form/control structure using a dot-separated path.\n   *\n   * @param {AbstractControl} form - The root form group, form array, or control to start searching from.\n   * @param {string} path - The dot-separated path specifying the control. For example, 'groupName.controlName' or 'arrayName.0.controlName'.\n   * @param {boolean} [strict=true] - If true, throws an error if the full path cannot be resolved; if false, returns the last valid control encountered.\n   * @return {AbstractControl} - The control at the specified path or the closest valid control if strict mode is disabled.\n   * @throws {Error} - Throws an error if the path cannot be resolved and strict mode is enabled.\n   */\n  static getControlFromPath = getControlFromPath;\n\n  static filterNumberInput = filterNumberInput;\n  static enableControls = enableControls;\n  static enableControl = enableControl;\n  static disableControl = disableControl;\n  static disableControls = disableControls;\n  static disableAndClearControl = disableAndClearControl;\n  static disableAndClearControls = disableAndClearControls;\n  static setControlEnabled = setControlEnabled;\n  static setControlsEnabled = setControlsEnabled;\n  static selectInputContentFromEvent = selectInputContentFromEvent;\n  static selectInputContent = selectInputContent;\n  /**\n   * @deprecated use markAllAsTouched() instead (naming was wrong)\n   */\n  static markAsTouched = markAllAsTouched;\n\n  /**\n   * Marks the control and all its descendant controls as touched.\n   * See also:\n   * - `markAsTouched()`\n   */\n  static markAllAsTouched = markAllAsTouched;\n  static markAsUntouched = markAsUntouched;\n  static waitWhilePending = waitWhilePending;\n  static waitIdle = waitIdle;\n  static updateValueAndValidity = updateValueAndValidity;\n\n  static isForm(object: any): object is IAppForm {\n    return object instanceof AppFormProvider || ('dirty' in object && 'enabled' in object && 'valid' in object);\n  }\n\n  static canSave(object: any): object is IAppForm & CanSave {\n    return 'save' in object && AppFormUtils.isForm(object);\n  }\n\n  // ArrayForm\n  static addValueInArray = addValueInArray;\n  static removeValueInArray = removeValueInArray;\n  static resizeArray = resizeArray;\n  static clearValueInArray = clearValueInArray;\n\n  // Calculated fields\n  static calculatedSuffix = 'Calculated';\n  static isControlHasInput = isControlHasInput;\n  static setCalculatedValue = setCalculatedValue;\n  static resetCalculatedValue = resetCalculatedValue;\n\n  // Form errors\n  static logFormErrors = logFormErrors;\n  static filterErrorsByPrefix = filterFormErrorsByPrefix;\n  static filterErrorsByPath = filterFormErrorsByPath;\n  static filterErrors = filterFormErrors;\n\n  /**\n   * Retrieves all validation errors from a given form control, including its child controls if it is a form group or array.\n   *\n   * @param {AbstractControl} control - The form control to retrieve errors from. This can be a form group, a form array, or a simple form control.\n   * @param {Object} [opts] - Optional configurations for error retrieval.\n   * @param {string} [opts.controlName] - The name or path of the control being processed, used for structuring error keys in the result.\n   * @param {FormErrors} [opts.result] - The object to which errors will be added, allowing for aggregation and persistence between calls.\n   * @param {boolean} [opts.recursive=true] - Whether to recursively collect errors from child controls within a form group or array. Defaults to true.\n   * @return {FormErrors} The collected errors as a key-value object where keys represent control names or paths and values represent their respective errors. Returns `undefined` if the provided control is valid and has no errors.\n   */\n  static getFormErrors = getFormErrors;\n\n  /**\n   * Sets form errors on an AbstractControl, including nested controls within form groups or arrays.\n   *\n   * @param {AbstractControl} control - The form control, form group, or form array to apply the errors to.\n   * @param {FormErrors} errors - An object representing the errors to be set on the control or its children.\n   * @return {void} Does not return a value.\n   */\n  static setFormErrors = setFormErrors;\n}\n\nexport function isControlHasInput(controls: { [key: string]: AbstractControl }, controlName: string): boolean {\n  // true if the control has a value and its 'calculated' control has the value 'false'\n  return controls[controlName].value && !toBoolean(controls[controlName + AppFormUtils.calculatedSuffix].value, false);\n}\n\nexport function setCalculatedValue(controls: { [key: string]: AbstractControl }, controlName: string, value: number | undefined) {\n  // set value to control\n  controls[controlName].setValue(round(value));\n  // set 'calculated' control to 'true'\n  controls[controlName + AppFormUtils.calculatedSuffix].setValue(true);\n}\n\nexport function resetCalculatedValue(controls: { [key: string]: AbstractControl }, controlName: string) {\n  if (!isControlHasInput(controls, controlName)) {\n    // set undefined only if control already calculated\n    AppFormUtils.setCalculatedValue(controls, controlName, undefined);\n  }\n}\n"]}

package/esm2022/src/app/core/form/list/list.form.mjs

@@ -0,0 +1,235 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Optional, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { referentialToString } from '../../services/model/referential.model';
+import { isNil } from '../../../shared/functions';
+import { AppForm } from '../form.class';
+import { AppFormUtils } from '../form.utils';
+import { SelectionModel } from '@angular/cdk/collections';
+import { FormArrayHelper } from '../array/form-array';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/core";
+import * as i3 from "../../services/local-settings.service";
+import * as i4 from "@angular/common";
+import * as i5 from "@ionic/angular";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "../../../shared/pipes/arrays.pipe";
+export class AppListForm extends AppForm {
+    injector;
+    formBuilder;
+    dateAdapter;
+    settings;
+    cd;
+    formGroupDir;
+    helper;
+    selection = new SelectionModel(true, []);
+    formArrayName;
+    formArray;
+    options;
+    displayWithFn = referentialToString;
+    equalsFn;
+    onNewItem = new EventEmitter();
+    selectionChanges = new EventEmitter(true);
+    set value(data) {
+        this.setValue(data);
+    }
+    get value() {
+        return this.formArray.value;
+    }
+    get itemControls() {
+        return this.formArray && this.formArray.controls;
+    }
+    get length() {
+        return this.helper ? this.helper.size() : 0;
+    }
+    get empty() {
+        return this.length === 0;
+    }
+    get touched() {
+        return this.formArray && (this.formArray.touched || (this.formArray.controls || []).findIndex((c) => c.touched) !== -1);
+    }
+    get untouched() {
+        return !this.formArray || this.formArray.untouched || (this.formArray.controls || []).findIndex((c) => c.touched) === -1;
+    }
+    get dirty() {
+        return this.formArray && this.formArray.dirty;
+    }
+    get invalid() {
+        return !this.formArray || this.formArray.invalid;
+    }
+    get valid() {
+        return this.formArray && this.formArray.valid;
+    }
+    get pending() {
+        return !this.formArray || this.formArray.pending;
+    }
+    markAsTouched(opts) {
+        AppFormUtils.markAsTouched(this.formArray, opts);
+        if (!opts || opts.emitEvent !== false)
+            this.markForCheck();
+    }
+    markAllAsTouched(opts) {
+        AppFormUtils.markAllAsTouched(this.formArray, opts);
+        if (!opts || opts.emitEvent !== false)
+            this.markForCheck();
+    }
+    constructor(injector, formBuilder, dateAdapter, settings, cd, formGroupDir) {
+        super(injector, null);
+        this.injector = injector;
+        this.formBuilder = formBuilder;
+        this.dateAdapter = dateAdapter;
+        this.settings = settings;
+        this.cd = cd;
+        this.formGroupDir = formGroupDir;
+        //this.debug = !environment.production;
+    }
+    ngOnInit() {
+        this.options = {
+            allowEmptyArray: true,
+            allowMultipleSelection: true,
+            buttons: [],
+            ...this.options,
+        };
+        // Retrieve the form
+        const form = (this.formArray && this.formArray.parent) || (this.formGroupDir && this.formGroupDir.form) || this.formBuilder.group({});
+        this.setForm(form);
+        this.formArray = this.formArray || (this.formArrayName && form.get(this.formArrayName));
+        this.formArrayName =
+            this.formArrayName || (this.formArray && Object.keys(form.controls).find((key) => form.get(key) === this.formArray)) || 'properties';
+        if (!this.formArray) {
+            console.warn(`Missing array control '${this.formArrayName}'. Will create it!`);
+            this.formArray = this.formBuilder.array([]);
+            this.form.addControl(this.formArrayName, this.formArray);
+        }
+        this.equalsFn = this.equalsFn || ((v1, v2) => (isNil(v1) && isNil(v2)) || v1 === v2);
+        this.helper = new FormArrayHelper(this.formArray, (value) => this.createControl(value), this.equalsFn, (value) => isNil(value), this.options);
+        super.ngOnInit();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.onNewItem.complete();
+        this.onNewItem.unsubscribe();
+        this.selectionChanges.complete();
+        this.selectionChanges.unsubscribe();
+    }
+    setValue(data) {
+        data = data || [];
+        if (this.helper) {
+            this.helper.resize(data.length);
+            this.helper.formArray.patchValue(data, { emitEvent: false });
+        }
+        else {
+            console.warn('TODO: cannot applied setValue() on fromArray, because formArrayHelper not exists yet !');
+        }
+        this.selection.clear();
+        this.markAsPristine();
+        this.markAsLoaded();
+    }
+    /** Whether the number of selected elements matches the total number of rows. */
+    isAllSelected() {
+        return this.selection.selected.length === this.length;
+    }
+    async masterToggle(opts) {
+        if (this.loading)
+            return;
+        if (this.isAllSelected()) {
+            this.selection.clear();
+        }
+        else {
+            const items = this.value;
+            items.forEach((item) => this.selection.select(item));
+        }
+        if (!opts || opts.emitEvent !== false) {
+            this.selectionChanges.emit(this.selection.selected);
+        }
+    }
+    async onItemClick(event, item, opts) {
+        if (!item || event.defaultPrevented || !this.selectionChanges.observed)
+            return;
+        // Multiple selection (if ctrl+click)
+        if (event.ctrlKey && this.options.allowMultipleSelection) {
+            this.selection.toggle(item);
+        }
+        else {
+            // Unselect all
+            // Select the item (or reselect)
+            if (!this.selection.isSelected(item) || (this.options.allowMultipleSelection && this.selection.selected.length > 1)) {
+                this.selection.clear();
+                this.selection.select(item);
+            }
+            // Unselect all
+            else {
+                this.selection.clear();
+            }
+        }
+        if (!opts || opts.emitEvent !== false) {
+            this.selectionChanges.emit(this.selection.selected);
+        }
+    }
+    async onItemButtonClick(button, event, item, index) {
+        if (button.click)
+            button.click(event, item, index);
+        await this.onItemClick(event, item);
+    }
+    hasSelection() {
+        return this.selection.hasValue();
+    }
+    onNewClick(event) {
+        this.onNewItem.emit(event);
+    }
+    add(value, opts) {
+        const done = this.helper.add(value, { emitEvent: true });
+        if (done) {
+            if (!this.options.allowMultipleSelection) {
+                this.selection.clear();
+            }
+            this.selection.toggle(value);
+            this.markForCheck();
+            if (!opts || opts.emitEvent !== false) {
+                this.selectionChanges.emit(this.selection.selected);
+            }
+        }
+    }
+    removeAt(index) {
+        const item = this.helper.at(index).value;
+        if (this.selection.isSelected(item)) {
+            this.selection.deselect(item);
+        }
+        this.helper.removeAt(index);
+    }
+    displayWith(value) {
+        return this.displayWithFn ? this.displayWithFn(value) : value;
+    }
+    /* -- protected methods -- */
+    createControl(data) {
+        return this.formBuilder.control(data || null, Validators.required);
+    }
+    markForCheck() {
+        this.cd.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppListForm, deps: [{ token: i0.Injector }, { token: i1.UntypedFormBuilder }, { token: i2.DateAdapter }, { token: i3.LocalSettingsService }, { token: i0.ChangeDetectorRef }, { token: i1.FormGroupDirective, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: AppListForm, selector: "app-list-form", inputs: { formArrayName: "formArrayName", formArray: "formArray", options: "options", displayWithFn: ["displayWith", "displayWithFn"], equalsFn: ["equals", "equalsFn"] }, outputs: { onNewItem: "onNewItem", selectionChanges: "selectionChanges" }, usesInheritance: true, ngImport: i0, template: "<ng-container *ngIf=\"!loading; else listSkeleton\">\n  <!-- List -->\n  <ion-list class=\"ion-no-padding\">\n    <ng-container *ngFor=\"let itemControl of itemControls; index as i; last as last\">\n      <ion-item\n        *ngIf=\"itemControl.value; let item\"\n        [class.disabled]=\"disabled\"\n        tappable\n        (click)=\"onItemClick($event, item)\"\n        [color]=\"selection.isSelected(item) ? 'secondary100' : undefined\"\n        [button]=\"selectionChanges.observers | isNotEmptyArray\"\n      >\n        <ion-label>{{ displayWith(item) }}</ion-label>\n\n        <!-- buttons -->\n        <ion-buttons slot=\"end\" *ngIf=\"enabled\" class=\"action-buttons\">\n          <ion-button fill=\"clear\" (click)=\"removeAt(i)\">\n            <ion-icon slot=\"icon-only\" name=\"trash\"></ion-icon>\n          </ion-button>\n\n          <ion-button\n            *ngFor=\"let button of options.buttons\"\n            fill=\"clear\"\n            [color]=\"button.color\"\n            [class.cdk-visually-hidden]=\"button.disabled | async\"\n            (click)=\"onItemButtonClick(button, $event, item, i)\"\n            [title]=\"button.title || '' | translate\"\n          >\n            <ion-icon slot=\"icon-only\" [name]=\"button.icon\"></ion-icon>\n          </ion-button>\n        </ion-buttons>\n      </ion-item>\n    </ng-container>\n  </ion-list>\n\n  <!-- Add button -->\n  <ion-button\n    color=\"tertiary\"\n    fill=\"clear\"\n    *ngIf=\"enabled && onNewItem.observed; else emptyText\"\n    [title]=\"'COMMON.BTN_ADD' | translate\"\n    (click)=\"onNewClick($event)\"\n  >\n    <ion-icon slot=\"start\" name=\"add\"></ion-icon>\n    <ion-label translate>COMMON.BTN_ADD</ion-label>\n  </ion-button>\n\n  <!-- Empty (if readonly) -->\n  <ng-template #emptyText>\n    <ion-text *ngIf=\"!length\" color=\"medium\"><i translate>COMMON.EMPTY_OPTION</i></ion-text>\n  </ng-template>\n</ng-container>\n\n<ng-template #listSkeleton>\n  <ion-list>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n  </ion-list>\n</ng-template>\n\n<ng-template #itemSkeleton>\n  <ion-item>\n    <ion-label>\n      <ion-skeleton-text animated style=\"width: 60%\"></ion-skeleton-text>\n    </ion-label>\n  </ion-item>\n</ng-template>\n", styles: [":host{--ion-item-background-selected: var(--ion-color-secondary100);--ion-item-color-selected: var(--ion-color-secondary100-contrast)}ion-item.disabled ion-label{color:var(--ion-color-medium-shade, grey)}ion-item{--min-height: 48px;background-color:var(--ion-item-background)}ion-item ion-text,ion-item ion-label{color:var(--ion-item-color)}ion-item .action-buttons{visibility:hidden;display:none}ion-item:hover{height:var(--min-height);--ion-item-background-color: var(--ion-color-light);--ion-item-color: var(--ion-color-light-contrast)}ion-item:hover .action-buttons{margin-top:-1px;visibility:visible;display:block}ion-item.selected{--ion-item-background-color-hover: var(--ion-item-background-selected) !important;--ion-item-color-hover: var(--ion-item-color-selected) !important}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i5.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i5.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i5.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i5.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i5.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i5.IonList, selector: "ion-list", inputs: ["inset", "lines", "mode"] }, { kind: "component", type: i5.IonSkeletonText, selector: "ion-skeleton-text", inputs: ["animated"] }, { kind: "component", type: i5.IonText, selector: "ion-text", inputs: ["color", "mode"] }, { kind: "directive", type: i6.TranslateDirective, selector: "[translate],[ngx-translate]", inputs: ["translate", "translateParams"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }, { kind: "pipe", type: i7.NotEmptyArrayPipe, name: "isNotEmptyArray" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppListForm, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-list-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"!loading; else listSkeleton\">\n  <!-- List -->\n  <ion-list class=\"ion-no-padding\">\n    <ng-container *ngFor=\"let itemControl of itemControls; index as i; last as last\">\n      <ion-item\n        *ngIf=\"itemControl.value; let item\"\n        [class.disabled]=\"disabled\"\n        tappable\n        (click)=\"onItemClick($event, item)\"\n        [color]=\"selection.isSelected(item) ? 'secondary100' : undefined\"\n        [button]=\"selectionChanges.observers | isNotEmptyArray\"\n      >\n        <ion-label>{{ displayWith(item) }}</ion-label>\n\n        <!-- buttons -->\n        <ion-buttons slot=\"end\" *ngIf=\"enabled\" class=\"action-buttons\">\n          <ion-button fill=\"clear\" (click)=\"removeAt(i)\">\n            <ion-icon slot=\"icon-only\" name=\"trash\"></ion-icon>\n          </ion-button>\n\n          <ion-button\n            *ngFor=\"let button of options.buttons\"\n            fill=\"clear\"\n            [color]=\"button.color\"\n            [class.cdk-visually-hidden]=\"button.disabled | async\"\n            (click)=\"onItemButtonClick(button, $event, item, i)\"\n            [title]=\"button.title || '' | translate\"\n          >\n            <ion-icon slot=\"icon-only\" [name]=\"button.icon\"></ion-icon>\n          </ion-button>\n        </ion-buttons>\n      </ion-item>\n    </ng-container>\n  </ion-list>\n\n  <!-- Add button -->\n  <ion-button\n    color=\"tertiary\"\n    fill=\"clear\"\n    *ngIf=\"enabled && onNewItem.observed; else emptyText\"\n    [title]=\"'COMMON.BTN_ADD' | translate\"\n    (click)=\"onNewClick($event)\"\n  >\n    <ion-icon slot=\"start\" name=\"add\"></ion-icon>\n    <ion-label translate>COMMON.BTN_ADD</ion-label>\n  </ion-button>\n\n  <!-- Empty (if readonly) -->\n  <ng-template #emptyText>\n    <ion-text *ngIf=\"!length\" color=\"medium\"><i translate>COMMON.EMPTY_OPTION</i></ion-text>\n  </ng-template>\n</ng-container>\n\n<ng-template #listSkeleton>\n  <ion-list>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n  </ion-list>\n</ng-template>\n\n<ng-template #itemSkeleton>\n  <ion-item>\n    <ion-label>\n      <ion-skeleton-text animated style=\"width: 60%\"></ion-skeleton-text>\n    </ion-label>\n  </ion-item>\n</ng-template>\n", styles: [":host{--ion-item-background-selected: var(--ion-color-secondary100);--ion-item-color-selected: var(--ion-color-secondary100-contrast)}ion-item.disabled ion-label{color:var(--ion-color-medium-shade, grey)}ion-item{--min-height: 48px;background-color:var(--ion-item-background)}ion-item ion-text,ion-item ion-label{color:var(--ion-item-color)}ion-item .action-buttons{visibility:hidden;display:none}ion-item:hover{height:var(--min-height);--ion-item-background-color: var(--ion-color-light);--ion-item-color: var(--ion-color-light-contrast)}ion-item:hover .action-buttons{margin-top:-1px;visibility:visible;display:block}ion-item.selected{--ion-item-background-color-hover: var(--ion-item-background-selected) !important;--ion-item-color-hover: var(--ion-item-color-selected) !important}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.UntypedFormBuilder }, { type: i2.DateAdapter }, { type: i3.LocalSettingsService }, { type: i0.ChangeDetectorRef }, { type: i1.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { formArrayName: [{
+                type: Input
+            }], formArray: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], displayWithFn: [{
+                type: Input,
+                args: ['displayWith']
+            }], equalsFn: [{
+                type: Input,
+                args: ['equals']
+            }], onNewItem: [{
+                type: Output
+            }], selectionChanges: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.form.js","sourceRoot":"","sources":["../../../../../../../src/app/core/form/list/list.form.ts","../../../../../../../src/app/core/form/list/list.form.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAqB,SAAS,EAAE,YAAY,EAAY,KAAK,EAAU,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC/I,OAAO,EAA+F,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACzI,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAIlD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG1D,OAAO,EAAE,eAAe,EAA0B,MAAM,qBAAqB,CAAC;;;;;;;;;AAqB9E,MAAM,OAAO,WAAqB,SAAQ,OAAY;IAqExC;IACA;IACA;IACA;IACA;IACU;IAzEtB,MAAM,CAAqB;IAC3B,SAAS,GAAG,IAAI,cAAc,CAAI,IAAI,EAAE,EAAE,CAAC,CAAC;IAEnC,aAAa,CAAS;IACtB,SAAS,CAAmB;IAC5B,OAAO,CAAwB;IAElB,aAAa,GAA0B,mBAAmB,CAAC;IAChE,QAAQ,CAA4B;IAE3C,SAAS,GAAG,IAAI,YAAY,EAAS,CAAC;IACtC,gBAAgB,GAAG,IAAI,YAAY,CAAM,IAAI,CAAC,CAAC;IAEzD,IAAI,KAAK,CAAC,IAAS;QACjB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,CAAC,KAAY,CAAC;IACrC,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,SAAS,IAAK,IAAI,CAAC,SAAS,CAAC,QAA+B,CAAC;IAC3E,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1H,CAAC;IAED,IAAI,SAAS;QACX,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3H,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAChD,CAAC;IAED,IAAI,OAAO;QACT,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;IACnD,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAChD,CAAC;IAED,IAAI,OAAO;QACT,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;IACnD,CAAC;IAED,aAAa,CAAC,IAAkD;QAC9D,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK;YAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7D,CAAC;IAED,gBAAgB,CAAC,IAA8B;QAC7C,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK;YAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7D,CAAC;IAED,YACY,QAAkB,EAClB,WAA+B,EAC/B,WAAgC,EAChC,QAA8B,EAC9B,EAAqB,EACX,YAAgC;QAEpD,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAPZ,aAAQ,GAAR,QAAQ,CAAU;QAClB,gBAAW,GAAX,WAAW,CAAoB;QAC/B,gBAAW,GAAX,WAAW,CAAqB;QAChC,aAAQ,GAAR,QAAQ,CAAsB;QAC9B,OAAE,GAAF,EAAE,CAAmB;QACX,iBAAY,GAAZ,YAAY,CAAoB;QAIpD,uCAAuC;IACzC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,OAAO,GAAG;YACb,eAAe,EAAE,IAAI;YACrB,sBAAsB,EAAE,IAAI;YAC5B,OAAO,EAAE,EAAE;YACX,GAAG,IAAI,CAAC,OAAO;SAChB,CAAC;QAEF,oBAAoB;QACpB,MAAM,IAAI,GACR,CAAC,IAAI,CAAC,SAAS,IAAK,IAAI,CAAC,SAAS,CAAC,MAA2B,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACjJ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEnB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa,IAAK,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAsB,CAAC,CAAC;QAC9G,IAAI,CAAC,aAAa;YAChB,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,YAAY,CAAC;QACvI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO,CAAC,IAAI,CAAC,0BAA0B,IAAI,CAAC,aAAa,oBAAoB,CAAC,CAAC;YAC/E,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC5C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAO,EAAE,EAAO,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAC/F,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAC/B,IAAI,CAAC,SAAS,EACd,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EACpC,IAAI,CAAC,QAAQ,EACb,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EACvB,IAAI,CAAC,OAAO,CACb,CAAC;QAEF,KAAK,CAAC,QAAQ,EAAE,CAAC;IACnB,CAAC;IAED,WAAW;QACT,KAAK,CAAC,WAAW,EAAE,CAAC;QAEpB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAC7B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QACjC,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC;IACtC,CAAC;IAED,QAAQ,CAAC,IAAe;QACtB,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAElB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAChC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC/D,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,wFAAwF,CAAC,CAAC;QACzG,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,gFAAgF;IAChF,aAAa;QACX,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,CAAC;IACxD,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,IAA8B;QAC/C,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,IAAI,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACzB,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;YACtC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,KAAiB,EAAE,IAAO,EAAE,IAA8B;QAC1E,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ;YAAE,OAAO;QAE/E,qCAAqC;QACrC,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC;YACzD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,eAAe;YAEf,gCAAgC;YAChC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;gBACpH,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;gBACvB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC9B,CAAC;YACD,eAAe;iBACV,CAAC;gBACJ,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,CAAC;QACH,CAAC;QAED,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;YACtC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,MAAkB,EAAE,KAAiB,EAAE,IAAO,EAAE,KAAa;QACnF,IAAI,MAAM,CAAC,KAAK;YAAE,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACnD,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IAED,UAAU,CAAC,KAAK;QACd,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,GAAG,CAAC,KAAQ,EAAE,IAA8B;QAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,CAAC;gBACzC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,CAAC;YACD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,CAAC,YAAY,EAAE,CAAC;YAEpB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;gBACtC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;IACH,CAAC;IAED,QAAQ,CAAC,KAAa;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;QACzC,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,WAAW,CAAC,KAAQ;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,KAAa,CAAC;IACzE,CAAC;IAED,6BAA6B;IAEnB,aAAa,CAAC,IAAU;QAChC,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;IACrE,CAAC;IAES,YAAY;QACpB,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC;IACzB,CAAC;wGAvOU,WAAW;4FAAX,WAAW,kUCjCxB,g2EAoEA;;4FDnCa,WAAW;kBANvB,SAAS;+BACE,eAAe,mBAGR,uBAAuB,CAAC,MAAM;;0BA4E5C,QAAQ;yCAtEF,aAAa;sBAArB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAEgB,aAAa;sBAAlC,KAAK;uBAAC,aAAa;gBACH,QAAQ;sBAAxB,KAAK;uBAAC,QAAQ;gBAEL,SAAS;sBAAlB,MAAM;gBACG,gBAAgB;sBAAzB,MAAM","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injector, Input, OnInit, Optional, Output } from '@angular/core';\nimport { AbstractControl, FormGroupDirective, UntypedFormArray, UntypedFormBuilder, UntypedFormGroup, Validators } from '@angular/forms';\nimport { referentialToString } from '../../services/model/referential.model';\nimport { isNil } from '../../../shared/functions';\nimport { DateAdapter } from '@angular/material/core';\nimport { Moment } from 'moment';\nimport { LocalSettingsService } from '../../services/local-settings.service';\nimport { AppForm } from '../form.class';\nimport { AppFormUtils } from '../form.utils';\nimport { SelectionModel } from '@angular/cdk/collections';\nimport { Observable } from 'rxjs';\nimport { Color } from '@ionic/core';\nimport { FormArrayHelper, FormArrayHelperOptions } from '../array/form-array';\n\nexport declare interface ItemButton<T = any> {\n  title?: string;\n  click: (event: Event, item: T, index: number) => void;\n  icon: string;\n  color?: Color;\n  disabled?: Observable<boolean>;\n}\n\nexport declare type AppListFormOptions<T> = FormArrayHelperOptions & {\n  allowMultipleSelection?: boolean;\n  buttons?: ItemButton<T>[];\n};\n\n@Component({\n  selector: 'app-list-form',\n  templateUrl: 'list.form.html',\n  styleUrls: ['./list.form.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class AppListForm<T = any> extends AppForm<T[]> implements OnInit {\n  helper: FormArrayHelper<T>;\n  selection = new SelectionModel<T>(true, []);\n\n  @Input() formArrayName: string;\n  @Input() formArray: UntypedFormArray;\n  @Input() options: AppListFormOptions<T>;\n\n  @Input('displayWith') displayWithFn: (item: any) => string = referentialToString;\n  @Input('equals') equalsFn: (v1: T, v2: T) => boolean;\n\n  @Output() onNewItem = new EventEmitter<Event>();\n  @Output() selectionChanges = new EventEmitter<T[]>(true);\n\n  set value(data: T[]) {\n    this.setValue(data);\n  }\n\n  get value(): T[] {\n    return this.formArray.value as T[];\n  }\n\n  get itemControls(): UntypedFormGroup[] {\n    return this.formArray && (this.formArray.controls as UntypedFormGroup[]);\n  }\n\n  get length(): number {\n    return this.helper ? this.helper.size() : 0;\n  }\n\n  get empty(): boolean {\n    return this.length === 0;\n  }\n\n  get touched(): boolean {\n    return this.formArray && (this.formArray.touched || (this.formArray.controls || []).findIndex((c) => c.touched) !== -1);\n  }\n\n  get untouched(): boolean {\n    return !this.formArray || this.formArray.untouched || (this.formArray.controls || []).findIndex((c) => c.touched) === -1;\n  }\n\n  get dirty(): boolean {\n    return this.formArray && this.formArray.dirty;\n  }\n\n  get invalid(): boolean {\n    return !this.formArray || this.formArray.invalid;\n  }\n\n  get valid(): boolean {\n    return this.formArray && this.formArray.valid;\n  }\n\n  get pending(): boolean {\n    return !this.formArray || this.formArray.pending;\n  }\n\n  markAsTouched(opts?: { onlySelf?: boolean; emitEvent?: boolean }) {\n    AppFormUtils.markAsTouched(this.formArray, opts);\n    if (!opts || opts.emitEvent !== false) this.markForCheck();\n  }\n\n  markAllAsTouched(opts?: { emitEvent?: boolean }) {\n    AppFormUtils.markAllAsTouched(this.formArray, opts);\n    if (!opts || opts.emitEvent !== false) this.markForCheck();\n  }\n\n  constructor(\n    protected injector: Injector,\n    protected formBuilder: UntypedFormBuilder,\n    protected dateAdapter: DateAdapter<Moment>,\n    protected settings: LocalSettingsService,\n    protected cd: ChangeDetectorRef,\n    @Optional() private formGroupDir: FormGroupDirective\n  ) {\n    super(injector, null);\n\n    //this.debug = !environment.production;\n  }\n\n  ngOnInit() {\n    this.options = {\n      allowEmptyArray: true,\n      allowMultipleSelection: true,\n      buttons: [],\n      ...this.options,\n    };\n\n    // Retrieve the form\n    const form =\n      (this.formArray && (this.formArray.parent as UntypedFormGroup)) || (this.formGroupDir && this.formGroupDir.form) || this.formBuilder.group({});\n    this.setForm(form);\n\n    this.formArray = this.formArray || (this.formArrayName && (form.get(this.formArrayName) as UntypedFormArray));\n    this.formArrayName =\n      this.formArrayName || (this.formArray && Object.keys(form.controls).find((key) => form.get(key) === this.formArray)) || 'properties';\n    if (!this.formArray) {\n      console.warn(`Missing array control '${this.formArrayName}'. Will create it!`);\n      this.formArray = this.formBuilder.array([]);\n      this.form.addControl(this.formArrayName, this.formArray);\n    }\n\n    this.equalsFn = this.equalsFn || ((v1: any, v2: any) => (isNil(v1) && isNil(v2)) || v1 === v2);\n    this.helper = new FormArrayHelper<T>(\n      this.formArray,\n      (value) => this.createControl(value),\n      this.equalsFn,\n      (value) => isNil(value),\n      this.options\n    );\n\n    super.ngOnInit();\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n\n    this.onNewItem.complete();\n    this.onNewItem.unsubscribe();\n    this.selectionChanges.complete();\n    this.selectionChanges.unsubscribe();\n  }\n\n  setValue(data: T[] | any) {\n    data = data || [];\n\n    if (this.helper) {\n      this.helper.resize(data.length);\n      this.helper.formArray.patchValue(data, { emitEvent: false });\n    } else {\n      console.warn('TODO: cannot applied setValue() on fromArray, because formArrayHelper not exists yet !');\n    }\n\n    this.selection.clear();\n    this.markAsPristine();\n    this.markAsLoaded();\n  }\n\n  /** Whether the number of selected elements matches the total number of rows. */\n  isAllSelected() {\n    return this.selection.selected.length === this.length;\n  }\n\n  async masterToggle(opts?: { emitEvent?: boolean }) {\n    if (this.loading) return;\n    if (this.isAllSelected()) {\n      this.selection.clear();\n    } else {\n      const items = this.value;\n      items.forEach((item) => this.selection.select(item));\n    }\n\n    if (!opts || opts.emitEvent !== false) {\n      this.selectionChanges.emit(this.selection.selected);\n    }\n  }\n\n  async onItemClick(event: MouseEvent, item: T, opts?: { emitEvent?: boolean }) {\n    if (!item || event.defaultPrevented || !this.selectionChanges.observed) return;\n\n    // Multiple selection (if ctrl+click)\n    if (event.ctrlKey && this.options.allowMultipleSelection) {\n      this.selection.toggle(item);\n    } else {\n      // Unselect all\n\n      // Select the item (or reselect)\n      if (!this.selection.isSelected(item) || (this.options.allowMultipleSelection && this.selection.selected.length > 1)) {\n        this.selection.clear();\n        this.selection.select(item);\n      }\n      // Unselect all\n      else {\n        this.selection.clear();\n      }\n    }\n\n    if (!opts || opts.emitEvent !== false) {\n      this.selectionChanges.emit(this.selection.selected);\n    }\n  }\n\n  async onItemButtonClick(button: ItemButton, event: MouseEvent, item: T, index: number) {\n    if (button.click) button.click(event, item, index);\n    await this.onItemClick(event, item);\n  }\n\n  hasSelection(): boolean {\n    return this.selection.hasValue();\n  }\n\n  onNewClick(event) {\n    this.onNewItem.emit(event);\n  }\n\n  add(value: T, opts?: { emitEvent?: boolean }) {\n    const done = this.helper.add(value, { emitEvent: true });\n    if (done) {\n      if (!this.options.allowMultipleSelection) {\n        this.selection.clear();\n      }\n      this.selection.toggle(value);\n      this.markForCheck();\n\n      if (!opts || opts.emitEvent !== false) {\n        this.selectionChanges.emit(this.selection.selected);\n      }\n    }\n  }\n\n  removeAt(index: number) {\n    const item = this.helper.at(index).value;\n    if (this.selection.isSelected(item)) {\n      this.selection.deselect(item);\n    }\n    this.helper.removeAt(index);\n  }\n\n  displayWith(value: T): string {\n    return this.displayWithFn ? this.displayWithFn(value) : (value as any);\n  }\n\n  /* -- protected methods -- */\n\n  protected createControl(data?: any): AbstractControl {\n    return this.formBuilder.control(data || null, Validators.required);\n  }\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n}\n","<ng-container *ngIf=\"!loading; else listSkeleton\">\n  <!-- List -->\n  <ion-list class=\"ion-no-padding\">\n    <ng-container *ngFor=\"let itemControl of itemControls; index as i; last as last\">\n      <ion-item\n        *ngIf=\"itemControl.value; let item\"\n        [class.disabled]=\"disabled\"\n        tappable\n        (click)=\"onItemClick($event, item)\"\n        [color]=\"selection.isSelected(item) ? 'secondary100' : undefined\"\n        [button]=\"selectionChanges.observers | isNotEmptyArray\"\n      >\n        <ion-label>{{ displayWith(item) }}</ion-label>\n\n        <!-- buttons -->\n        <ion-buttons slot=\"end\" *ngIf=\"enabled\" class=\"action-buttons\">\n          <ion-button fill=\"clear\" (click)=\"removeAt(i)\">\n            <ion-icon slot=\"icon-only\" name=\"trash\"></ion-icon>\n          </ion-button>\n\n          <ion-button\n            *ngFor=\"let button of options.buttons\"\n            fill=\"clear\"\n            [color]=\"button.color\"\n            [class.cdk-visually-hidden]=\"button.disabled | async\"\n            (click)=\"onItemButtonClick(button, $event, item, i)\"\n            [title]=\"button.title || '' | translate\"\n          >\n            <ion-icon slot=\"icon-only\" [name]=\"button.icon\"></ion-icon>\n          </ion-button>\n        </ion-buttons>\n      </ion-item>\n    </ng-container>\n  </ion-list>\n\n  <!-- Add button -->\n  <ion-button\n    color=\"tertiary\"\n    fill=\"clear\"\n    *ngIf=\"enabled && onNewItem.observed; else emptyText\"\n    [title]=\"'COMMON.BTN_ADD' | translate\"\n    (click)=\"onNewClick($event)\"\n  >\n    <ion-icon slot=\"start\" name=\"add\"></ion-icon>\n    <ion-label translate>COMMON.BTN_ADD</ion-label>\n  </ion-button>\n\n  <!-- Empty (if readonly) -->\n  <ng-template #emptyText>\n    <ion-text *ngIf=\"!length\" color=\"medium\"><i translate>COMMON.EMPTY_OPTION</i></ion-text>\n  </ng-template>\n</ng-container>\n\n<ng-template #listSkeleton>\n  <ion-list>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n    <ng-container *ngTemplateOutlet=\"itemSkeleton\"></ng-container>\n  </ion-list>\n</ng-template>\n\n<ng-template #itemSkeleton>\n  <ion-item>\n    <ion-label>\n      <ion-skeleton-text animated style=\"width: 60%\"></ion-skeleton-text>\n    </ion-label>\n  </ion-item>\n</ng-template>\n"]}

package/esm2022/src/app/core/form/list/list.module.mjs

@@ -0,0 +1,31 @@
+import { NgModule } from '@angular/core';
+import { SharedModule } from '../../../shared/shared.module';
+import { AppListForm } from './list.form';
+import { TranslateModule } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class AppListFormModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppListFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AppListFormModule, declarations: [
+            // Other components
+            AppListForm], imports: [SharedModule, i1.TranslateModule], exports: [TranslateModule,
+            // Components
+            AppListForm] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppListFormModule, imports: [SharedModule, TranslateModule.forChild(), TranslateModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppListFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [SharedModule, TranslateModule.forChild()],
+                    declarations: [
+                        // Other components
+                        AppListForm,
+                    ],
+                    exports: [
+                        TranslateModule,
+                        // Components
+                        AppListForm,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2NvcmUvZm9ybS9saXN0L2xpc3QubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQzdELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDMUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDOzs7QUFnQnRELE1BQU0sT0FBTyxpQkFBaUI7d0dBQWpCLGlCQUFpQjt5R0FBakIsaUJBQWlCO1lBVjFCLG1CQUFtQjtZQUNuQixXQUFXLGFBSkgsWUFBWSxpQ0FPcEIsZUFBZTtZQUVmLGFBQWE7WUFDYixXQUFXO3lHQUdGLGlCQUFpQixZQWJsQixZQUFZLEVBQUUsZUFBZSxDQUFDLFFBQVEsRUFBRSxFQU9oRCxlQUFlOzs0RkFNTixpQkFBaUI7a0JBZDdCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGVBQWUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztvQkFFbkQsWUFBWSxFQUFFO3dCQUNaLG1CQUFtQjt3QkFDbkIsV0FBVztxQkFDWjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsZUFBZTt3QkFFZixhQUFhO3dCQUNiLFdBQVc7cUJBQ1o7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU2hhcmVkTW9kdWxlIH0gZnJvbSAnLi4vLi4vLi4vc2hhcmVkL3NoYXJlZC5tb2R1bGUnO1xuaW1wb3J0IHsgQXBwTGlzdEZvcm0gfSBmcm9tICcuL2xpc3QuZm9ybSc7XG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1NoYXJlZE1vZHVsZSwgVHJhbnNsYXRlTW9kdWxlLmZvckNoaWxkKCldLFxuXG4gIGRlY2xhcmF0aW9uczogW1xuICAgIC8vIE90aGVyIGNvbXBvbmVudHNcbiAgICBBcHBMaXN0Rm9ybSxcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFRyYW5zbGF0ZU1vZHVsZSxcblxuICAgIC8vIENvbXBvbmVudHNcbiAgICBBcHBMaXN0Rm9ybSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgQXBwTGlzdEZvcm1Nb2R1bGUge31cbiJdfQ==