@ecodev/natural 41.3.0 → 42.0.0

package/esm2020/lib/classes/data-source.mjs

@@ -0,0 +1,76 @@
+/**
+ * Data source to provide what data should be rendered in the table. The observable provided
+ * in connect should emit exactly the data that should be rendered by the table. If the data is
+ * altered, the observable should emit that new set of data on the stream. In our case here,
+ * we return a stream that contains only one set of data that doesn't change.
+ */
+import { DataSource } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { map, takeUntil } from 'rxjs/operators';
+/**
+ * A NaturalDataSource will connect immediately, in order to know as soon as possible if
+ * we need to show a template at all (as seen in my-ichtus)
+ *
+ * It also allow some extra data manipulation
+ */
+export class NaturalDataSource extends DataSource {
+    constructor(value) {
+        super();
+        this.ngUnsubscribe = new Subject();
+        if (value instanceof Observable) {
+            this.internalData = new BehaviorSubject(null);
+            value.pipe(takeUntil(this.ngUnsubscribe)).subscribe(res => (this.data = res));
+        }
+        else {
+            this.internalData = new BehaviorSubject(value);
+        }
+    }
+    get internalDataObservable() {
+        return this.internalData;
+    }
+    /**
+     * Array of data that should be rendered by the table, where each object represents one row.
+     */
+    get data() {
+        return this.internalData.value;
+    }
+    set data(data) {
+        this.internalData.next(data);
+    }
+    connect() {
+        return this.internalData.pipe(takeUntil(this.ngUnsubscribe), map(data => (data ? data.items : [])));
+    }
+    disconnect() {
+        this.ngUnsubscribe.next(); // unsubscribe everybody
+        this.ngUnsubscribe.complete(); // complete the stream, because we will never emit again
+    }
+    push(item) {
+        if (!this.data) {
+            return;
+        }
+        const fullList = this.data.items;
+        fullList.push(item);
+        this.data = Object.assign(this.data, { items: fullList, length: fullList.length });
+    }
+    pop() {
+        if (!this.data) {
+            return;
+        }
+        const fullList = this.data.items;
+        const removedElement = fullList.pop();
+        this.data = Object.assign(this.data, { items: fullList, length: fullList.length });
+        return removedElement;
+    }
+    remove(item) {
+        if (!this.data) {
+            return;
+        }
+        const index = this.data.items.indexOf(item);
+        if (index > -1) {
+            this.data.items.splice(index, 1);
+            this.data.length--;
+            this.data = this.data;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/classes/query-variable-manager.mjs

@@ -0,0 +1,161 @@
+import { cloneDeep, defaultsDeep, isArray, mergeWith, omit } from 'lodash-es';
+import { BehaviorSubject } from 'rxjs';
+import { mergeOverrideArray } from './utility';
+import { hasMixedGroupLogic } from './query-variable-manager-utils';
+export var SortingOrder;
+(function (SortingOrder) {
+    SortingOrder["ASC"] = "ASC";
+    SortingOrder["DESC"] = "DESC";
+})(SortingOrder || (SortingOrder = {}));
+/**
+ * During lodash merge, concat arrays
+ */
+function mergeConcatArray(destValue, source) {
+    if (isArray(source)) {
+        if (destValue) {
+            return destValue.concat(source);
+        }
+        else {
+            return source;
+        }
+    }
+}
+/**
+ * Filter manager stores a set of channels that contain a variable object and exposes an observable "variables" that updates with the result
+ * of all channels merged together.
+ *
+ * A channel is supposed to be used by an aspect of the GUI (pagination, sorting, search, others ?).
+ * Each
+ *
+ * const fm = new QueryVariablesManager();
+ * fm.merge('componentA-variables', {a : [1, 2, 3]});
+ *
+ * Variables attributes is a BehaviorSubject. That mean it's not mandatory to subscribe, we can just call getValue or value attributes on
+ * it : console.log(fm.variables.value); //  {a : [1, 2, 3]}
+ *
+ * Set new variables for 'componentA-variables'
+ * fm.merge('componentA-variables', {a : [1, 2]);
+ * console.log(fm.variables.value); //  {a : [1, 2, 3]}
+ *
+ * Set new variables for new channel
+ * fm.merge('componentB-variables', {a : [3, 4]);
+ * console.log(fm.variables.value); // {a : [1, 2, 3, 4]}
+ */
+export class NaturalQueryVariablesManager {
+    constructor(queryVariablesManager) {
+        this.variables = new BehaviorSubject(undefined);
+        this.channels = new Map();
+        if (queryVariablesManager) {
+            this.channels = queryVariablesManager.getChannelsCopy();
+            this.updateVariables();
+        }
+    }
+    /**
+     * Set or override all the variables that may exist in the given channel
+     */
+    set(channelName, variables) {
+        // cloneDeep to change reference and prevent some interactions when merge
+        if (variables) {
+            this.channels.set(channelName, cloneDeep(variables));
+        }
+        else {
+            this.channels.delete(channelName);
+        }
+        this.updateVariables();
+    }
+    /**
+     * Return a deep clone of the variables for the given channel name.
+     *
+     * Avoid returning the same reference to prevent an attribute change, then another channel update that would
+     * used this changed attribute without having explicitly asked QueryVariablesManager to update it.
+     */
+    get(channelName) {
+        return cloneDeep(this.channels.get(channelName));
+    }
+    /**
+     * Merge variable into a channel, overriding arrays in same channel / key
+     */
+    merge(channelName, newVariables) {
+        const variables = this.channels.get(channelName);
+        if (variables) {
+            mergeWith(variables, cloneDeep(newVariables), mergeOverrideArray); // merge preserves references, cloneDeep prevent that
+            this.updateVariables();
+        }
+        else {
+            this.set(channelName, newVariables);
+        }
+    }
+    /**
+     * Apply default values to a channel
+     * Note : lodash defaults only defines values on destinations keys that are undefined
+     */
+    defaults(channelName, newVariables) {
+        const variables = this.channels.get(channelName);
+        if (variables) {
+            defaultsDeep(variables, newVariables);
+            this.updateVariables();
+        }
+        else {
+            this.set(channelName, newVariables);
+        }
+    }
+    getChannelsCopy() {
+        return new Map(this.channels);
+    }
+    /**
+     * Merge channels in a single object
+     * Arrays are concatenated
+     * Filter groups are combined smartly (see mergeGroupList)
+     */
+    updateVariables() {
+        const merged = {};
+        this.channels.forEach((channelVariables) => {
+            if (channelVariables.filter) {
+                // Merge filter's groups first
+                const groups = this.mergeGroupList(merged.filter && merged.filter.groups ? merged.filter.groups : [], channelVariables.filter.groups || []);
+                // Merge filter key (that contain groups)
+                if (groups && groups.length) {
+                    if (merged.filter) {
+                        merged.filter.groups = groups;
+                    }
+                    else {
+                        merged.filter = { groups: groups };
+                    }
+                }
+                else {
+                    mergeWith(merged, { filter: channelVariables.filter }, mergeConcatArray);
+                }
+            }
+            // Merge other attributes than filter
+            mergeWith(merged, omit(channelVariables, 'filter'), mergeConcatArray);
+        });
+        this.variables.next(merged);
+    }
+    /**
+     * Cross merge two filters
+     * Only accepts groups with same groupLogic (ignores the first one, because there is no groupLogic in this one)
+     * @throws In case two non-empty lists of groups are given and at one of them mix groupLogic value, throws an error
+     */
+    mergeGroupList(groupsA, groupsB) {
+        if (groupsA.length === 0 && groupsB.length === 0) {
+            return []; // empty listings, return empty lists
+        }
+        if (groupsA.length === 0 && groupsB.length > 0) {
+            return groupsB; // One list is empty, return the one that is not
+        }
+        if (groupsB.length === 0 && groupsA.length > 0) {
+            return groupsA; // One list is empty, return the one that is not
+        }
+        const groups = [];
+        if (hasMixedGroupLogic(groupsA) || hasMixedGroupLogic(groupsB)) {
+            throw Error('QueryVariables groups contain mixed group logics');
+        }
+        groupsA.forEach(groupA => {
+            groupsB.forEach(groupB => {
+                groups.push(mergeWith(cloneDeep(groupA), groupB, mergeConcatArray));
+            });
+        });
+        return groups;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-variable-manager.js","sourceRoot":"","sources":["../../../../../projects/natural/src/lib/classes/query-variable-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import {cloneDeep, defaultsDeep, isArray, mergeWith, omit} from 'lodash-es';\nimport {BehaviorSubject} from 'rxjs';\nimport {Literal} from '../types/types';\nimport {mergeOverrideArray} from './utility';\nimport {hasMixedGroupLogic} from './query-variable-manager-utils';\n\nexport interface QueryVariables {\n    filter?: any | null;\n    pagination?: PaginationInput | null;\n    sorting?: Array<Sorting> | null;\n}\n\nexport interface PaginationInput {\n    offset?: number | null;\n    pageIndex?: number | null;\n    pageSize?: number | null;\n}\n\nexport interface Sorting {\n    field: any;\n    order?: SortingOrder | null;\n    nullAsHighest?: boolean | null;\n}\n\nexport enum SortingOrder {\n    ASC = 'ASC',\n    DESC = 'DESC',\n}\n\n/**\n * During lodash merge, concat arrays\n */\nfunction mergeConcatArray(destValue: any, source: any): any {\n    if (isArray(source)) {\n        if (destValue) {\n            return destValue.concat(source);\n        } else {\n            return source;\n        }\n    }\n}\n\n/**\n * Filter manager stores a set of channels that contain a variable object and exposes an observable \"variables\" that updates with the result\n * of all channels merged together.\n *\n * A channel is supposed to be used by an aspect of the GUI (pagination, sorting, search, others ?).\n * Each\n *\n * const fm = new QueryVariablesManager();\n * fm.merge('componentA-variables', {a : [1, 2, 3]});\n *\n * Variables attributes is a BehaviorSubject. That mean it's not mandatory to subscribe, we can just call getValue or value attributes on\n * it : console.log(fm.variables.value); //  {a : [1, 2, 3]}\n *\n * Set new variables for 'componentA-variables'\n * fm.merge('componentA-variables', {a : [1, 2]);\n * console.log(fm.variables.value); //  {a : [1, 2, 3]}\n *\n * Set new variables for new channel\n * fm.merge('componentB-variables', {a : [3, 4]);\n * console.log(fm.variables.value); // {a : [1, 2, 3, 4]}\n */\nexport class NaturalQueryVariablesManager<T extends QueryVariables = QueryVariables> {\n    public readonly variables: BehaviorSubject<T | undefined> = new BehaviorSubject<T | undefined>(undefined);\n    private readonly channels: Map<string, Partial<T>> = new Map<string, Partial<T>>();\n\n    public constructor(queryVariablesManager?: NaturalQueryVariablesManager<T>) {\n        if (queryVariablesManager) {\n            this.channels = queryVariablesManager.getChannelsCopy();\n            this.updateVariables();\n        }\n    }\n\n    /**\n     * Set or override all the variables that may exist in the given channel\n     */\n    public set(channelName: string, variables: Partial<T> | null | undefined): void {\n        // cloneDeep to change reference and prevent some interactions when merge\n        if (variables) {\n            this.channels.set(channelName, cloneDeep(variables));\n        } else {\n            this.channels.delete(channelName);\n        }\n        this.updateVariables();\n    }\n\n    /**\n     * Return a deep clone of the variables for the given channel name.\n     *\n     * Avoid returning the same reference to prevent an attribute change, then another channel update that would\n     * used this changed attribute without having explicitly asked QueryVariablesManager to update it.\n     */\n    public get(channelName: string): Partial<T> | undefined {\n        return cloneDeep(this.channels.get(channelName));\n    }\n\n    /**\n     * Merge variable into a channel, overriding arrays in same channel / key\n     */\n    public merge(channelName: string, newVariables: Partial<T>): void {\n        const variables = this.channels.get(channelName);\n        if (variables) {\n            mergeWith(variables, cloneDeep(newVariables), mergeOverrideArray); // merge preserves references, cloneDeep prevent that\n            this.updateVariables();\n        } else {\n            this.set(channelName, newVariables);\n        }\n    }\n\n    /**\n     * Apply default values to a channel\n     * Note : lodash defaults only defines values on destinations keys that are undefined\n     */\n    public defaults(channelName: string, newVariables: Partial<T>): void {\n        const variables = this.channels.get(channelName);\n        if (variables) {\n            defaultsDeep(variables, newVariables);\n            this.updateVariables();\n        } else {\n            this.set(channelName, newVariables);\n        }\n    }\n\n    private getChannelsCopy(): Map<string, Partial<T>> {\n        return new Map<string, Partial<T>>(this.channels);\n    }\n\n    /**\n     * Merge channels in a single object\n     * Arrays are concatenated\n     * Filter groups are combined smartly (see mergeGroupList)\n     */\n    private updateVariables(): void {\n        const merged: Literal = {};\n\n        this.channels.forEach((channelVariables: Literal) => {\n            if (channelVariables.filter) {\n                // Merge filter's groups first\n                const groups = this.mergeGroupList(\n                    merged.filter && merged.filter.groups ? merged.filter.groups : [],\n                    channelVariables.filter.groups || [],\n                );\n\n                // Merge filter key (that contain groups)\n                if (groups && groups.length) {\n                    if (merged.filter) {\n                        merged.filter.groups = groups;\n                    } else {\n                        merged.filter = {groups: groups};\n                    }\n                } else {\n                    mergeWith(merged, {filter: channelVariables.filter}, mergeConcatArray);\n                }\n            }\n\n            // Merge other attributes than filter\n            mergeWith(merged, omit(channelVariables, 'filter'), mergeConcatArray);\n        });\n\n        this.variables.next(merged as T);\n    }\n\n    /**\n     * Cross merge two filters\n     * Only accepts groups with same groupLogic (ignores the first one, because there is no groupLogic in this one)\n     * @throws In case two non-empty lists of groups are given and at one of them mix groupLogic value, throws an error\n     */\n    private mergeGroupList(groupsA: Literal[], groupsB: Literal[]): Literal {\n        if (groupsA.length === 0 && groupsB.length === 0) {\n            return []; // empty listings, return empty lists\n        }\n\n        if (groupsA.length === 0 && groupsB.length > 0) {\n            return groupsB; // One list is empty, return the one that is not\n        }\n\n        if (groupsB.length === 0 && groupsA.length > 0) {\n            return groupsA; // One list is empty, return the one that is not\n        }\n\n        const groups: Literal[] = [];\n\n        if (hasMixedGroupLogic(groupsA) || hasMixedGroupLogic(groupsB)) {\n            throw Error('QueryVariables groups contain mixed group logics');\n        }\n\n        groupsA.forEach(groupA => {\n            groupsB.forEach(groupB => {\n                groups.push(mergeWith(cloneDeep(groupA), groupB, mergeConcatArray));\n            });\n        });\n\n        return groups;\n    }\n}\n"]}

package/esm2020/lib/classes/validators.mjs

@@ -0,0 +1,179 @@
+import { FormArray, FormGroup, Validators, } from '@angular/forms';
+import { of, timer } from 'rxjs';
+import { filter, first, map, switchMap } from 'rxjs/operators';
+import { NaturalQueryVariablesManager } from './query-variable-manager';
+import { validTlds } from './tld';
+/**
+ * Returns an async validator function that checks that the form control value is unique
+ */
+export function unique(fieldName, excludedId, modelService) {
+    return (control) => {
+        if (!control.value || !control.dirty) {
+            return of(null);
+        }
+        const condition = {};
+        condition[fieldName] = { equal: { value: control.value } };
+        if (excludedId) {
+            condition['id'] = { equal: { value: excludedId, not: true } };
+        }
+        const variables = {
+            pagination: { pageIndex: 0, pageSize: 0 },
+            filter: { groups: [{ conditions: [condition] }] },
+        };
+        const qvm = new NaturalQueryVariablesManager();
+        qvm.set('variables', variables);
+        return timer(500).pipe(switchMap(() => modelService.count(qvm).pipe(map(count => (count > 0 ? { duplicateValue: count } : null)))));
+    };
+}
+/**
+ * Returns an async validator function that checks that the form control value is available
+ *
+ * Similar to `unique` validator, but allows to use a custom query for when the client does
+ * not have permissions for `modelService.count()`.
+ */
+export function available(getAvailableQuery, excludedId = null) {
+    return (control) => {
+        if (!control.value || !control.dirty) {
+            return of(null);
+        }
+        return timer(500).pipe(switchMap(() => getAvailableQuery(control.value, excludedId).pipe(map(isAvailable => (isAvailable ? null : { available: true })))));
+    };
+}
+/**
+ * Return all errors recursively for the given Form or control
+ */
+export function collectErrors(control) {
+    let errors = null;
+    if (control instanceof FormGroup || control instanceof FormArray) {
+        errors = Object.entries(control.controls).reduce((acc, [key, childControl]) => {
+            const childErrors = collectErrors(childControl);
+            if (childErrors) {
+                acc = { ...acc, [key]: childErrors };
+            }
+            return acc;
+        }, null);
+    }
+    if (!errors) {
+        errors = control.errors;
+    }
+    return errors;
+}
+/**
+ * Force validation of all form controls recursively.
+ *
+ * Recursively mark descending form tree as dirty and touched in order to show all invalid fields on demand.
+ * Typically used when creating a new object and user clicked on create button but several fields were not
+ * touched and are invalid.
+ */
+export function validateAllFormControls(control) {
+    control.markAsDirty({ onlySelf: true });
+    control.markAsTouched({ onlySelf: true });
+    if (control instanceof FormGroup || control instanceof FormArray) {
+        for (const [, child] of Object.entries(control.controls)) {
+            validateAllFormControls(child);
+        }
+    }
+}
+function isValid(status) {
+    return status === 'VALID';
+}
+/**
+ * Emits exactly 0 or 1 time:
+ *
+ * - if the form is VALID, emits immediately
+ * - if the form is PENDING emits if it changes from PENDING to VALID
+ * - any other cases will **never** emit
+ */
+export function ifValid(control) {
+    const observable = control.pending ? control.statusChanges.pipe(first()) : of(control.status);
+    return observable.pipe(filter(isValid));
+}
+// This is is an approximation of RFC_5322 where the hostname:
+//
+// - is too strict because it rejects IP address
+// - is too lax because it accepts pretty much anything else
+//
+// but the TLD will be validated against a whitelist so that should make the whole thing acceptable
+const RFC_5322 = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[^@ ]+\.[^@]+$/u;
+/**
+ * Validate an email address according to RFC, and also that it is publicly deliverable (not "root@localhost" or "root@127.0.0.1")
+ *
+ * This is meant to replace **all** usages of Angular too permissive `Validators.email`
+ */
+export function deliverableEmail(control) {
+    // don't validate empty values to allow optional controls
+    const value = control.value;
+    if (!value) {
+        return null;
+    }
+    const error = { email: true };
+    if (value.length > 254) {
+        return error;
+    }
+    if (!RFC_5322.test(value)) {
+        return error;
+    }
+    const tld = value.split('.').pop();
+    if (!validTlds.includes(tld)) {
+        return error;
+    }
+    return null;
+}
+/**
+ * Naive URL validator for "normal" web links, that is a bit too permissive
+ *
+ * It enforces:
+ *
+ *     - http/https protocol
+ *     - one domain
+ *     - one tld
+ *
+ * It allows:
+ *
+ *     - any number of subdomains
+ *     - any parameters
+ *     - any fragments
+ *     - any characters for any parts (does not conform to rfc1738)
+ */
+export const urlValidator = Validators.pattern(/^https?:\/\/(?:[^.\s]+\.)+[^.\s]+$/);
+/**
+ * Validates that the value is an integer (non-float)
+ */
+export function integer(control) {
+    // Don't validate empty values to allow optional controls
+    if (control.value === null || control.value === undefined || control.value === '') {
+        return null;
+    }
+    return Number.isInteger(parseFloat(control.value)) ? null : { integer: true };
+}
+/**
+ * Validate that the value is a decimal number with up to `scale` digits
+ *
+ * The error contains the expected scale, so that the error message can explain
+ * it to the end-user.
+ */
+export function decimal(scale) {
+    const regExp = new RegExp(`^-?\\d+(\\.\\d{0,${scale}})?$`);
+    return control => {
+        // Don't validate empty values to allow optional controls
+        if (control.value === null || control.value === undefined || control.value === '') {
+            return null;
+        }
+        const value = '' + control.value;
+        if (value.match(regExp)) {
+            return null;
+        }
+        return { decimal: scale };
+    };
+}
+/**
+ * For internal use to avoid re-creating regexp on each call of `money`
+ */
+const twoDecimals = decimal(2);
+/**
+ * Validate that the value is an amount of money, meaning a number with at most 2 decimals
+ */
+export function money(control) {
+    return twoDecimals(control) ? { money: true } : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../../../../projects/natural/src/lib/classes/validators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AbstractControl,\n    AsyncValidatorFn,\n    FormArray,\n    FormControlStatus,\n    FormGroup,\n    ValidationErrors,\n    ValidatorFn,\n    Validators,\n} from '@angular/forms';\nimport {Observable, of, timer} from 'rxjs';\nimport {filter, first, map, switchMap} from 'rxjs/operators';\nimport {NaturalAbstractModelService} from '../services/abstract-model.service';\nimport {NaturalQueryVariablesManager, QueryVariables} from './query-variable-manager';\nimport {validTlds} from './tld';\nimport {FilterGroupCondition} from '../modules/search/classes/graphql-doctrine.types';\n\n/**\n * Returns an async validator function that checks that the form control value is unique\n */\nexport function unique<TService extends NaturalAbstractModelService<any, any, any, any, any, any, any, any, any, any>>(\n    fieldName: string,\n    excludedId: string | null | undefined,\n    modelService: TService,\n): AsyncValidatorFn {\n    return (control: AbstractControl): Observable<ValidationErrors | null> => {\n        if (!control.value || !control.dirty) {\n            return of(null);\n        }\n\n        const condition: FilterGroupCondition = {};\n        condition[fieldName] = {equal: {value: control.value}};\n\n        if (excludedId) {\n            condition['id'] = {equal: {value: excludedId, not: true}};\n        }\n\n        const variables: QueryVariables = {\n            pagination: {pageIndex: 0, pageSize: 0},\n            filter: {groups: [{conditions: [condition]}]},\n        };\n\n        const qvm = new NaturalQueryVariablesManager();\n        qvm.set('variables', variables);\n\n        return timer(500).pipe(\n            switchMap(() => modelService.count(qvm).pipe(map(count => (count > 0 ? {duplicateValue: count} : null)))),\n        );\n    };\n}\n\n/**\n * Returns an async validator function that checks that the form control value is available\n *\n * Similar to `unique` validator, but allows to use a custom query for when the client does\n * not have permissions for `modelService.count()`.\n */\nexport function available(\n    getAvailableQuery: (value: string, excludedId: string | null) => Observable<boolean>,\n    excludedId: string | null = null,\n): AsyncValidatorFn {\n    return (control: AbstractControl): Observable<ValidationErrors | null> => {\n        if (!control.value || !control.dirty) {\n            return of(null);\n        }\n\n        return timer(500).pipe(\n            switchMap(() =>\n                getAvailableQuery(control.value, excludedId).pipe(\n                    map(isAvailable => (isAvailable ? null : {available: true})),\n                ),\n            ),\n        );\n    };\n}\n\n/**\n * Return all errors recursively for the given Form or control\n */\nexport function collectErrors(control: AbstractControl): ValidationErrors | null {\n    let errors: ValidationErrors | null = null;\n    if (control instanceof FormGroup || control instanceof FormArray) {\n        errors = Object.entries(control.controls).reduce((acc: ValidationErrors | null, [key, childControl]) => {\n            const childErrors = collectErrors(childControl);\n            if (childErrors) {\n                acc = {...acc, [key]: childErrors};\n            }\n            return acc;\n        }, null);\n    }\n\n    if (!errors) {\n        errors = control.errors;\n    }\n\n    return errors;\n}\n\n/**\n * Force validation of all form controls recursively.\n *\n * Recursively mark descending form tree as dirty and touched in order to show all invalid fields on demand.\n * Typically used when creating a new object and user clicked on create button but several fields were not\n * touched and are invalid.\n */\nexport function validateAllFormControls(control: AbstractControl): void {\n    control.markAsDirty({onlySelf: true});\n    control.markAsTouched({onlySelf: true});\n\n    if (control instanceof FormGroup || control instanceof FormArray) {\n        for (const [, child] of Object.entries(control.controls)) {\n            validateAllFormControls(child);\n        }\n    }\n}\n\nfunction isValid(status: FormControlStatus): status is 'VALID' {\n    return status === 'VALID';\n}\n\n/**\n * Emits exactly 0 or 1 time:\n *\n * - if the form is VALID, emits immediately\n * - if the form is PENDING emits if it changes from PENDING to VALID\n * - any other cases will **never** emit\n */\nexport function ifValid(control: AbstractControl): Observable<'VALID'> {\n    const observable = control.pending ? control.statusChanges.pipe(first()) : of(control.status);\n\n    return observable.pipe(filter(isValid));\n}\n\n// This is is an approximation of RFC_5322 where the hostname:\n//\n// - is too strict because it rejects IP address\n// - is too lax because it accepts pretty much anything else\n//\n// but the TLD will be validated against a whitelist so that should make the whole thing acceptable\nconst RFC_5322 = /^[a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[^@ ]+\\.[^@]+$/u;\n\n/**\n * Validate an email address according to RFC, and also that it is publicly deliverable (not \"root@localhost\" or \"root@127.0.0.1\")\n *\n * This is meant to replace **all** usages of Angular too permissive `Validators.email`\n */\nexport function deliverableEmail(control: AbstractControl): ValidationErrors | null {\n    // don't validate empty values to allow optional controls\n    const value = control.value;\n    if (!value) {\n        return null;\n    }\n\n    const error = {email: true};\n    if (value.length > 254) {\n        return error;\n    }\n\n    if (!RFC_5322.test(value)) {\n        return error;\n    }\n\n    const tld = value.split('.').pop();\n    if (!validTlds.includes(tld)) {\n        return error;\n    }\n\n    return null;\n}\n\n/**\n * Naive URL validator for \"normal\" web links, that is a bit too permissive\n *\n * It enforces:\n *\n *     - http/https protocol\n *     - one domain\n *     - one tld\n *\n * It allows:\n *\n *     - any number of subdomains\n *     - any parameters\n *     - any fragments\n *     - any characters for any parts (does not conform to rfc1738)\n */\nexport const urlValidator = Validators.pattern(/^https?:\\/\\/(?:[^.\\s]+\\.)+[^.\\s]+$/);\n\n/**\n * Validates that the value is an integer (non-float)\n */\nexport function integer(control: AbstractControl): ValidationErrors | null {\n    // Don't validate empty values to allow optional controls\n    if (control.value === null || control.value === undefined || control.value === '') {\n        return null;\n    }\n\n    return Number.isInteger(parseFloat(control.value)) ? null : {integer: true};\n}\n\n/**\n * Validate that the value is a decimal number with up to `scale` digits\n *\n * The error contains the expected scale, so that the error message can explain\n * it to the end-user.\n */\nexport function decimal(scale: number): ValidatorFn {\n    const regExp = new RegExp(`^-?\\\\d+(\\\\.\\\\d{0,${scale}})?$`);\n    return control => {\n        // Don't validate empty values to allow optional controls\n        if (control.value === null || control.value === undefined || control.value === '') {\n            return null;\n        }\n\n        const value = '' + control.value;\n        if (value.match(regExp)) {\n            return null;\n        }\n\n        return {decimal: scale};\n    };\n}\n\n/**\n * For internal use to avoid re-creating regexp on each call of `money`\n */\nconst twoDecimals = decimal(2);\n\n/**\n * Validate that the value is an amount of money, meaning a number with at most 2 decimals\n */\nexport function money(control: AbstractControl): ValidationErrors | null {\n    return twoDecimals(control) ? {money: true} : null;\n}\n"]}

package/esm2020/lib/directives/http-prefix.directive.mjs

@@ -0,0 +1,50 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { NaturalAbstractController } from '../classes/abstract-controller';
+import * as i0 from "@angular/core";
+/**
+ * Need to add  http:// prefix if we don't have prefix already AND we don't have part of it
+ */
+export function ensureHttpPrefix(value) {
+    if (!value) {
+        return value;
+    }
+    const completePrefix = /^(https?):\/\//i.test(value);
+    const startingPrefix = 'https://'.indexOf(value) === 0 || 'http://'.indexOf(value) === 0;
+    if (!completePrefix && !startingPrefix) {
+        return 'http://' + value;
+    }
+    else {
+        return value;
+    }
+}
+/**
+ * This directive only supports ReactiveForms due to ngModel/ngControl encapsulation and changes emissions.
+ */
+export class NaturalHttpPrefixDirective extends NaturalAbstractController {
+    constructor() {
+        super();
+        this.naturalHttpPrefix = null;
+    }
+    httpize($event) {
+        if (this.naturalHttpPrefix) {
+            const newValue = ensureHttpPrefix($event) || $event;
+            if ($event !== newValue) {
+                this.naturalHttpPrefix.setValue(newValue);
+            }
+        }
+    }
+}
+NaturalHttpPrefixDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalHttpPrefixDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+NaturalHttpPrefixDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: NaturalHttpPrefixDirective, selector: "[naturalHttpPrefix]", inputs: { naturalHttpPrefix: "naturalHttpPrefix" }, host: { listeners: { "ngModelChange": "httpize($event)" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalHttpPrefixDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[naturalHttpPrefix]',
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { naturalHttpPrefix: [{
+                type: Input
+            }], httpize: [{
+                type: HostListener,
+                args: ['ngModelChange', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/alert/alert.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { NaturalConfirmComponent } from './confirm.component';
+import * as i0 from "@angular/core";
+export class NaturalAlertModule {
+}
+NaturalAlertModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NaturalAlertModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertModule, declarations: [NaturalConfirmComponent], imports: [CommonModule, MatDialogModule, MatSnackBarModule, MatButtonModule] });
+NaturalAlertModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertModule, imports: [[CommonModule, MatDialogModule, MatSnackBarModule, MatButtonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [NaturalConfirmComponent],
+                    imports: [CommonModule, MatDialogModule, MatSnackBarModule, MatButtonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmF0dXJhbC9zcmMvbGliL21vZHVsZXMvYWxlcnQvYWxlcnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxFQUFDLGlCQUFpQixFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFDOUQsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0scUJBQXFCLENBQUM7O0FBTTVELE1BQU0sT0FBTyxrQkFBa0I7OytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFIWix1QkFBdUIsYUFDNUIsWUFBWSxFQUFFLGVBQWUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlO2dIQUVsRSxrQkFBa0IsWUFGbEIsQ0FBQyxZQUFZLEVBQUUsZUFBZSxFQUFFLGlCQUFpQixFQUFFLGVBQWUsQ0FBQzsyRkFFbkUsa0JBQWtCO2tCQUo5QixRQUFRO21CQUFDO29CQUNOLFlBQVksRUFBRSxDQUFDLHVCQUF1QixDQUFDO29CQUN2QyxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsZUFBZSxFQUFFLGlCQUFpQixFQUFFLGVBQWUsQ0FBQztpQkFDL0UiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtNYXRCdXR0b25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2J1dHRvbic7XG5pbXBvcnQge01hdERpYWxvZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGlhbG9nJztcbmltcG9ydCB7TWF0U25hY2tCYXJNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3NuYWNrLWJhcic7XG5pbXBvcnQge05hdHVyYWxDb25maXJtQ29tcG9uZW50fSBmcm9tICcuL2NvbmZpcm0uY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtOYXR1cmFsQ29uZmlybUNvbXBvbmVudF0sXG4gICAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgTWF0RGlhbG9nTW9kdWxlLCBNYXRTbmFja0Jhck1vZHVsZSwgTWF0QnV0dG9uTW9kdWxlXSxcbn0pXG5leHBvcnQgY2xhc3MgTmF0dXJhbEFsZXJ0TW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/modules/alert/alert.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { NaturalConfirmComponent } from './confirm.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/material/snack-bar";
+export class NaturalAlertService {
+    constructor(dialog, snackBar) {
+        this.dialog = dialog;
+        this.snackBar = snackBar;
+    }
+    /**
+     * Show an informative message in a snack bar
+     */
+    info(message, duration = 2500) {
+        return this.snackBar.open(message, undefined, {
+            duration: duration === null ? undefined : duration,
+            verticalPosition: 'top',
+            horizontalPosition: 'end',
+        });
+    }
+    /**
+     * Show an error in a snack bar
+     */
+    error(message, duration = 2500, action) {
+        return this.snackBar.open(message, action, {
+            duration: duration === null ? undefined : duration,
+            panelClass: ['snackbar-error'],
+            verticalPosition: 'top',
+            horizontalPosition: 'end',
+        });
+    }
+    /**
+     * Show a simple confirmation dialog and returns true if user confirmed it
+     */
+    confirm(title, message, confirmText, cancelText = $localize `Annuler`) {
+        const dialog = this.dialog.open(NaturalConfirmComponent, {
+            data: {
+                title: title,
+                message: message,
+                confirmText: confirmText,
+                cancelText: cancelText,
+            },
+        });
+        return dialog.afterClosed();
+    }
+}
+NaturalAlertService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertService, deps: [{ token: i1.MatDialog }, { token: i2.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalAlertService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalAlertService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.MatSnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwvc3JjL2xpYi9tb2R1bGVzL2FsZXJ0L2FsZXJ0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUl6QyxPQUFPLEVBQUMsdUJBQXVCLEVBQXFCLE1BQU0scUJBQXFCLENBQUM7Ozs7QUFLaEYsTUFBTSxPQUFPLG1CQUFtQjtJQUM1QixZQUFvQyxNQUFpQixFQUFtQixRQUFxQjtRQUF6RCxXQUFNLEdBQU4sTUFBTSxDQUFXO1FBQW1CLGFBQVEsR0FBUixRQUFRLENBQWE7SUFBRyxDQUFDO0lBRWpHOztPQUVHO0lBQ0ksSUFBSSxDQUFDLE9BQWUsRUFBRSxXQUEwQixJQUFJO1FBQ3ZELE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFNBQVMsRUFBRTtZQUMxQyxRQUFRLEVBQUUsUUFBUSxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxRQUFRO1lBQ2xELGdCQUFnQixFQUFFLEtBQUs7WUFDdkIsa0JBQWtCLEVBQUUsS0FBSztTQUM1QixDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsT0FBZSxFQUFFLFdBQTBCLElBQUksRUFBRSxNQUFlO1FBQ3pFLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRTtZQUN2QyxRQUFRLEVBQUUsUUFBUSxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxRQUFRO1lBQ2xELFVBQVUsRUFBRSxDQUFDLGdCQUFnQixDQUFDO1lBQzlCLGdCQUFnQixFQUFFLEtBQUs7WUFDdkIsa0JBQWtCLEVBQUUsS0FBSztTQUM1QixDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxPQUFPLENBQ1YsS0FBYSxFQUNiLE9BQWUsRUFDZixXQUFtQixFQUNuQixhQUFxQixTQUFTLENBQUEsU0FBUztRQUV2QyxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBdUQsdUJBQXVCLEVBQUU7WUFDM0csSUFBSSxFQUFFO2dCQUNGLEtBQUssRUFBRSxLQUFLO2dCQUNaLE9BQU8sRUFBRSxPQUFPO2dCQUNoQixXQUFXLEVBQUUsV0FBVztnQkFDeEIsVUFBVSxFQUFFLFVBQVU7YUFDekI7U0FDSixDQUFDLENBQUM7UUFFSCxPQUFPLE1BQU0sQ0FBQyxXQUFXLEVBQUUsQ0FBQztJQUNoQyxDQUFDOztnSEE3Q1EsbUJBQW1CO29IQUFuQixtQkFBbUIsY0FGaEIsTUFBTTsyRkFFVCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7TWF0RGlhbG9nfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaWFsb2cnO1xuaW1wb3J0IHtNYXRTbmFja0JhciwgTWF0U25hY2tCYXJSZWYsIFNpbXBsZVNuYWNrQmFyfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zbmFjay1iYXInO1xuaW1wb3J0IHtPYnNlcnZhYmxlfSBmcm9tICdyeGpzJztcbmltcG9ydCB7TmF0dXJhbENvbmZpcm1Db21wb25lbnQsIE5hdHVyYWxDb25maXJtRGF0YX0gZnJvbSAnLi9jb25maXJtLmNvbXBvbmVudCc7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIE5hdHVyYWxBbGVydFNlcnZpY2Uge1xuICAgIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IGRpYWxvZzogTWF0RGlhbG9nLCBwcml2YXRlIHJlYWRvbmx5IHNuYWNrQmFyOiBNYXRTbmFja0Jhcikge31cblxuICAgIC8qKlxuICAgICAqIFNob3cgYW4gaW5mb3JtYXRpdmUgbWVzc2FnZSBpbiBhIHNuYWNrIGJhclxuICAgICAqL1xuICAgIHB1YmxpYyBpbmZvKG1lc3NhZ2U6IHN0cmluZywgZHVyYXRpb246IG51bWJlciB8IG51bGwgPSAyNTAwKTogTWF0U25hY2tCYXJSZWY8U2ltcGxlU25hY2tCYXI+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuc25hY2tCYXIub3BlbihtZXNzYWdlLCB1bmRlZmluZWQsIHtcbiAgICAgICAgICAgIGR1cmF0aW9uOiBkdXJhdGlvbiA9PT0gbnVsbCA/IHVuZGVmaW5lZCA6IGR1cmF0aW9uLFxuICAgICAgICAgICAgdmVydGljYWxQb3NpdGlvbjogJ3RvcCcsXG4gICAgICAgICAgICBob3Jpem9udGFsUG9zaXRpb246ICdlbmQnLFxuICAgICAgICB9KTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBTaG93IGFuIGVycm9yIGluIGEgc25hY2sgYmFyXG4gICAgICovXG4gICAgcHVibGljIGVycm9yKG1lc3NhZ2U6IHN0cmluZywgZHVyYXRpb246IG51bWJlciB8IG51bGwgPSAyNTAwLCBhY3Rpb24/OiBzdHJpbmcpOiBNYXRTbmFja0JhclJlZjxTaW1wbGVTbmFja0Jhcj4ge1xuICAgICAgICByZXR1cm4gdGhpcy5zbmFja0Jhci5vcGVuKG1lc3NhZ2UsIGFjdGlvbiwge1xuICAgICAgICAgICAgZHVyYXRpb246IGR1cmF0aW9uID09PSBudWxsID8gdW5kZWZpbmVkIDogZHVyYXRpb24sXG4gICAgICAgICAgICBwYW5lbENsYXNzOiBbJ3NuYWNrYmFyLWVycm9yJ10sXG4gICAgICAgICAgICB2ZXJ0aWNhbFBvc2l0aW9uOiAndG9wJyxcbiAgICAgICAgICAgIGhvcml6b250YWxQb3NpdGlvbjogJ2VuZCcsXG4gICAgICAgIH0pO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIFNob3cgYSBzaW1wbGUgY29uZmlybWF0aW9uIGRpYWxvZyBhbmQgcmV0dXJucyB0cnVlIGlmIHVzZXIgY29uZmlybWVkIGl0XG4gICAgICovXG4gICAgcHVibGljIGNvbmZpcm0oXG4gICAgICAgIHRpdGxlOiBzdHJpbmcsXG4gICAgICAgIG1lc3NhZ2U6IHN0cmluZyxcbiAgICAgICAgY29uZmlybVRleHQ6IHN0cmluZyxcbiAgICAgICAgY2FuY2VsVGV4dDogc3RyaW5nID0gJGxvY2FsaXplYEFubnVsZXJgLFxuICAgICk6IE9ic2VydmFibGU8Ym9vbGVhbiB8IHVuZGVmaW5lZD4ge1xuICAgICAgICBjb25zdCBkaWFsb2cgPSB0aGlzLmRpYWxvZy5vcGVuPE5hdHVyYWxDb25maXJtQ29tcG9uZW50LCBOYXR1cmFsQ29uZmlybURhdGEsIGJvb2xlYW4+KE5hdHVyYWxDb25maXJtQ29tcG9uZW50LCB7XG4gICAgICAgICAgICBkYXRhOiB7XG4gICAgICAgICAgICAgICAgdGl0bGU6IHRpdGxlLFxuICAgICAgICAgICAgICAgIG1lc3NhZ2U6IG1lc3NhZ2UsXG4gICAgICAgICAgICAgICAgY29uZmlybVRleHQ6IGNvbmZpcm1UZXh0LFxuICAgICAgICAgICAgICAgIGNhbmNlbFRleHQ6IGNhbmNlbFRleHQsXG4gICAgICAgICAgICB9LFxuICAgICAgICB9KTtcblxuICAgICAgICByZXR1cm4gZGlhbG9nLmFmdGVyQ2xvc2VkKCk7XG4gICAgfVxufVxuIl19