@sumaris-net/ngx-components 18.0.1 → 18.0.2-alpha2

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

@@ -1,17 +1,24 @@
-import { isNilOrBlank, isNotNil } from '../../../shared/functions';
+import { isNil, isNilOrBlank, isNotEmptyArray, 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 {PropertiesMap} - 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.key(source);
+            const def = definitions?.find((d) => d.key === key);
+            return AppPropertyUtils.asObject(source, def);
+        })
             // Fill a JSON object
             .reduce((res, item) => {
             if (isNilOrBlank(item.key))
@@ -23,38 +30,194 @@ export class AppPropertiesUtils {
         }, {}));
     }
     /**
-     * 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 {PropertiesMap} [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.
+     * @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) {
+        const targets = Array.isArray(sources)
+            ? sources.slice()
+            : Object.getOwnPropertyNames(sources || {}).map((key) => ({
+                key,
+                value: sources[key],
+            }));
+        const jobs = [];
+        if (isNotEmptyArray(definitions)) {
+            for (let target of targets) {
+                // Find definition
+                const def = definitions.find((def) => def.key === target.key);
+                // 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 as promise, if need
+        if (jobs.length)
+            return Promise.all(jobs).then(() => targets);
+        return targets;
     }
 }
 export class AppPropertyUtils {
-    static asObject(source) {
+    static key(source) {
+        if (!source)
+            return undefined;
+        return source.key?.key ?? source.key;
+    }
+    static asObject(source, def) {
         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;
+        const key = AppPropertyUtils.key(source);
+        const joinAttribute = def?.autocomplete?.filter?.joinAttribute || 'id';
         // Serialize the value
         let value = source.value;
         if (Array.isArray(value)) {
             value = value
-                .map((v) => v?.id ?? v)
+                .map((v) => v?.[joinAttribute] ?? v)
                 .filter(isNotNil)
                 .join(',');
         }
         else {
             value = value?.id ?? value;
         }
-        return { key, value };
+        return { key, value: value?.toString() };
+    }
+    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 'enums':
+                const keys = (target.value || '').trim().split(/[|,]+/);
+                if (isNotEmptyArray(keys)) {
+                    const enumValues = keys.map((key) => def.values?.find((defValue) => defValue && key === (defValue['key'] || defValue)));
+                    target.value = enumValues || null;
+                }
+                else {
+                    target.value = null;
+                }
+                break;
+            case 'entity':
+                // Deserialize unique entity
+                const valueOrPromise = AppPropertyUtils.valueFromObject(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.valueFromObject(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 valueFromObject(value, def, opts) {
+        // Use deserialize function, if any
+        if (def.deserialize) {
+            return def.deserialize(value);
+        }
+        // Or try using suggest function
+        return this.resolveValueBySuggest(value, def, opts);
+    }
+    static async resolveValueBySuggest(value, def, opts) {
+        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
+        const joinAttribute = filter?.joinAttribute || 'id';
+        if (joinAttribute === 'id') {
+            filter.id = +value;
+            filter.offset = 0;
+            filter.size = 1;
+            searchValue = '*';
+            // DEBUG
+            console.debug(`[properties-utils] Resolving entity where id=${value}...`);
+        }
+        else {
+            filter.searchAttribute = joinAttribute;
+            // DEBUG
+            console.debug(`[properties-utils] Resolving entity where ${joinAttribute}=${searchValue}...`);
+        }
+        try {
+            // Fetch entity, using the suggest function
+            const res = await suggestFn(searchValue, filter, joinAttribute, 'asc', {
+                withTotal: false,
+                ...opts?.defaultSuggestOptions,
+            });
+            // Get result array
+            const data = Array.isArray(res) ? res : res.data;
+            console.debug(`[properties-utils] ${data.length} entities found: `, data);
+            // Ok, we find it => stop here
+            if (data?.length)
+                return data[0];
+        }
+        catch (err) {
+            console.error(`Cannot fetch entity from ${def.key}=${value}`, err);
+            // Continue
+        }
+        // Create the missing result
+        const unresolvedEntity = {
+            [joinAttribute]: value,
+        };
+        // Fill attributes with '??'
+        def.autocomplete?.attributes?.forEach((key) => {
+            unresolvedEntity[key] = unresolvedEntity[key] ?? '';
+        });
+        return unresolvedEntity;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydGllcy51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29yZS9mb3JtL3Byb3BlcnRpZXMvcHJvcGVydGllcy51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRW5FLE1BQU0sT0FBTyxrQkFBa0I7SUFDN0I7Ozs7Ozs7T0FPRztJQUNILE1BQU0sQ0FBQyxhQUFhLENBQUMsT0FBb0IsRUFBRSxJQUFrQztRQUMzRSxPQUFPLENBQ0wsQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDO1lBQ2Isc0JBQXNCO2FBQ3JCLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUM7WUFDL0IscUJBQXFCO2FBQ3BCLE1BQU0sQ0FDTCxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsRUFBRTtZQUNaLElBQUksWUFBWSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUM7Z0JBQUUsT0FBTyxHQUFHLENBQUM7WUFDdkMsSUFBSSxZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLElBQUksRUFBRSxjQUFjLEtBQUssS0FBSztnQkFBRSxPQUFPLEdBQUcsQ0FBQztZQUMzRSxHQUFHLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7WUFDM0IsT0FBTyxHQUFHLENBQUM7UUFDYixDQUFDLEVBQ2MsRUFBRSxDQUNsQixDQUNKLENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsZUFBZSxDQUFVLE1BQXNCO1FBQ3BELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7WUFBRSxPQUFPLE1BQU0sQ0FBQyxDQUFDLG1CQUFtQjtRQUM3RCxPQUFPLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBQzVELEdBQUc7WUFDSCxLQUFLLEVBQUUsTUFBTSxDQUFDLEdBQUcsQ0FBQztTQUNuQixDQUFDLENBQUMsQ0FBQztJQUNOLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxnQkFBZ0I7SUFDM0IsTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFzQjtRQUNwQyxJQUFJLENBQUMsTUFBTTtZQUFFLE9BQU8sU0FBUyxDQUFDO1FBQzlCLGlIQUFpSDtRQUNqSCxNQUFNLEdBQUcsR0FBSSxNQUFNLENBQUMsR0FBVyxFQUFFLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDO1FBRW5ELHNCQUFzQjtRQUN0QixJQUFJLEtBQUssR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDO1FBQ3pCLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3pCLEtBQUssR0FBRyxLQUFLO2lCQUNWLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7aUJBQ3RCLE1BQU0sQ0FBQyxRQUFRLENBQUM7aUJBQ2hCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNmLENBQUM7YUFBTSxDQUFDO1lBQ04sS0FBSyxHQUFJLEtBQWEsRUFBRSxFQUFFLElBQUksS0FBSyxDQUFDO1FBQ3RDLENBQUM7UUFDRCxPQUFPLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxDQUFDO0lBQ3hCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFByb3BlcnRpZXNNYXAsIFByb3BlcnR5IH0gZnJvbSAnLi4vLi4vLi4vc2hhcmVkL3R5cGVzJztcbmltcG9ydCB7IGlzTmlsT3JCbGFuaywgaXNOb3ROaWwgfSBmcm9tICcuLi8uLi8uLi9zaGFyZWQvZnVuY3Rpb25zJztcblxuZXhwb3J0IGNsYXNzIEFwcFByb3BlcnRpZXNVdGlscyB7XG4gIC8qKlxuICAgKiBDb252ZXJ0cyBhbiBhcnJheSBvZiBQcm9wZXJ0eSBvYmplY3RzIHRvIGFuIG9iamVjdCBtYXAuXG4gICAqXG4gICAqIEBwYXJhbSB7UHJvcGVydHlbXX0gW3NvdXJjZXNdIC0gVGhlIGFycmF5IG9mIFByb3BlcnR5IG9iamVjdHMgdG8gY29udmVydC5cbiAgICogQHBhcmFtIHtPYmplY3R9IFtvcHRzXSAtIE9wdGlvbnMgZm9yIHRoZSBjb252ZXJzaW9uLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IFtvcHRzLm9taXROaWxPckJsYW5rXSAtIElmIHNldCB0byB0cnVlLCBwcm9wZXJ0aWVzIHdpdGggbmlsIG9yIGJsYW5rIHZhbHVlcyB3aWxsIGJlIG9taXR0ZWQgZnJvbSB0aGUgcmVzdWx0aW5nIG9iamVjdC5cbiAgICogQHJldHVybiB7UHJvcGVydGllc01hcH0gVGhlIHJlc3VsdGluZyBvYmplY3QgbWFwIHdoZXJlIGtleXMgYXJlIHByb3BlcnR5IGtleXMgYW5kIHZhbHVlcyBhcmUgcHJvcGVydHkgdmFsdWVzLlxuICAgKi9cbiAgc3RhdGljIGFycmF5QXNPYmplY3Qoc291cmNlcz86IFByb3BlcnR5W10sIG9wdHM/OiB7IG9taXROaWxPckJsYW5rOiBib29sZWFuIH0pOiBQcm9wZXJ0aWVzTWFwIHtcbiAgICByZXR1cm4gKFxuICAgICAgKHNvdXJjZXMgfHwgW10pXG4gICAgICAgIC8vIFNlcmlhbGl6ZSBlYWNoIGl0ZW1cbiAgICAgICAgLm1hcChBcHBQcm9wZXJ0eVV0aWxzLmFzT2JqZWN0KVxuICAgICAgICAvLyBGaWxsIGEgSlNPTiBvYmplY3RcbiAgICAgICAgLnJlZHVjZShcbiAgICAgICAgICAocmVzLCBpdGVtKSA9PiB7XG4gICAgICAgICAgICBpZiAoaXNOaWxPckJsYW5rKGl0ZW0ua2V5KSkgcmV0dXJuIHJlcztcbiAgICAgICAgICAgIGlmIChpc05pbE9yQmxhbmsoaXRlbS52YWx1ZSkgJiYgb3B0cz8ub21pdE5pbE9yQmxhbmsgIT09IGZhbHNlKSByZXR1cm4gcmVzO1xuICAgICAgICAgICAgcmVzW2l0ZW0ua2V5XSA9IGl0ZW0udmFsdWU7XG4gICAgICAgICAgICByZXR1cm4gcmVzO1xuICAgICAgICAgIH0sXG4gICAgICAgICAgPFByb3BlcnRpZXNNYXA+e31cbiAgICAgICAgKVxuICAgICk7XG4gIH1cblxuICAvKipcbiAgICogQ29udmVydHMgYW4gb2JqZWN0IGludG8gYW4gYXJyYXkgb2YgcHJvcGVydGllcy5cbiAgICpcbiAgICogQHBhcmFtIHtQcm9wZXJ0aWVzTWFwfSBbc291cmNlXSAtIFRoZSBzb3VyY2Ugb2JqZWN0IGNvbnRhaW5pbmcgcHJvcGVydGllcyB0byBjb252ZXJ0LlxuICAgKiBAcmV0dXJuIHtQcm9wZXJ0eVtdfSBBbiBhcnJheSBvZiBwcm9wZXJ0aWVzIGRlcml2ZWQgZnJvbSB0aGUgc291cmNlIG9iamVjdC5cbiAgICovXG4gIHN0YXRpYyBhcnJheUZyb21PYmplY3Q8VCA9IGFueT4oc291cmNlPzogUHJvcGVydGllc01hcCk6IFByb3BlcnR5W10ge1xuICAgIGlmIChBcnJheS5pc0FycmF5KHNvdXJjZSkpIHJldHVybiBzb3VyY2U7IC8vIEFscmVhZHkgYW4gYXJyYXlcbiAgICByZXR1cm4gT2JqZWN0LmdldE93blByb3BlcnR5TmFtZXMoc291cmNlIHx8IHt9KS5tYXAoKGtleSkgPT4gKHtcbiAgICAgIGtleSxcbiAgICAgIHZhbHVlOiBzb3VyY2Vba2V5XSxcbiAgICB9KSk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEFwcFByb3BlcnR5VXRpbHMge1xuICBzdGF0aWMgYXNPYmplY3Qoc291cmNlOiBQcm9wZXJ0eSB8IGFueSk6IHsga2V5OiBzdHJpbmc7IHZhbHVlOiBzdHJpbmcgfSB8IHVuZGVmaW5lZCB7XG4gICAgaWYgKCFzb3VyY2UpIHJldHVybiB1bmRlZmluZWQ7XG4gICAgLy8gU2VyaWFsaXplIGtleSAoV0FSTklORzogY2FuIGJlIGFuIG9iamVjdCwgd2hlbiB1c2luZyBhdXRvY29tcGxldGUgZmllbGQgdG8gZWRpdCBhIGtleSAtIHNlZSBBcHBQcm9wZXJ0aWVzRm9ybSlcbiAgICBjb25zdCBrZXkgPSAoc291cmNlLmtleSBhcyBhbnkpPy5rZXkgPz8gc291cmNlLmtleTtcblxuICAgIC8vIFNlcmlhbGl6ZSB0aGUgdmFsdWVcbiAgICBsZXQgdmFsdWUgPSBzb3VyY2UudmFsdWU7XG4gICAgaWYgKEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgICB2YWx1ZSA9IHZhbHVlXG4gICAgICAgIC5tYXAoKHYpID0+IHY/LmlkID8/IHYpXG4gICAgICAgIC5maWx0ZXIoaXNOb3ROaWwpXG4gICAgICAgIC5qb2luKCcsJyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIHZhbHVlID0gKHZhbHVlIGFzIGFueSk/LmlkID8/IHZhbHVlO1xuICAgIH1cbiAgICByZXR1cm4geyBrZXksIHZhbHVlIH07XG4gIH1cbn1cbiJdfQ==
+//# 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 { PropertiesMap, Property } from '../../../shared/types';\nimport { isNil, isNilOrBlank, isNotEmptyArray, 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 {PropertiesMap} - The resulting `PropertiesMap` object.\n   */\n  static arrayAsObject(sources?: Property[], definitions?: FormFieldDefinition[], opts?: { omitNilOrBlank: boolean }): PropertiesMap {\n    return (\n      (sources || [])\n        // Serialize each item\n        .map((source) => {\n          if (!source) return undefined;\n          const key = AppPropertyUtils.key(source);\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            if (isNilOrBlank(item.value) && opts?.omitNilOrBlank !== false) return res;\n            res[item.key] = item.value;\n            return res;\n          },\n          <PropertiesMap>{}\n        )\n    );\n  }\n\n  /**\n   * Generates an array of properties from the given object, optionally applying definitions to the properties.\n   *\n   * @param {PropertiesMap} [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   * @return {Property[] | Promise<Property[]>} An array of properties generated from the source object, or a promise resolving to that array.\n   */\n  static arrayFromObject(sources?: PropertiesMap | Property[], definitions?: FormFieldDefinition[]): Property[] | Promise<Property[]> {\n    const targets = Array.isArray(sources)\n      ? sources.slice()\n      : Object.getOwnPropertyNames(sources || {}).map((key) => ({\n          key,\n          value: sources[key],\n        }));\n    const jobs = [];\n    if (isNotEmptyArray(definitions)) {\n      for (let target of targets) {\n        // Find definition\n        const def = definitions.find((def) => def.key === target.key);\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    }\n\n    // Return as promise, if need\n    if (jobs.length) return Promise.all(jobs).then(() => targets);\n\n    return targets;\n  }\n}\n\nexport class AppPropertyUtils {\n  static key(source: Property | any): string {\n    if (!source) return undefined;\n    return (source.key as any)?.key ?? source.key;\n  }\n\n  static asObject(source: Property | any, def?: FormFieldDefinition): { 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.key(source);\n\n    const joinAttribute = def?.autocomplete?.filter?.joinAttribute || 'id';\n    // Serialize the value\n    let value = source.value;\n    if (Array.isArray(value)) {\n      value = value\n        .map((v) => v?.[joinAttribute] ?? v)\n        .filter(isNotNil)\n        .join(',');\n    } else {\n      value = (value as any)?.id ?? value;\n    }\n    return { key, value: value?.toString() };\n  }\n\n  static fromObject(\n    source: Property<string>,\n    def: FormFieldDefinition,\n    opts?: { defaultSuggestFn: SuggestFn<any, any> }\n  ): Property<any> | Promise<Property<any>> {\n    if (!source?.key || isNil(source.value) || !def) return source; // 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, toBoolean(def.defaultValue));\n        break;\n      case 'integer':\n      case 'double':\n        target.value = toNumber(source.value, toNumber(def.defaultValue));\n        break;\n      case 'enums':\n        const keys = (target.value || '').trim().split(/[|,]+/);\n        if (isNotEmptyArray(keys)) {\n          const enumValues = keys.map((key) =>\n            (def.values as (string | Property)[])?.find((defValue) => defValue && key === (defValue['key'] || defValue))\n          );\n          target.value = enumValues || null;\n        } else {\n          target.value = null;\n        }\n        break;\n      case 'entity':\n        // Deserialize unique entity\n        const valueOrPromise = AppPropertyUtils.valueFromObject(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.valueFromObject(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 valueFromObject(\n    value: any,\n    def: FormFieldDefinition,\n    opts?: {\n      defaultSuggestFn: SuggestFn<any, any>;\n      defaultSuggestOptions?: EntitiesServiceLoadOptions;\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.resolveValueBySuggest(value, def, opts);\n  }\n\n  private static async resolveValueBySuggest(\n    value: any,\n    def: FormFieldDefinition,\n    opts?: {\n      defaultSuggestFn: SuggestFn<any, any>;\n      defaultSuggestOptions?: EntitiesServiceLoadOptions;\n    }\n  ): Promise<any> {\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    const joinAttribute = filter?.joinAttribute || 'id';\n    if (joinAttribute === 'id') {\n      filter.id = +value;\n      filter.offset = 0;\n      filter.size = 1;\n      searchValue = '*';\n      // DEBUG\n      console.debug(`[properties-utils] Resolving entity where id=${value}...`);\n    } else {\n      filter.searchAttribute = joinAttribute;\n      // DEBUG\n      console.debug(`[properties-utils] Resolving entity where ${joinAttribute}=${searchValue}...`);\n    }\n\n    try {\n      // Fetch entity, using the suggest function\n      const res = await suggestFn(searchValue, filter, joinAttribute, 'asc', {\n        withTotal: false,\n        ...opts?.defaultSuggestOptions,\n      });\n\n      // Get result array\n      const data = Array.isArray(res) ? res : res.data;\n\n      console.debug(`[properties-utils] ${data.length} entities found: `, data);\n\n      // Ok, we find it => stop here\n      if (data?.length) return data[0];\n    } catch (err) {\n      console.error(`Cannot fetch entity from ${def.key}=${value}`, err);\n      // Continue\n    }\n\n    // Create the missing result\n    const unresolvedEntity = <any>{\n      [joinAttribute]: 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"]}

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,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

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

@@ -3,10 +3,12 @@ import { AppPropertiesForm } from '../properties.form';
 import { StatusIds } from '../../../services/model/model.enum';
 import { suggestFromArray } from '../../../../shared/services';
 import { Validators } from '@angular/forms';
+import { AppPropertiesUtils } from '../properties.utils';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/forms";
-import * as i2 from "@ionic/angular";
-import * as i3 from "../properties.form";
+import * as i2 from "../property.validator";
+import * as i3 from "@ionic/angular";
+import * as i4 from "../properties.form";
 const TEST_PROPERTIES = Object.freeze({
     // Entity
     ENTITY: {
@@ -14,6 +16,7 @@ const TEST_PROPERTIES = Object.freeze({
         label: 'Select one entity',
         type: 'entity',
         autocomplete: {
+            showAllOnFocus: true,
             filter: {
                 entityName: 'LocationLevel',
                 statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],
@@ -28,6 +31,7 @@ const TEST_PROPERTIES = Object.freeze({
         label: 'Select many entities',
         type: 'entities',
         autocomplete: {
+            showAllOnFocus: true,
             filter: {
                 entityName: 'LocationLevel',
                 statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],
@@ -44,12 +48,14 @@ const FAKE_ENTITIES = [
 ];
 export class PropertiesFormTestPage {
     formBuilder;
+    pv;
     propertyDefinitions;
     i18nFieldPrefix;
     form;
     propertiesForm;
-    constructor(formBuilder) {
+    constructor(formBuilder, pv) {
         this.formBuilder = formBuilder;
+        this.pv = pv;
         this.i18nFieldPrefix = '';
         this.form = formBuilder.group({
             properties: formBuilder.array([
@@ -74,22 +80,30 @@ export class PropertiesFormTestPage {
         this.propertiesForm.markAsReady();
         this.propertiesForm.enable();
     }
-    ngAfterViewInit() {
-        const properties = {};
-        properties[TEST_PROPERTIES.ENTITIES.key] = FAKE_ENTITIES[0];
-        this.propertiesForm.setValue(properties);
+    async ngAfterViewInit() {
+        // Create the map, as it comes from the pod
+        const json = {
+            // Simple entity
+            [TEST_PROPERTIES.ENTITY.key]: FAKE_ENTITIES[0].id.toString(),
+            // Multiples entities
+            [TEST_PROPERTIES.ENTITIES.key]: [FAKE_ENTITIES[0], FAKE_ENTITIES[1]].map((entity) => entity.id).join(','),
+        };
+        // Convert to an array of Property
+        const data = await AppPropertiesUtils.arrayFromObject(json, this.propertyDefinitions);
+        console.debug('[properties-form-test] Value to set: ', data);
+        this.propertiesForm.value = data;
     }
     async suggestEntity(value, filter) {
         return suggestFromArray(FAKE_ENTITIES, value, filter);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PropertiesFormTestPage, deps: [{ token: i1.FormBuilder }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: PropertiesFormTestPage, selector: "app-properties-form-test", viewQueries: [{ propertyName: "propertiesForm", first: true, predicate: ["propertiesForm"], descendants: true, read: AppPropertiesForm, static: true }], ngImport: i0, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Properties form test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <form [formGroup]=\"form\">\n    <app-properties-form\n      #propertiesForm\n      formArrayName=\"properties\"\n      [definitions]=\"propertyDefinitions\"\n      [options]=\"{ allowEmptyArray: true }\"\n      showHintKey=\"true\"\n    ></app-properties-form>\n  </form>\n</ion-content>\n", dependencies: [{ kind: "component", type: i2.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i2.IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i2.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i2.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i2.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: i2.IonBackButton, selector: "ion-back-button" }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { kind: "component", type: i3.AppPropertiesForm, selector: "app-properties-form", inputs: ["formArrayName", "formArray", "options", "chipColor", "mobile", "appearance", "subscriptSizing", "showHintKey", "hintKeyPrefix", "showMoreButton", "showMoreButtonTitle", "showAddButton", "definitions"] }] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PropertiesFormTestPage, deps: [{ token: i1.FormBuilder }, { token: i2.PropertyValidator }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: PropertiesFormTestPage, selector: "app-properties-form-test", viewQueries: [{ propertyName: "propertiesForm", first: true, predicate: ["propertiesForm"], descendants: true, read: AppPropertiesForm, static: true }], ngImport: i0, template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Properties form test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <form [formGroup]=\"form\">\n    <app-properties-form\n      #propertiesForm\n      formArrayName=\"properties\"\n      [definitions]=\"propertyDefinitions\"\n      [options]=\"{ allowEmptyArray: true }\"\n      showHintKey=\"true\"\n    ></app-properties-form>\n  </form>\n</ion-content>\n", dependencies: [{ kind: "component", type: i3.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i3.IonContent, selector: "ion-content", inputs: ["color", "fixedSlotPlacement", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i3.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i3.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i3.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "component", type: i3.IonBackButton, selector: "ion-back-button" }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { kind: "component", type: i4.AppPropertiesForm, selector: "app-properties-form", inputs: ["formArrayName", "formArray", "options", "chipColor", "mobile", "appearance", "subscriptSizing", "showHintKey", "hintKeyPrefix", "showMoreButton", "showMoreButtonTitle", "showAddButton", "definitions"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PropertiesFormTestPage, decorators: [{
             type: Component,
             args: [{ selector: 'app-properties-form-test', template: "<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Properties form test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <form [formGroup]=\"form\">\n    <app-properties-form\n      #propertiesForm\n      formArrayName=\"properties\"\n      [definitions]=\"propertyDefinitions\"\n      [options]=\"{ allowEmptyArray: true }\"\n      showHintKey=\"true\"\n    ></app-properties-form>\n  </form>\n</ion-content>\n" }]
-        }], ctorParameters: () => [{ type: i1.FormBuilder }], propDecorators: { propertiesForm: [{
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i2.PropertyValidator }], propDecorators: { propertiesForm: [{
                 type: ViewChild,
                 args: ['propertiesForm', { read: AppPropertiesForm, static: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"properties-form.test.js","sourceRoot":"","sources":["../../../../../../../../src/app/core/form/properties/testing/properties-form.test.ts","../../../../../../../../src/app/core/form/properties/testing/properties-form.test.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, OnInit, ViewChild } from '@angular/core';\nimport { FormFieldDefinition } from '../../../../shared/form/field.model';\nimport { AppPropertiesForm } from '../properties.form';\nimport { StatusIds } from '../../../services/model/model.enum';\nimport { suggestFromArray } from '../../../../shared/services';\nimport { LoadResult } from '../../../../shared/services/entity-service.class';\nimport { ObjectMap } from '../../../../shared/types';\nimport { FormBuilder, FormGroup, Validators } from '@angular/forms';\n\nconst TEST_PROPERTIES = Object.freeze({\n  // Entity\n  ENTITY: <FormFieldDefinition>{\n    key: 'sumaris.properties.entity',\n    label: 'Select one entity',\n    type: 'entity',\n    autocomplete: {\n      filter: {\n        entityName: 'LocationLevel',\n        statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],\n      },\n      attributes: ['label', 'name'],\n    },\n    defaultValue: null,\n  },\n\n  // Entities\n  ENTITIES: <FormFieldDefinition>{\n    key: 'sumaris.properties.entities',\n    label: 'Select many entities',\n    type: 'entities',\n    autocomplete: {\n      filter: {\n        entityName: 'LocationLevel',\n        statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],\n      },\n      attributes: ['label', 'name'],\n    },\n    defaultValue: null,\n  },\n});\n\nconst FAKE_ENTITIES = [\n  { id: 1, label: 'AAA', name: 'Item A', description: 'Very long description A', comments: 'Very very long comments... again for A' },\n  { id: 2, label: 'BBB', name: 'Item B', description: 'Very long description B', comments: 'Very very long comments... again for B' },\n  { id: 3, label: 'CCC', name: 'Item C', description: 'Very long description C', comments: 'Very very long comments... again for C' },\n];\n\n@Component({\n  selector: 'app-properties-form-test',\n  templateUrl: './properties-form.test.html',\n})\nexport class PropertiesFormTestPage implements OnInit, AfterViewInit {\n  propertyDefinitions: FormFieldDefinition[];\n  i18nFieldPrefix: string;\n  form: FormGroup;\n\n  @ViewChild('propertiesForm', { read: AppPropertiesForm, static: true }) propertiesForm: AppPropertiesForm;\n\n  constructor(protected formBuilder: FormBuilder) {\n    this.i18nFieldPrefix = '';\n    this.form = formBuilder.group({\n      properties: formBuilder.array([\n        this.formBuilder.group({\n          key: [null, Validators.compose([Validators.required, Validators.max(50)])],\n          value: [null, Validators.required],\n        }),\n      ]),\n    });\n\n    this.propertyDefinitions = Object.values(TEST_PROPERTIES).map((def) => {\n      if (def.type === 'entity' || def.type === 'entities') {\n        def = Object.assign({}, def); // Copy\n        def.autocomplete = {\n          suggestFn: (value, filter) => this.suggestEntity(value, filter),\n          ...def.autocomplete,\n        };\n      }\n      return def;\n    });\n  }\n\n  ngOnInit() {\n    this.propertiesForm.markAsReady();\n    this.propertiesForm.enable();\n  }\n\n  ngAfterViewInit() {\n    const properties: ObjectMap = {};\n    properties[TEST_PROPERTIES.ENTITIES.key] = FAKE_ENTITIES[0];\n    this.propertiesForm.setValue(properties);\n  }\n\n  protected async suggestEntity(value: any, filter: any): Promise<LoadResult<any>> {\n    return suggestFromArray(FAKE_ENTITIES, value, filter);\n  }\n}\n","<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Properties form test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <form [formGroup]=\"form\">\n    <app-properties-form\n      #propertiesForm\n      formArrayName=\"properties\"\n      [definitions]=\"propertyDefinitions\"\n      [options]=\"{ allowEmptyArray: true }\"\n      showHintKey=\"true\"\n    ></app-properties-form>\n  </form>\n</ion-content>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"properties-form.test.js","sourceRoot":"","sources":["../../../../../../../../src/app/core/form/properties/testing/properties-form.test.ts","../../../../../../../../src/app/core/form/properties/testing/properties-form.test.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, OnInit, ViewChild } from '@angular/core';\nimport { FormFieldDefinition } from '../../../../shared/form/field.model';\nimport { AppPropertiesForm } from '../properties.form';\nimport { StatusIds } from '../../../services/model/model.enum';\nimport { suggestFromArray } from '../../../../shared/services';\nimport { LoadResult } from '../../../../shared/services/entity-service.class';\nimport { FormBuilder, FormGroup, Validators } from '@angular/forms';\nimport { PropertyValidator } from '../property.validator';\nimport { AppPropertiesUtils } from '../properties.utils';\nimport { PropertiesMap } from '../../../../shared/types';\n\nconst TEST_PROPERTIES = Object.freeze({\n  // Entity\n  ENTITY: <FormFieldDefinition>{\n    key: 'sumaris.properties.entity',\n    label: 'Select one entity',\n    type: 'entity',\n    autocomplete: {\n      showAllOnFocus: true,\n      filter: {\n        entityName: 'LocationLevel',\n        statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],\n      },\n      attributes: ['label', 'name'],\n    },\n    defaultValue: null,\n  },\n\n  // Entities\n  ENTITIES: <FormFieldDefinition>{\n    key: 'sumaris.properties.entities',\n    label: 'Select many entities',\n    type: 'entities',\n    autocomplete: {\n      showAllOnFocus: true,\n      filter: {\n        entityName: 'LocationLevel',\n        statusIds: [StatusIds.DISABLE, StatusIds.ENABLE],\n      },\n      attributes: ['label', 'name'],\n    },\n    defaultValue: null,\n  },\n});\n\nconst FAKE_ENTITIES = [\n  { id: 1, label: 'AAA', name: 'Item A', description: 'Very long description A', comments: 'Very very long comments... again for A' },\n  { id: 2, label: 'BBB', name: 'Item B', description: 'Very long description B', comments: 'Very very long comments... again for B' },\n  { id: 3, label: 'CCC', name: 'Item C', description: 'Very long description C', comments: 'Very very long comments... again for C' },\n];\n\n@Component({\n  selector: 'app-properties-form-test',\n  templateUrl: './properties-form.test.html',\n})\nexport class PropertiesFormTestPage implements OnInit, AfterViewInit {\n  propertyDefinitions: FormFieldDefinition[];\n  i18nFieldPrefix: string;\n  form: FormGroup;\n\n  @ViewChild('propertiesForm', { read: AppPropertiesForm, static: true }) propertiesForm: AppPropertiesForm;\n\n  constructor(\n    protected formBuilder: FormBuilder,\n    protected pv: PropertyValidator\n  ) {\n    this.i18nFieldPrefix = '';\n    this.form = formBuilder.group({\n      properties: formBuilder.array([\n        this.formBuilder.group({\n          key: [null, Validators.compose([Validators.required, Validators.max(50)])],\n          value: [null, Validators.required],\n        }),\n      ]),\n    });\n\n    this.propertyDefinitions = Object.values(TEST_PROPERTIES).map((def) => {\n      if (def.type === 'entity' || def.type === 'entities') {\n        def = Object.assign({}, def); // Copy\n        def.autocomplete = {\n          suggestFn: (value, filter) => this.suggestEntity(value, filter),\n          ...def.autocomplete,\n        };\n      }\n      return def;\n    });\n  }\n\n  ngOnInit() {\n    this.propertiesForm.markAsReady();\n    this.propertiesForm.enable();\n  }\n\n  async ngAfterViewInit() {\n    // Create the map, as it comes from the pod\n    const json = <PropertiesMap>{\n      // Simple entity\n      [TEST_PROPERTIES.ENTITY.key]: FAKE_ENTITIES[0].id.toString(),\n\n      // Multiples entities\n      [TEST_PROPERTIES.ENTITIES.key]: [FAKE_ENTITIES[0], FAKE_ENTITIES[1]].map((entity) => entity.id).join(','),\n    };\n\n    // Convert to an array of Property\n    const data = await AppPropertiesUtils.arrayFromObject(json, this.propertyDefinitions);\n\n    console.debug('[properties-form-test] Value to set: ', data);\n    this.propertiesForm.value = data;\n  }\n\n  protected async suggestEntity(value: any, filter: any): Promise<LoadResult<any>> {\n    return suggestFromArray(FAKE_ENTITIES, value, filter);\n  }\n}\n","<ion-header>\n  <ion-toolbar color=\"primary\">\n    <ion-buttons slot=\"start\">\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n\n    <ion-title>Properties form test page</ion-title>\n  </ion-toolbar>\n</ion-header>\n\n<ion-content class=\"ion-padding\">\n  <form [formGroup]=\"form\">\n    <app-properties-form\n      #propertiesForm\n      formArrayName=\"properties\"\n      [definitions]=\"propertyDefinitions\"\n      [options]=\"{ allowEmptyArray: true }\"\n      showHintKey=\"true\"\n    ></app-properties-form>\n  </form>\n</ion-content>\n"]}

package/esm2022/src/app/core/home/home.module.mjs

@@ -5,7 +5,7 @@ import { AppAuthModule } from '../auth/auth.module';
 import { TranslateModule } from '@ngx-translate/core';
 import { RouterModule } from '@angular/router';
 import { AppInstallUpgradeCardModule } from '../install/install-upgrade-card.module';
-import { RxStateModule } from '../../shared/rx-state.module';
+import { RxStateModule } from '../../shared/rx-state/rx-state.module';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
 export class AppHomePageModule {
@@ -39,4 +39,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     exports: [RouterModule, TranslateModule, HomePage],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/core/menu/menu.module.mjs

@@ -4,7 +4,7 @@ import { MenuComponent } from './menu.component';
 import { TranslateModule } from '@ngx-translate/core';
 import { RouterModule } from '@angular/router';
 import { SubMenuTabDirective } from './sub-menu-tab.directive';
-import { RxStateModule } from '../../shared/rx-state.module';
+import { RxStateModule } from '../../shared/rx-state/rx-state.module';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
 export class AppMenuModule {
@@ -44,4 +44,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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