@sumaris-net/ngx-components 18.0.0-rc1 → 18.0.1-0.alpha1

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

@@ -1,60 +1,292 @@
-import { isNilOrBlank, isNotNil } from '../../../shared/functions';
+import { getPropertyByPath, isNil, isNilOrBlank, isNotNil, isNotNilOrBlank, isPromise, toBoolean, toNumber } from '../../../shared/functions';
 export class AppPropertiesUtils {
     /**
-     * Converts an array of Property objects to an object map.
+     * Converts an array of `Property` objects into a `PropertiesMap` object.
      *
-     * @param {Property[]} [sources] - The array of Property objects to convert.
-     * @param {Object} [opts] - Options for the conversion.
-     * @param {boolean} [opts.omitNilOrBlank] - If set to true, properties with nil or blank values will be omitted from the resulting object.
-     * @return {PropertiesMap} The resulting object map where keys are property keys and values are property values.
+     * @param {Property[]} [sources] - An optional array of properties to be converted.
+     * @param {FormFieldDefinition[]} [definitions] - An optional array of form field definitions to help with the conversion.
+     * @param {Object} [opts] - Optional configurations.
+     * @param {boolean} [opts.omitNilOrBlank] - If true, properties with nil or blank values will be omitted. Defaults to true.
+     * @return {PropertyMap} - The resulting `PropertiesMap` object.
      */
-    static arrayAsObject(sources, opts) {
+    static arrayAsObject(sources, definitions, opts) {
         return ((sources || [])
             // Serialize each item
-            .map(AppPropertyUtils.asObject)
+            .map((source) => {
+            if (!source)
+                return undefined;
+            const key = AppPropertyUtils.getPropertyKey(source);
+            if (!key)
+                return undefined;
+            const def = definitions?.find((d) => d.key === key);
+            return AppPropertyUtils.asObject(source, def);
+        })
             // Fill a JSON object
             .reduce((res, item) => {
-            if (isNilOrBlank(item.key))
+            if (isNilOrBlank(item?.key))
                 return res;
-            if (isNilOrBlank(item.value) && opts?.omitNilOrBlank !== false)
+            // Skip if nil or blank value
+            if (opts?.omitNilOrBlank !== false && isNilOrBlank(item.value))
                 return res;
             res[item.key] = item.value;
             return res;
         }, {}));
     }
     /**
-     * Converts an object into an array of properties.
+     * Generates an array of properties from the given object, optionally applying definitions to the properties.
      *
-     * @param {PropertiesMap} [source] - The source object containing properties to convert.
-     * @return {Property[]} An array of properties derived from the source object.
+     * @param {PropertyMap} [sources] - The source object from which properties are to be extracted.
+     * @param {FormFieldDefinition[]} [definitions] - An optional array of definitions to be applied to the extracted properties.
+     * @param opts
+     * @return {Property[] | Promise<Property[]>} An array of properties generated from the source object, or a promise resolving to that array.
      */
-    static arrayFromObject(source) {
-        if (Array.isArray(source))
-            return source; // Already an array
-        return Object.getOwnPropertyNames(source || {}).map((key) => ({
-            key,
-            value: source[key],
-        }));
+    static arrayFromObject(sources, definitions, opts) {
+        // DEBUG
+        //console.debug(`[properties-utils] Convert property map into array of Property...`);
+        let targets = Array.isArray(sources)
+            ? sources.slice()
+            : Object.getOwnPropertyNames(sources || {}).map((key) => ({
+                key,
+                value: sources[key],
+            }));
+        const jobs = [];
+        if (!!definitions) {
+            targets = targets
+                .map((target) => {
+                // Find definition
+                const def = definitions.find((def) => def.key === target.key);
+                // Exclude no definition (if expected by user options)
+                if (!def && opts?.keepOrphan === false)
+                    return null;
+                // Deserialize from string
+                let propertyOrPromise = AppPropertyUtils.fromObject(target, def);
+                if (isPromise(propertyOrPromise)) {
+                    jobs.push(propertyOrPromise.then((property) => (target.value = property.value)));
+                }
+                else {
+                    // Update the target value
+                    target.value = propertyOrPromise.value;
+                }
+                return target;
+            })
+                // Clean orphan
+                .filter(isNotNil);
+            // Return as promise, when need
+            if (jobs.length)
+                return Promise.all(jobs).then(() => targets);
+        }
+        return targets;
     }
 }
 export class AppPropertyUtils {
-    static asObject(source) {
+    static key(key) {
+        return key?.key ?? key;
+    }
+    static getPropertyKey(source) {
+        if (!source)
+            return undefined;
+        return source.key?.key ?? source.key;
+    }
+    /**
+     * Converts the given source to an object that contains a key-value pair.
+     *
+     * @param {Property<any> | any} source - The source property or any value to be converted.
+     * @param {FormFieldDefinition} [def] - The form field definition used for serialization.
+     * @param {Object} [opts] - Additional options for serialization.
+     * @param {string} [opts.defaultSerializeAttribute='id'] - The attribute to be used for default serialization.
+     * @return {{ key: string, value: string } | undefined} An object containing the serialized key-value pair, or undefined if the source is not provided.
+     */
+    static asObject(source, def, opts) {
         if (!source)
             return undefined;
         // Serialize key (WARNING: can be an object, when using autocomplete field to edit a key - see AppPropertiesForm)
-        const key = source.key?.key ?? source.key;
-        // Serialize the value
-        let value = source.value;
-        if (Array.isArray(value)) {
-            value = value
-                .map((v) => v?.id ?? v)
-                .filter(isNotNil)
-                .join(',');
+        const key = AppPropertyUtils.getPropertyKey(source);
+        // Prepare a deserialize function
+        let serializeFn = def?.serialize;
+        if (!serializeFn) {
+            switch (def?.type || 'other') {
+                case 'enum':
+                case 'enums':
+                    serializeFn = AppPropertyUtils.key;
+                    break;
+                case 'entity':
+                case 'entities':
+                    const serializeAttribute = def?.serializeAttribute ?? opts?.defaultSerializeAttribute ?? 'id';
+                    serializeFn =
+                        def?.serialize ||
+                            ((value) => {
+                                const serializeValue = getPropertyByPath(value, serializeAttribute, value /*default value*/);
+                                if (isNil(serializeValue))
+                                    return serializeValue;
+                                return serializeValue.toString();
+                            });
+                    break;
+                default:
+                    serializeFn = AppPropertyUtils.toString;
+            }
+        }
+        let valueStr;
+        // Value is an array
+        if (Array.isArray(source.value)) {
+            valueStr = source.value.map(serializeFn).filter(isNotNilOrBlank).join(',');
+        }
+        // Any other case
+        else {
+            valueStr = serializeFn(source.value);
+        }
+        return { key, value: valueStr };
+    }
+    static fromObject(source, def, opts) {
+        if (!source?.key || isNil(source.value) || !def)
+            return source; // Skip if no key
+        // Clone the source
+        const target = { key: source.key, value: source.value };
+        const jobs = [];
+        // Resolve value
+        switch (def.type) {
+            case 'boolean':
+                target.value = toBoolean(source.value, toBoolean(def.defaultValue));
+                break;
+            case 'integer':
+            case 'double':
+                target.value = toNumber(source.value, toNumber(def.defaultValue));
+                break;
+            case 'enum':
+                const valueKey = AppPropertyUtils.key(target.value);
+                if (isNotNilOrBlank(valueKey)) {
+                    const enumValue = def.values?.find((defValue) => defValue && valueKey === (defValue['key'] || defValue)) ?? null;
+                    target.value = enumValue?.['key'] ?? enumValue ?? null;
+                }
+                else {
+                    target.value = null;
+                }
+                break;
+            case 'enums':
+                const valueKeys = Array.isArray(source.value)
+                    ? source.value.map(AppPropertyUtils.key) // Copy
+                    : typeof source.value === 'string'
+                        ? source.value.trim().split(/,+/)
+                        : [AppPropertyUtils.key(source.value)];
+                target.value = valueKeys
+                    .filter(isNotNil)
+                    .map((key) => def.values?.find((defValue) => defValue && key === (defValue['key'] || defValue)) || { key, value: '?' });
+                break;
+            case 'entity':
+                // Deserialize entity (e.g. load entity from the id)
+                const valueOrPromise = AppPropertyUtils.resolveEntity(target.value, def, opts);
+                if (isPromise(valueOrPromise)) {
+                    jobs.push(valueOrPromise.then((value) => {
+                        target.value = value;
+                    }));
+                }
+                else {
+                    target.value = valueOrPromise;
+                }
+                break;
+            case 'entities':
+                // Convert value to array
+                target.value = Array.isArray(source.value)
+                    ? source.value.slice() // Copy
+                    : typeof source.value === 'string'
+                        ? source.value
+                            .split(',')
+                            .map((v) => v.trim())
+                            .filter(isNotNilOrBlank)
+                        : [];
+                // Deserialize each sub-value
+                let index = 0;
+                for (let subValue of target.value) {
+                    // Deserialize sub-value
+                    const subValueOrPromise = AppPropertyUtils.resolveEntity(subValue, def, opts);
+                    // Add promise to jobs
+                    if (isPromise(subValueOrPromise)) {
+                        const finalIndex = index;
+                        jobs.push(subValueOrPromise.then((value) => {
+                            // Update sub value
+                            target.value[finalIndex] = value;
+                        }));
+                    }
+                    else {
+                        // Update sub value
+                        target.value[index] = subValueOrPromise;
+                    }
+                    index++;
+                }
+        }
+        // /!\ Return as promise only if need (let function sync when possible)
+        if (jobs.length)
+            return Promise.all(jobs).then(() => target);
+        return target;
+    }
+    static resolveEntity(value, def, opts) {
+        // Use deserialize function, if any
+        if (def.deserialize) {
+            return def.deserialize(value);
+        }
+        // Or try using suggest function
+        return this.resolveEntityBySuggest(value, def, opts);
+    }
+    static async resolveEntityBySuggest(value, def, opts) {
+        const serializeAttribute = def.serializeAttribute ?? opts?.defaultSerializeAttribute ?? 'id';
+        if (typeof value === 'object' && isNotNil(value[serializeAttribute])) {
+            return value; // Already resolve
+        }
+        const suggestFn = def.autocomplete?.suggestFn || opts?.defaultSuggestFn;
+        if (!suggestFn) {
+            console.warn(`Missing 'deserialize' or 'autocomplete.suggestFn' in the field definition '${def.key}'. Cannot deserialize value: ${JSON.stringify(value)}`);
+            return value; // Skip
+        }
+        let searchValue = value;
+        const filter = { ...def.autocomplete?.filter }; // Cope filter
+        if (serializeAttribute === 'id' || serializeAttribute === 'label') {
+            filter[serializeAttribute] = serializeAttribute === 'id' ? +value : value;
+            searchValue = '*';
+            // DEBUG
+            //console.debug(`[properties-utils] Resolving entity where id=${value}...`);
         }
         else {
-            value = value?.id ?? value;
+            filter.searchAttribute = serializeAttribute;
+            // DEBUG
+            //console.debug(`[properties-utils] Resolving entity where ${serializeAttribute}=${searchValue}...`);
+        }
+        try {
+            // Fetch entity, using the suggest function
+            const res = await suggestFn(searchValue, filter, serializeAttribute, 'asc', {
+                withTotal: false,
+                offset: 0,
+                size: 1,
+                ...opts?.defaultSuggestOptions,
+            });
+            // Get result array
+            const data = Array.isArray(res) ? res : res.data;
+            if (data?.length > 0) {
+                if (data?.length > 1) {
+                    console.warn(`[properties-utils] More than one entity found, for option ${def.key}=${value}! Please check option's definition and the 'autocomplete.suggestFn' function`, data);
+                }
+                // DEBUG
+                //console.debug(`[properties-utils] ${data.length} entities found: `, data);
+                // Ok, we find it => stop here
+                return data[0];
+            }
+            // Warn, but continue
+            console.warn(`[properties-utils] Unable to resolve entity for option: ${def.key}=${value}. Please check option's definition and the 'autocomplete.suggestFn' function`);
         }
-        return { key, value };
+        catch (err) {
+            console.error(`[properties-utils] Cannot resolve entity for option: ${def.key}=${value}`, err);
+            // Continue
+        }
+        // Create the missing result
+        const unresolvedEntity = {
+            [serializeAttribute]: value,
+        };
+        // Fill attributes with '??'
+        def.autocomplete?.attributes?.forEach((key) => {
+            unresolvedEntity[key] = unresolvedEntity[key] ?? '';
+        });
+        return unresolvedEntity;
+    }
+    static toString(value) {
+        return value?.toString();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"properties.utils.js","sourceRoot":"","sources":["../../../../../../../src/app/core/form/properties/properties.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Property, PropertyMap } from '../../../shared/types';\nimport { getPropertyByPath, isNil, isNilOrBlank, isNotNil, isNotNilOrBlank, isPromise, toBoolean, toNumber } from '../../../shared/functions';\nimport { FormFieldDefinition } from '../../../shared/form/field.model';\nimport { EntitiesServiceLoadOptions, SuggestFn } from '../../../shared/services/entity-service.class';\n\nexport class AppPropertiesUtils {\n  /**\n   * Converts an array of `Property` objects into a `PropertiesMap` object.\n   *\n   * @param {Property[]} [sources] - An optional array of properties to be converted.\n   * @param {FormFieldDefinition[]} [definitions] - An optional array of form field definitions to help with the conversion.\n   * @param {Object} [opts] - Optional configurations.\n   * @param {boolean} [opts.omitNilOrBlank] - If true, properties with nil or blank values will be omitted. Defaults to true.\n   * @return {PropertyMap} - The resulting `PropertiesMap` object.\n   */\n  static arrayAsObject<T = any>(sources?: Property<T>[], definitions?: FormFieldDefinition[], opts?: { omitNilOrBlank: boolean }): PropertyMap {\n    return (\n      (sources || [])\n        // Serialize each item\n        .map((source) => {\n          if (!source) return undefined;\n          const key = AppPropertyUtils.getPropertyKey(source);\n          if (!key) return undefined;\n          const def = definitions?.find((d) => d.key === key);\n          return AppPropertyUtils.asObject(source, def);\n        })\n        // Fill a JSON object\n        .reduce(\n          (res, item) => {\n            if (isNilOrBlank(item?.key)) return res;\n            // Skip if nil or blank value\n            if (opts?.omitNilOrBlank !== false && isNilOrBlank(item.value)) return res;\n            res[item.key] = item.value;\n            return res;\n          },\n          <PropertyMap>{}\n        )\n    );\n  }\n\n  /**\n   * Generates an array of properties from the given object, optionally applying definitions to the properties.\n   *\n   * @param {PropertyMap} [sources] - The source object from which properties are to be extracted.\n   * @param {FormFieldDefinition[]} [definitions] - An optional array of definitions to be applied to the extracted properties.\n   * @param opts\n   * @return {Property[] | Promise<Property[]>} An array of properties generated from the source object, or a promise resolving to that array.\n   */\n  static arrayFromObject<T>(\n    sources?: PropertyMap | Property<T>[],\n    definitions?: FormFieldDefinition[],\n    opts?: {\n      keepOrphan?: boolean; // true by default\n    }\n  ): Property<T>[] | Promise<Property<T>[]> {\n    // DEBUG\n    //console.debug(`[properties-utils] Convert property map into array of Property...`);\n\n    let targets = Array.isArray(sources)\n      ? sources.slice()\n      : Object.getOwnPropertyNames(sources || {}).map(\n          (key) =>\n            <Property<any>>{\n              key,\n              value: sources[key],\n            }\n        );\n    const jobs = [];\n\n    if (!!definitions) {\n      targets = targets\n        .map((target: Property<any>) => {\n          // Find definition\n          const def = definitions.find((def) => def.key === target.key);\n\n          // Exclude no definition (if expected by user options)\n          if (!def && opts?.keepOrphan === false) return null;\n\n          // Deserialize from string\n          let propertyOrPromise = AppPropertyUtils.fromObject(target, def);\n          if (isPromise(propertyOrPromise)) {\n            jobs.push(propertyOrPromise.then((property) => (target.value = property.value)));\n          } else {\n            // Update the target value\n            target.value = propertyOrPromise.value;\n          }\n\n          return target;\n        })\n        // Clean orphan\n        .filter(isNotNil);\n\n      // Return as promise, when need\n      if (jobs.length) return Promise.all(jobs).then(() => targets as Property<T>[]);\n    }\n\n    return targets as Property<T>[];\n  }\n}\n\nexport class AppPropertyUtils {\n  static key(key: any): string {\n    return key?.key ?? key;\n  }\n\n  static getPropertyKey(source: Property | any): string {\n    if (!source) return undefined;\n    return (source.key as any)?.key ?? source.key;\n  }\n\n  /**\n   * Converts the given source to an object that contains a key-value pair.\n   *\n   * @param {Property<any> | any} source - The source property or any value to be converted.\n   * @param {FormFieldDefinition} [def] - The form field definition used for serialization.\n   * @param {Object} [opts] - Additional options for serialization.\n   * @param {string} [opts.defaultSerializeAttribute='id'] - The attribute to be used for default serialization.\n   * @return {{ key: string, value: string } | undefined} An object containing the serialized key-value pair, or undefined if the source is not provided.\n   */\n  static asObject(\n    source: Property<any> | any,\n    def?: FormFieldDefinition,\n    opts?: {\n      defaultSerializeAttribute?: string;\n    }\n  ): { key: string; value: string } | undefined {\n    if (!source) return undefined;\n    // Serialize key (WARNING: can be an object, when using autocomplete field to edit a key - see AppPropertiesForm)\n    const key = AppPropertyUtils.getPropertyKey(source);\n\n    // Prepare a deserialize function\n    let serializeFn = def?.serialize;\n    if (!serializeFn) {\n      switch (def?.type || 'other') {\n        case 'enum':\n        case 'enums':\n          serializeFn = AppPropertyUtils.key;\n          break;\n        case 'entity':\n        case 'entities':\n          const serializeAttribute = def?.serializeAttribute ?? opts?.defaultSerializeAttribute ?? 'id';\n          serializeFn =\n            def?.serialize ||\n            ((value) => {\n              const serializeValue = getPropertyByPath(value, serializeAttribute, value /*default value*/);\n              if (isNil(serializeValue)) return serializeValue;\n              return serializeValue.toString();\n            });\n          break;\n        default:\n          serializeFn = AppPropertyUtils.toString;\n      }\n    }\n\n    let valueStr: string;\n\n    // Value is an array\n    if (Array.isArray(source.value)) {\n      valueStr = source.value.map(serializeFn).filter(isNotNilOrBlank).join(',');\n    }\n    // Any other case\n    else {\n      valueStr = serializeFn(source.value);\n    }\n    return { key, value: valueStr };\n  }\n\n  static fromObject<T = string>(\n    source: Property | Property<T>,\n    def: FormFieldDefinition,\n    opts?: {\n      defaultSuggestFn: SuggestFn<any, any>;\n      defaultSuggestOptions?: EntitiesServiceLoadOptions;\n      defaultSerializeAttribute?: string;\n    }\n  ): Property<T> | Promise<Property<T>> {\n    if (!source?.key || isNil(source.value) || !def) return source as Property<T>; // Skip if no key\n\n    // Clone the source\n    const target: Property<any> = { key: source.key, value: source.value };\n\n    const jobs: Promise<any>[] = [];\n    // Resolve value\n    switch (def.type) {\n      case 'boolean':\n        target.value = toBoolean(source.value as any, toBoolean(def.defaultValue));\n        break;\n      case 'integer':\n      case 'double':\n        target.value = toNumber(source.value as any, toNumber(def.defaultValue));\n        break;\n      case 'enum':\n        const valueKey = AppPropertyUtils.key(target.value);\n        if (isNotNilOrBlank(valueKey)) {\n          const enumValue = (def.values as (string | Property)[])?.find((defValue) => defValue && valueKey === (defValue['key'] || defValue)) ?? null;\n          target.value = enumValue?.['key'] ?? enumValue ?? null;\n        } else {\n          target.value = null;\n        }\n        break;\n      case 'enums':\n        const valueKeys = Array.isArray(source.value)\n          ? source.value.map(AppPropertyUtils.key) // Copy\n          : typeof source.value === 'string'\n            ? source.value.trim().split(/,+/)\n            : [AppPropertyUtils.key(source.value)];\n        target.value = valueKeys\n          .filter(isNotNil)\n          .map(\n            (key: string) =>\n              (def.values as (string | Property)[])?.find((defValue) => defValue && key === (defValue['key'] || defValue)) || { key, value: '?' }\n          );\n        break;\n      case 'entity':\n        // Deserialize entity (e.g. load entity from the id)\n        const valueOrPromise = AppPropertyUtils.resolveEntity(target.value, def, opts);\n        if (isPromise(valueOrPromise)) {\n          jobs.push(\n            valueOrPromise.then((value) => {\n              target.value = value;\n            })\n          );\n        } else {\n          target.value = valueOrPromise as any;\n        }\n        break;\n      case 'entities':\n        // Convert value to array\n        target.value = Array.isArray(source.value)\n          ? source.value.slice() // Copy\n          : typeof source.value === 'string'\n            ? source.value\n                .split(',')\n                .map((v) => v.trim())\n                .filter(isNotNilOrBlank)\n            : [];\n\n        // Deserialize each sub-value\n        let index = 0;\n        for (let subValue of target.value) {\n          // Deserialize sub-value\n          const subValueOrPromise = AppPropertyUtils.resolveEntity(subValue, def, opts);\n\n          // Add promise to jobs\n          if (isPromise(subValueOrPromise)) {\n            const finalIndex = index;\n            jobs.push(\n              subValueOrPromise.then((value) => {\n                // Update sub value\n                target.value[finalIndex] = value;\n              })\n            );\n          } else {\n            // Update sub value\n            target.value[index] = subValueOrPromise as any;\n          }\n          index++;\n        }\n    }\n\n    // /!\\ Return as promise only if need (let function sync when possible)\n    if (jobs.length) return Promise.all(jobs).then(() => target);\n\n    return target;\n  }\n\n  private static resolveEntity(\n    value: any,\n    def: FormFieldDefinition,\n    opts?: {\n      defaultSuggestFn: SuggestFn<any, any>;\n      defaultSuggestOptions?: EntitiesServiceLoadOptions;\n      defaultSerializeAttribute?: string;\n    }\n  ): any | Promise<any> {\n    // Use deserialize function, if any\n    if (def.deserialize) {\n      return def.deserialize(value);\n    }\n\n    // Or try using suggest function\n    return this.resolveEntityBySuggest(value, def, opts);\n  }\n\n  private static async resolveEntityBySuggest(\n    value: any,\n    def: FormFieldDefinition,\n    opts?: {\n      defaultSuggestFn: SuggestFn<any, any>;\n      defaultSuggestOptions?: EntitiesServiceLoadOptions;\n      defaultSerializeAttribute?: string;\n    }\n  ): Promise<any> {\n    const serializeAttribute = def.serializeAttribute ?? opts?.defaultSerializeAttribute ?? 'id';\n    if (typeof value === 'object' && isNotNil(value[serializeAttribute])) {\n      return value; // Already resolve\n    }\n\n    const suggestFn: SuggestFn<any, any> = def.autocomplete?.suggestFn || opts?.defaultSuggestFn;\n    if (!suggestFn) {\n      console.warn(\n        `Missing 'deserialize' or 'autocomplete.suggestFn' in the field definition '${def.key}'. Cannot deserialize value: ${JSON.stringify(value)}`\n      );\n      return value; // Skip\n    }\n    let searchValue = value;\n    const filter = { ...def.autocomplete?.filter }; // Cope filter\n    if (serializeAttribute === 'id' || serializeAttribute === 'label') {\n      filter[serializeAttribute] = serializeAttribute === 'id' ? +value : value;\n      searchValue = '*';\n      // DEBUG\n      //console.debug(`[properties-utils] Resolving entity where id=${value}...`);\n    } else {\n      filter.searchAttribute = serializeAttribute;\n      // DEBUG\n      //console.debug(`[properties-utils] Resolving entity where ${serializeAttribute}=${searchValue}...`);\n    }\n\n    try {\n      // Fetch entity, using the suggest function\n      const res = await suggestFn(searchValue, filter, serializeAttribute, 'asc', {\n        withTotal: false,\n        offset: 0,\n        size: 1,\n        ...opts?.defaultSuggestOptions,\n      });\n\n      // Get result array\n      const data = Array.isArray(res) ? res : res.data;\n\n      if (data?.length > 0) {\n        if (data?.length > 1) {\n          console.warn(\n            `[properties-utils] More than one entity found, for option ${def.key}=${value}! Please check option's definition and the 'autocomplete.suggestFn' function`,\n            data\n          );\n        }\n\n        // DEBUG\n        //console.debug(`[properties-utils] ${data.length} entities found: `, data);\n\n        // Ok, we find it => stop here\n        return data[0];\n      }\n\n      // Warn, but continue\n      console.warn(\n        `[properties-utils] Unable to resolve entity for option: ${def.key}=${value}. Please check option's definition and the 'autocomplete.suggestFn' function`\n      );\n    } catch (err) {\n      console.error(`[properties-utils] Cannot resolve entity for option: ${def.key}=${value}`, err);\n      // Continue\n    }\n\n    // Create the missing result\n    const unresolvedEntity = <any>{\n      [serializeAttribute]: value,\n    };\n\n    // Fill attributes with '??'\n    def.autocomplete?.attributes?.forEach((key) => {\n      unresolvedEntity[key] = unresolvedEntity[key] ?? '';\n    });\n\n    return unresolvedEntity;\n  }\n\n  private static toString(value?: any): string {\n    return value?.toString();\n  }\n}\n"]}

package/esm2022/src/app/core/form/properties/property.validator.mjs

@@ -1,7 +1,9 @@
 import { Injectable } from '@angular/core';
 import { Validators } from '@angular/forms';
 import { AppValidatorService } from '../../services/validator/base.validator.class';
-import { isNil } from '../../../shared/functions';
+import { isNil, isNotEmptyArray } from '../../../shared/functions';
+import { AppFormArray } from '../array/form-array';
+import { AppPropertiesUtils } from './properties.utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/forms";
 export class PropertyValidator extends AppValidatorService {
@@ -10,14 +12,44 @@ export class PropertyValidator extends AppValidatorService {
         super(formBuilder, null);
         this.formBuilder = formBuilder;
     }
+    getFormArray(data, opts) {
+        const fromArray = new AppFormArray((value) => this.getFormGroup(value, { valueMaxLength: 2000 }), (v1, v2) => this.equals(v1, v2), (value) => this.isEmpty(value), {
+            allowReuseControls: false,
+            allowEmptyArray: true,
+        });
+        // Set data, if any
+        if (data) {
+            const dataArrayOrPromise = AppPropertiesUtils.arrayFromObject(data, opts?.definitions);
+            if (Array.isArray(dataArrayOrPromise)) {
+                if (isNotEmptyArray(dataArrayOrPromise))
+                    fromArray.patchValue(dataArrayOrPromise);
+            }
+            else {
+                // If promise: wait and set after
+                dataArrayOrPromise
+                    .catch((err) => {
+                    console.error('[property-validator] Error during conversion from map to array conversion: ' + (err?.message || err), data, err);
+                    return null;
+                })
+                    .then((values) => {
+                    if (isNotEmptyArray(values))
+                        fromArray.patchValue(values);
+                    fromArray.updateValueAndValidity();
+                });
+                // Wait value to be set
+                fromArray.markAsPending();
+            }
+        }
+        return fromArray;
+    }
     getFormGroup(data, opts) {
         return this.formBuilder.group(this.getFormGroupConfig(data, opts));
     }
     getFormGroupConfig(data, opts) {
         return {
-            key: [(data && data.key) || null, Validators.compose([Validators.required, Validators.max(50)])],
+            key: [data?.key ?? null, Validators.compose([Validators.required, Validators.max(50)])],
             value: [
-                (data && data.value) || null,
+                data?.value ?? null,
                 opts?.valueMaxLength > 0 ? Validators.compose([Validators.required, Validators.max(opts.valueMaxLength)]) : Validators.required,
             ],
         };
@@ -35,4 +67,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i1.UntypedFormBuilder }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHkudmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9jb3JlL2Zvcm0vcHJvcGVydGllcy9wcm9wZXJ0eS52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQXdDLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRWxGLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQ3BGLE9BQU8sRUFBRSxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFbkUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDOzs7QUFheEQsTUFBTSxPQUFPLGlCQUFrQixTQUFRLG1CQUE2QjtJQUM1QztJQUF0QixZQUFzQixXQUErQjtRQUNuRCxLQUFLLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxDQUFDO1FBREwsZ0JBQVcsR0FBWCxXQUFXLENBQW9CO0lBRXJELENBQUM7SUFFRCxZQUFZLENBQUMsSUFBVSxFQUFFLElBQWlDO1FBQ3hELE1BQU0sU0FBUyxHQUFHLElBQUksWUFBWSxDQUNoQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsRUFBRSxjQUFjLEVBQUUsSUFBSSxFQUFFLENBQUMsRUFDN0QsQ0FBQyxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsRUFDL0IsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQzlCO1lBQ0Usa0JBQWtCLEVBQUUsS0FBSztZQUN6QixlQUFlLEVBQUUsSUFBSTtTQUN0QixDQUNGLENBQUM7UUFFRixtQkFBbUI7UUFDbkIsSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUNULE1BQU0sa0JBQWtCLEdBQUcsa0JBQWtCLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUM7WUFDdkYsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLEVBQUUsQ0FBQztnQkFDdEMsSUFBSSxlQUFlLENBQUMsa0JBQWtCLENBQUM7b0JBQUUsU0FBUyxDQUFDLFVBQVUsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1lBQ3BGLENBQUM7aUJBQU0sQ0FBQztnQkFDTixpQ0FBaUM7Z0JBQ2pDLGtCQUFrQjtxQkFDZixLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtvQkFDYixPQUFPLENBQUMsS0FBSyxDQUFDLDZFQUE2RSxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sSUFBSSxHQUFHLENBQUMsRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7b0JBQ2hJLE9BQU8sSUFBSSxDQUFDO2dCQUNkLENBQUMsQ0FBQztxQkFDRCxJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtvQkFDZixJQUFJLGVBQWUsQ0FBQyxNQUFNLENBQUM7d0JBQUUsU0FBUyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztvQkFDMUQsU0FBUyxDQUFDLHNCQUFzQixFQUFFLENBQUM7Z0JBQ3JDLENBQUMsQ0FBQyxDQUFDO2dCQUVMLHVCQUF1QjtnQkFDdkIsU0FBUyxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQzVCLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELFlBQVksQ0FBQyxJQUFlLEVBQUUsSUFBK0I7UUFDM0QsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDckUsQ0FBQztJQUVELGtCQUFrQixDQUFDLElBQWUsRUFBRSxJQUErQjtRQUNqRSxPQUFPO1lBQ0wsR0FBRyxFQUFFLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxJQUFJLEVBQUUsVUFBVSxDQUFDLE9BQU8sQ0FBQyxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDdkYsS0FBSyxFQUFFO2dCQUNMLElBQUksRUFBRSxLQUFLLElBQUksSUFBSTtnQkFDbkIsSUFBSSxFQUFFLGNBQWMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLFFBQVE7YUFDaEk7U0FDRixDQUFDO0lBQ0osQ0FBQztJQUVELE1BQU0sQ0FBQyxFQUFZLEVBQUUsRUFBWTtRQUMvQixPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxFQUFFLENBQUMsR0FBRyxLQUFLLEVBQUUsQ0FBQyxHQUFHLENBQUM7SUFDM0MsQ0FBQztJQUVELE9BQU8sQ0FBQyxHQUFhO1FBQ25CLE9BQU8sS0FBSyxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsSUFBSSxLQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdDLENBQUM7dUdBNURVLGlCQUFpQjsyR0FBakIsaUJBQWlCLGNBREosTUFBTTs7MkZBQ25CLGlCQUFpQjtrQkFEN0IsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBVbnR5cGVkRm9ybUJ1aWxkZXIsIFVudHlwZWRGb3JtR3JvdXAsIFZhbGlkYXRvcnMgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBQcm9wZXJ0eSB9IGZyb20gJy4uLy4uLy4uL3NoYXJlZC90eXBlcyc7XG5pbXBvcnQgeyBBcHBWYWxpZGF0b3JTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvdmFsaWRhdG9yL2Jhc2UudmFsaWRhdG9yLmNsYXNzJztcbmltcG9ydCB7IGlzTmlsLCBpc05vdEVtcHR5QXJyYXkgfSBmcm9tICcuLi8uLi8uLi9zaGFyZWQvZnVuY3Rpb25zJztcbmltcG9ydCB7IEZvcm1GaWVsZERlZmluaXRpb24gfSBmcm9tICcuLi8uLi8uLi9zaGFyZWQvZm9ybS9maWVsZC5tb2RlbCc7XG5pbXBvcnQgeyBBcHBGb3JtQXJyYXkgfSBmcm9tICcuLi9hcnJheS9mb3JtLWFycmF5JztcbmltcG9ydCB7IEFwcFByb3BlcnRpZXNVdGlscyB9IGZyb20gJy4vcHJvcGVydGllcy51dGlscyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvcGVydHlWYWxpZGF0b3JPcHRpb25zIHtcbiAgZGVmaW5pdGlvbj86IEZvcm1GaWVsZERlZmluaXRpb247XG4gIHZhbHVlTWF4TGVuZ3RoPzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFByb3BlcnRpZXNWYWxpZGF0b3JPcHRpb25zIHtcbiAgZGVmaW5pdGlvbnM/OiBGb3JtRmllbGREZWZpbml0aW9uW107XG4gIHZhbHVlTWF4TGVuZ3RoPzogbnVtYmVyO1xufVxuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFByb3BlcnR5VmFsaWRhdG9yIGV4dGVuZHMgQXBwVmFsaWRhdG9yU2VydmljZTxQcm9wZXJ0eT4ge1xuICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgZm9ybUJ1aWxkZXI6IFVudHlwZWRGb3JtQnVpbGRlcikge1xuICAgIHN1cGVyKGZvcm1CdWlsZGVyLCBudWxsKTtcbiAgfVxuXG4gIGdldEZvcm1BcnJheShkYXRhPzogYW55LCBvcHRzPzogUHJvcGVydGllc1ZhbGlkYXRvck9wdGlvbnMpIHtcbiAgICBjb25zdCBmcm9tQXJyYXkgPSBuZXcgQXBwRm9ybUFycmF5PFByb3BlcnR5LCBVbnR5cGVkRm9ybUdyb3VwPihcbiAgICAgICh2YWx1ZSkgPT4gdGhpcy5nZXRGb3JtR3JvdXAodmFsdWUsIHsgdmFsdWVNYXhMZW5ndGg6IDIwMDAgfSksXG4gICAgICAodjEsIHYyKSA9PiB0aGlzLmVxdWFscyh2MSwgdjIpLFxuICAgICAgKHZhbHVlKSA9PiB0aGlzLmlzRW1wdHkodmFsdWUpLFxuICAgICAge1xuICAgICAgICBhbGxvd1JldXNlQ29udHJvbHM6IGZhbHNlLFxuICAgICAgICBhbGxvd0VtcHR5QXJyYXk6IHRydWUsXG4gICAgICB9XG4gICAgKTtcblxuICAgIC8vIFNldCBkYXRhLCBpZiBhbnlcbiAgICBpZiAoZGF0YSkge1xuICAgICAgY29uc3QgZGF0YUFycmF5T3JQcm9taXNlID0gQXBwUHJvcGVydGllc1V0aWxzLmFycmF5RnJvbU9iamVjdChkYXRhLCBvcHRzPy5kZWZpbml0aW9ucyk7XG4gICAgICBpZiAoQXJyYXkuaXNBcnJheShkYXRhQXJyYXlPclByb21pc2UpKSB7XG4gICAgICAgIGlmIChpc05vdEVtcHR5QXJyYXkoZGF0YUFycmF5T3JQcm9taXNlKSkgZnJvbUFycmF5LnBhdGNoVmFsdWUoZGF0YUFycmF5T3JQcm9taXNlKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIC8vIElmIHByb21pc2U6IHdhaXQgYW5kIHNldCBhZnRlclxuICAgICAgICBkYXRhQXJyYXlPclByb21pc2VcbiAgICAgICAgICAuY2F0Y2goKGVycikgPT4ge1xuICAgICAgICAgICAgY29uc29sZS5lcnJvcignW3Byb3BlcnR5LXZhbGlkYXRvcl0gRXJyb3IgZHVyaW5nIGNvbnZlcnNpb24gZnJvbSBtYXAgdG8gYXJyYXkgY29udmVyc2lvbjogJyArIChlcnI/Lm1lc3NhZ2UgfHwgZXJyKSwgZGF0YSwgZXJyKTtcbiAgICAgICAgICAgIHJldHVybiBudWxsO1xuICAgICAgICAgIH0pXG4gICAgICAgICAgLnRoZW4oKHZhbHVlcykgPT4ge1xuICAgICAgICAgICAgaWYgKGlzTm90RW1wdHlBcnJheSh2YWx1ZXMpKSBmcm9tQXJyYXkucGF0Y2hWYWx1ZSh2YWx1ZXMpO1xuICAgICAgICAgICAgZnJvbUFycmF5LnVwZGF0ZVZhbHVlQW5kVmFsaWRpdHkoKTtcbiAgICAgICAgICB9KTtcblxuICAgICAgICAvLyBXYWl0IHZhbHVlIHRvIGJlIHNldFxuICAgICAgICBmcm9tQXJyYXkubWFya0FzUGVuZGluZygpO1xuICAgICAgfVxuICAgIH1cbiAgICByZXR1cm4gZnJvbUFycmF5O1xuICB9XG5cbiAgZ2V0Rm9ybUdyb3VwKGRhdGE/OiBQcm9wZXJ0eSwgb3B0cz86IFByb3BlcnR5VmFsaWRhdG9yT3B0aW9ucyk6IFVudHlwZWRGb3JtR3JvdXAge1xuICAgIHJldHVybiB0aGlzLmZvcm1CdWlsZGVyLmdyb3VwKHRoaXMuZ2V0Rm9ybUdyb3VwQ29uZmlnKGRhdGEsIG9wdHMpKTtcbiAgfVxuXG4gIGdldEZvcm1Hcm91cENvbmZpZyhkYXRhPzogUHJvcGVydHksIG9wdHM/OiBQcm9wZXJ0eVZhbGlkYXRvck9wdGlvbnMpOiB7IFtwOiBzdHJpbmddOiBhbnkgfSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGtleTogW2RhdGE/LmtleSA/PyBudWxsLCBWYWxpZGF0b3JzLmNvbXBvc2UoW1ZhbGlkYXRvcnMucmVxdWlyZWQsIFZhbGlkYXRvcnMubWF4KDUwKV0pXSxcbiAgICAgIHZhbHVlOiBbXG4gICAgICAgIGRhdGE/LnZhbHVlID8/IG51bGwsXG4gICAgICAgIG9wdHM/LnZhbHVlTWF4TGVuZ3RoID4gMCA/IFZhbGlkYXRvcnMuY29tcG9zZShbVmFsaWRhdG9ycy5yZXF1aXJlZCwgVmFsaWRhdG9ycy5tYXgob3B0cy52YWx1ZU1heExlbmd0aCldKSA6IFZhbGlkYXRvcnMucmVxdWlyZWQsXG4gICAgICBdLFxuICAgIH07XG4gIH1cblxuICBlcXVhbHModjE6IFByb3BlcnR5LCB2MjogUHJvcGVydHkpOiBib29sZWFuIHtcbiAgICByZXR1cm4gKCF2MSAmJiAhdjIpIHx8IHYxLmtleSA9PT0gdjIua2V5O1xuICB9XG5cbiAgaXNFbXB0eShvYmo6IFByb3BlcnR5KTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIGlzTmlsKG9iaj8ua2V5KSB8fCBpc05pbChvYmoudmFsdWUpO1xuICB9XG59XG4iXX0=