@ecodev/natural 64.0.2 → 65.0.0

package/fesm2022/ecodev-natural-vanilla.mjs

@@ -1,1218 +0,0 @@
-import { mergeWith, defaultsDeep, defaults } from 'es-toolkit/compat';
-import { pickBy, cloneDeepWith, cloneDeep, uniq, groupBy, omit, merge, pick } from 'es-toolkit';
-import { switchMap, take, BehaviorSubject, throwError, from, ReplaySubject, Subject, debounceTime, raceWith, mergeMap, EMPTY, shareReplay, catchError, of, Observable, forkJoin, map, first, combineLatest } from 'rxjs';
-import { NavigationStart, NavigationEnd } from '@angular/router';
-import { filter, takeWhile, map as map$1, switchMap as switchMap$1, debounceTime as debounceTime$1, tap, shareReplay as shareReplay$1, startWith } from 'rxjs/operators';
-import { Apollo, gql } from 'apollo-angular';
-import { NetworkStatus } from '@apollo/client/core';
-import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
-import * as i0 from '@angular/core';
-import { Injectable, inject } from '@angular/core';
-
-function formatIsoDate(date) {
-    if (!date) {
-        return null;
-    }
-    const y = date.getFullYear();
-    const m = date.getMonth() + 1;
-    const d = date.getDate();
-    return y + '-' + (m < 10 ? '0' : '') + m + '-' + (d < 10 ? '0' : '') + d;
-}
-/**
- * Format a date and time in a way that will preserve the local time zone.
- * This allows the server side to know the day (without time) that was selected on client side.
- *
- * So something like: "2021-09-23T17:57:16+09:00"
- */
-function formatIsoDateTime(date) {
-    const timezoneOffsetInMinutes = date.getTimezoneOffset();
-    const timezoneOffsetInHours = -Math.trunc(timezoneOffsetInMinutes / 60); // UTC minus local time
-    const sign = timezoneOffsetInHours >= 0 ? '+' : '-';
-    const hoursLeadingZero = Math.abs(timezoneOffsetInHours) < 10 ? '0' : '';
-    const remainderMinutes = -(timezoneOffsetInMinutes % 60);
-    const minutesLeadingZero = Math.abs(remainderMinutes) < 10 ? '0' : '';
-    // It's a bit unfortunate that we need to construct a new Date instance,
-    // but we don't want the original Date instance to be modified
-    const correctedDate = new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-    correctedDate.setHours(date.getHours() + timezoneOffsetInHours);
-    const iso = correctedDate
-        .toISOString()
-        .replace(/\.\d{3}Z/, '')
-        .replace('Z', '');
-    return (iso +
-        sign +
-        hoursLeadingZero +
-        Math.abs(timezoneOffsetInHours).toString() +
-        ':' +
-        minutesLeadingZero +
-        remainderMinutes);
-}
-/**
- * Relations to full objects are converted to their IDs only.
- *
- * So {user: {id: 123}} becomes {user: 123}
- */
-function relationsToIds(object) {
-    const newObj = {};
-    Object.keys(object).forEach(key => {
-        let value = object[key];
-        if (value === null || value === undefined) {
-            // noop
-        }
-        else if (hasId(value)) {
-            value = value.id;
-        }
-        else if (Array.isArray(value)) {
-            value = value.map((i) => (hasId(i) ? i.id : i));
-        }
-        else if (typeof value === 'object' && !(value instanceof File) && !(value instanceof Date)) {
-            value = pickBy(value, (v, k) => k !== '__typename'); // omit(value, ['__typename']) ?
-        }
-        newObj[key] = value;
-    });
-    return newObj;
-}
-function hasId(value) {
-    return !!value && typeof value === 'object' && 'id' in value && !!value.id;
-}
-/**
- * Returns the plural form of the given name
- *
- * This is **not** necessarily valid english grammar. Its only purpose is for internal usage, not for humans.
- *
- * This **MUST** be kept in sync with `\Ecodev\Felix\Api\Plural:make()`.
- *
- * This is a bit performance-sensitive, so we should keep it fast and only cover cases that we actually need.
- */
-function makePlural(name) {
-    // Words ending in a y preceded by a vowel form their plurals by adding -s:
-    if (/[aeiou]y$/.exec(name)) {
-        return name + 's';
-    }
-    const plural = name + 's';
-    return plural.replace(/ys$/, 'ies').replace(/ss$/, 'ses').replace(/xs$/, 'xes');
-}
-/**
- * Returns the string with the first letter as capital
- */
-function upperCaseFirstLetter(term) {
-    return term.charAt(0).toUpperCase() + term.slice(1);
-}
-/**
- * Replace all attributes of first object with the ones provided by the second, but keeps the reference
- */
-function replaceObjectKeepingReference(obj, newObj) {
-    if (!obj || !newObj) {
-        return;
-    }
-    Object.keys(obj).forEach(key => {
-        delete obj[key];
-    });
-    Object.keys(newObj).forEach(key => {
-        obj[key] = newObj[key];
-    });
-}
-/**
- * Get contrasted color for text in the slider thumb
- * @param hexBgColor string in hexadecimals representing the background color
- */
-function getForegroundColor(hexBgColor) {
-    const rgb = hexToRgb(hexBgColor.slice(0, 7)); // splice remove alpha and consider only "visible" color at 100% alpha
-    const o = Math.round((rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000);
-    return o > 125 ? 'black' : 'white';
-}
-function hexToRgb(hex) {
-    // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
-    const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-    hex = hex.replace(shorthandRegex, (m, r, g, b) => {
-        return r + r + g + g + b + b;
-    });
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    return result
-        ? {
-            r: parseInt(result[1], 16),
-            g: parseInt(result[2], 16),
-            b: parseInt(result[3], 16),
-        }
-        : {
-            r: 0,
-            g: 0,
-            b: 0,
-        };
-}
-/**
- * Convert RGB color to hexadecimal color
- *
- * ```ts
- * rgbToHex('rgb(255, 00, 255)'); // '#FF00FF'
- * ```
- */
-function rgbToHex(rgb) {
-    const m = /^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/.exec(rgb);
-    if (!m) {
-        return rgb;
-    }
-    return '#' + [m[1], m[2], m[3]].map(x => parseInt(x).toString(16).toUpperCase().padStart(2, '0')).join('');
-}
-/**
- * Deep clone given values except for `File` that will be referencing the original value
- */
-function cloneDeepButSkipFile(value) {
-    return cloneDeepWith(value, v => (isFile(v) ? v : undefined));
-}
-function isFile(value) {
-    return ((typeof File !== 'undefined' && value instanceof File) ||
-        (typeof Blob !== 'undefined' && value instanceof Blob) ||
-        (typeof FileList !== 'undefined' && value instanceof FileList));
-}
-/**
- * During lodash.mergeWith, overrides arrays
- */
-function mergeOverrideArray(destValue, source) {
-    if (Array.isArray(source) || isFile(source)) {
-        return source;
-    }
-}
-/**
- * Copy text to clipboard.
- * Accepts line breaks `\n` as textarea do.
- */
-function copyToClipboard(document, text) {
-    const input = document.createElement('textarea');
-    document.body.append(input);
-    input.value = text;
-    input.select();
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    document.execCommand('copy');
-    document.body.removeChild(input);
-}
-function deepFreeze(o) {
-    Object.values(o).forEach(v => Object.isFrozen(v) || deepFreeze(v));
-    return Object.freeze(o);
-}
-/**
- * Return a valid PaginationInput from whatever is available from data. Invalid properties/types will be dropped.
- */
-function validatePagination(data) {
-    if (!data || typeof data !== 'object' || Array.isArray(data)) {
-        return null;
-    }
-    const pagination = {};
-    if ('offset' in data && (data.offset === null || typeof data.offset === 'number')) {
-        pagination.offset = data.offset;
-    }
-    if ('pageIndex' in data && (data.pageIndex === null || typeof data.pageIndex === 'number')) {
-        pagination.pageIndex = data.pageIndex;
-    }
-    if ('pageSize' in data && (data.pageSize === null || typeof data.pageSize === 'number')) {
-        pagination.pageSize = data.pageSize;
-    }
-    return pagination;
-}
-/**
- * Return a valid Sortings from whatever is available from data. Invalid properties/types will be dropped.
- */
-function validateSorting(data) {
-    if (!Array.isArray(data)) {
-        return null;
-    }
-    const result = [];
-    data.forEach(s => {
-        const r = validateOneSorting(s);
-        if (r) {
-            result.push(r);
-        }
-    });
-    return result;
-}
-function validateOneSorting(data) {
-    if (!data || typeof data !== 'object' || !('field' in data)) {
-        return null;
-    }
-    const sorting = { field: data.field };
-    if ('order' in data &&
-        (data.order === SortingOrder.ASC || data.order === SortingOrder.DESC || data.order === null)) {
-        sorting.order = data.order;
-    }
-    if ('nullAsHighest' in data && (data.nullAsHighest === null || typeof data.nullAsHighest === 'boolean')) {
-        sorting.nullAsHighest = data.nullAsHighest;
-    }
-    if ('emptyStringAsHighest' in data &&
-        (data.emptyStringAsHighest === null || typeof data.emptyStringAsHighest === 'boolean')) {
-        sorting.emptyStringAsHighest = data.emptyStringAsHighest;
-    }
-    return sorting;
-}
-/**
- * Return valid columns from whatever is available from data. Invalid properties/types will be dropped.
- */
-function validateColumns(data) {
-    if (typeof data !== 'string') {
-        return null;
-    }
-    return data.split(',').filter(string => string);
-}
-function onHistoryEvent(router) {
-    return router.events.pipe(filter(e => e instanceof NavigationStart && e.navigationTrigger === 'popstate'), switchMap(() => router.events.pipe(filter(e => e instanceof NavigationEnd), take(1))));
-}
-
-// Basic; loosely typed structure for graphql-doctrine filters
-// Logical operator to be used in conditions
-var LogicalOperator;
-(function (LogicalOperator) {
-    LogicalOperator["AND"] = "AND";
-    LogicalOperator["OR"] = "OR";
-})(LogicalOperator || (LogicalOperator = {}));
-// Join types to be used in DQL
-var JoinType;
-(function (JoinType) {
-    JoinType["innerJoin"] = "innerJoin";
-    JoinType["leftJoin"] = "leftJoin";
-})(JoinType || (JoinType = {}));
-
-function hasMixedGroupLogic(groups) {
-    // Complete lack of definition by fallback on AND operator
-    const completedGroups = cloneDeep(groups).map(group => {
-        if (!group.groupLogic) {
-            group.groupLogic = LogicalOperator.AND;
-        }
-        return group;
-    });
-    const groupLogics = uniq(Object.keys(groupBy(completedGroups.slice(1), group => group.groupLogic)));
-    return groupLogics.length > 1;
-}
-
-var SortingOrder;
-(function (SortingOrder) {
-    SortingOrder["ASC"] = "ASC";
-    SortingOrder["DESC"] = "DESC";
-})(SortingOrder || (SortingOrder = {}));
-/**
- * During lodash merge, concat arrays
- */
-function mergeConcatArray(destValue, source) {
-    if (isFile(source)) {
-        return source;
-    }
-    if (Array.isArray(source)) {
-        if (Array.isArray(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 a given aspect of the GUI (pagination, sorting, search, others ?).
- *
- * ```ts
- * 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 :
- *
- * ```ts
- * console.log(fm.variables.value); // {a : [1, 2, 3]}
- * ```
- *
- * Set new variables for 'componentA-variables':
- *
- * ```ts
- * fm.merge('componentA-variables', {a : [1, 2]});
- * console.log(fm.variables.value); // {a : [1, 2, 3]}
- * ```
- *
- * Set new variables for new channel:
- *
- * ```ts
- * fm.merge('componentB-variables', {a : [3, 4]});
- * console.log(fm.variables.value); // {a : [1, 2, 3, 4]}
- * ```
- */
-class NaturalQueryVariablesManager {
-    variables = new BehaviorSubject(undefined);
-    channels = new Map();
-    constructor(queryVariablesManager) {
-        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, cloneDeepButSkipFile(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 cloneDeepButSkipFile(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?.groups ? merged.filter.groups : [], channelVariables.filter.groups || []);
-                // Merge filter key (that contain groups)
-                if (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;
-    }
-}
-
-function bufferToHexa(hashBuffer) {
-    const hashArray = new Uint8Array(hashBuffer); // convert buffer to byte array
-    return hashArray.reduce((result, byte) => result + byte.toString(16).padStart(2, '0'), ''); // convert bytes to hex string
-}
-/**
- * Thin wrapper around browsers' native SubtleCrypto for convenience of use
- */
-async function sha256(message) {
-    const msgUint8 = new TextEncoder().encode(message); // encode as (utf-8) Uint8Array
-    const hashBuffer = await crypto.subtle.digest('SHA-256', msgUint8); // hash the message
-    return bufferToHexa(hashBuffer);
-}
-/**
- * Thin wrapper around browsers' native SubtleCrypto for convenience of use
- */
-async function hmacSha256(secret, payload) {
-    const encoder = new TextEncoder();
-    const algorithm = { name: 'HMAC', hash: 'SHA-256' };
-    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), algorithm, false, ['sign']);
-    const signature = await crypto.subtle.sign(algorithm.name, key, encoder.encode(payload));
-    return bufferToHexa(signature);
-}
-
-function getOperations(req) {
-    if (req.body instanceof FormData) {
-        const operations = req.body.get('operations');
-        if (typeof operations !== 'string') {
-            throw new Error('Cannot sign a GraphQL query that is using FormData but that is missing the key `operations`');
-        }
-        return operations;
-    }
-    else {
-        return JSON.stringify(req.body);
-    }
-}
-/**
- * Sign all HTTP POST requests that are GraphQL queries against `/graphql` endpoint with a custom signature.
- *
- * The server will validate the signature before executing the GraphQL query.
- */
-function graphqlQuerySigner(key) {
-    // Validates the configuration exactly 1 time (not for
-    // every query), and if not reject **all** HTTP requests
-    if (!key) {
-        return () => throwError(() => new Error('graphqlQuerySigner requires a non-empty key. Configure it in local.php under signedQueries.'));
-    }
-    return (req, next) => {
-        const mustSign = req.method === 'POST' && /\/graphql(\?|$)/.exec(req.url);
-        if (!mustSign) {
-            return next(req);
-        }
-        const operations = getOperations(req);
-        const timestamp = Math.round(Date.now() / 1000);
-        const payload = timestamp + operations;
-        return from(hmacSha256(key, payload)).pipe(switchMap(hash => {
-            const header = `v1.${timestamp}.${hash}`;
-            const signedRequest = req.clone({
-                headers: req.headers.set('X-Signature', header),
-            });
-            return next(signedRequest);
-        }));
-    };
-}
-
-/**
- * Debounce subscriptions to update mutations, with the possibility to cancel one, flush one, or flush all of them.
- *
- * `modelService` is also used to separate objects by their types. So User with ID 1 is not confused with Product with ID 1.
- *
- * `id` must be the ID of the object that will be updated.
- */
-class NaturalDebounceService {
-    /**
-     * Stores the debounced update function
-     */
-    allDebouncedUpdateCache = new Map();
-    /**
-     * Debounce the `modelService.updateNow()` mutation for a short time. If called multiple times with the same
-     * modelService and id, it will postpone the subscription to the mutation.
-     *
-     * All input variables for the same object (same service and ID) will be cumulated over time. So it is possible
-     * to update `field1`, then `field2`, and they will be batched into a single XHR including `field1` and `field2`.
-     *
-     * But it will always keep the same debouncing timeline.
-     */
-    debounce(modelService, id, object) {
-        const debouncedUpdateCache = this.getMap(modelService);
-        let debounced = debouncedUpdateCache.get(id);
-        if (debounced) {
-            debounced.object = {
-                ...debounced.object,
-                ...object,
-            };
-        }
-        else {
-            const debouncer = new ReplaySubject(1);
-            let wasCancelled = false;
-            const canceller = new Subject();
-            canceller.subscribe(() => {
-                wasCancelled = true;
-                debouncer.complete();
-                canceller.complete();
-                this.delete(modelService, id);
-            });
-            const flusher = new Subject();
-            debounced = {
-                object,
-                debouncer,
-                canceller,
-                flusher,
-                modelService: modelService,
-                result: debouncer.pipe(debounceTime(2000), // Wait 2 seconds...
-                raceWith(flusher), // ...unless flusher is triggered
-                take(1), mergeMap(() => {
-                    this.delete(modelService, id);
-                    if (wasCancelled || !debounced) {
-                        return EMPTY;
-                    }
-                    return modelService.updateNow(debounced.object);
-                }), shareReplay()),
-            };
-            debouncedUpdateCache.set(id, debounced);
-        }
-        // Notify our debounced update each time we ask to update
-        debounced.debouncer.next();
-        // Return and observable that is updated when mutation is done
-        return debounced.result;
-    }
-    cancelOne(modelService, id) {
-        const debounced = this.allDebouncedUpdateCache.get(modelService)?.get(id);
-        debounced?.canceller.next();
-    }
-    /**
-     * Immediately execute the pending update, if any.
-     *
-     * It should typically be called before resolving the object, to mutate it before re-fetching it from server.
-     *
-     * The returned observable will complete when the update completes, even if it errors.
-     */
-    flushOne(modelService, id) {
-        const debounced = this.allDebouncedUpdateCache.get(modelService)?.get(id);
-        return this.internalFlush(debounced ? [debounced] : []);
-    }
-    /**
-     * Immediately execute all pending updates.
-     *
-     * It should typically be called before login out.
-     *
-     * The returned observable will complete when all updates complete, even if some of them error.
-     */
-    flush() {
-        const all = [];
-        this.allDebouncedUpdateCache.forEach(map => map.forEach(debounced => all.push(debounced)));
-        return this.internalFlush(all);
-    }
-    internalFlush(debounceds) {
-        const all = [];
-        const allFlusher = [];
-        debounceds.forEach(debounced => {
-            all.push(debounced.result.pipe(catchError(() => of(undefined))));
-            allFlusher.push(debounced.flusher);
-        });
-        if (!all.length) {
-            all.push(of(undefined));
-        }
-        return new Observable(subscriber => {
-            const subscription = forkJoin(all)
-                .pipe(map(() => undefined))
-                .subscribe(subscriber);
-            // Flush only after subscription process is finished
-            allFlusher.forEach(flusher => flusher.next());
-            return subscription;
-        });
-    }
-    /**
-     * Count of pending updates
-     */
-    get count() {
-        let count = 0;
-        this.allDebouncedUpdateCache.forEach(map => (count += map.size));
-        return count;
-    }
-    getMap(modelService) {
-        let debouncedUpdateCache = this.allDebouncedUpdateCache.get(modelService);
-        if (!debouncedUpdateCache) {
-            debouncedUpdateCache = new Map();
-            this.allDebouncedUpdateCache.set(modelService, debouncedUpdateCache);
-        }
-        return debouncedUpdateCache;
-    }
-    delete(modelService, id) {
-        const map = this.allDebouncedUpdateCache.get(modelService);
-        if (!map) {
-            return;
-        }
-        map.delete(id);
-        if (!map.size) {
-            this.allDebouncedUpdateCache.delete(modelService);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: NaturalDebounceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: NaturalDebounceService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.0", ngImport: i0, type: NaturalDebounceService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-/**
- * Lookup a facet by its `name` and then by its `field`, or return null if not found
- */
-function getFacetFromSelection(facets, selection) {
-    if (!facets) {
-        return null;
-    }
-    return (facets.find(facet => facet.name != null && facet.name === selection.name) ||
-        facets.find(facet => facet.field === selection.field) ||
-        null);
-}
-/**
- * Deep clone a literal via JSON serializing/unserializing
- *
- * It will **not** work with:
- *
- *     - functions (will be removed)
- *     - `undefined` (will be removed)
- *     - cyclic references (will crash)
- *     - objects (will be converted to `{}`)
- */
-function deepClone(obj) {
-    return JSON.parse(JSON.stringify(obj));
-}
-
-class NaturalAbstractModelService {
-    name;
-    oneQuery;
-    allQuery;
-    createMutation;
-    updateMutation;
-    deleteMutation;
-    createName;
-    updateName;
-    deleteName;
-    /**
-     * Store the creation mutations that are pending
-     */
-    creatingCache = new Map();
-    apollo = inject(Apollo);
-    naturalDebounceService = inject(NaturalDebounceService);
-    plural;
-    /**
-     *
-     * @param name service and single object query name (eg. userForFront or user).
-     * @param oneQuery GraphQL query to fetch a single object from ID (eg. userForCrudQuery).
-     * @param allQuery GraphQL query to fetch a filtered list of objects (eg. usersForCrudQuery).
-     * @param createMutation GraphQL mutation to create an object.
-     * @param updateMutation GraphQL mutation to update an object.
-     * @param deleteMutation GraphQL mutation to delete a list of objects.
-     * @param plural list query name (eg. usersForFront or users).
-     * @param createName create object mutation name (eg. createUser).
-     * @param updateName update object mutation name (eg. updateUser).
-     * @param deleteName delete object mutation name (eg. deleteUsers).
-     */
-    constructor(name, oneQuery, allQuery, createMutation, updateMutation, deleteMutation, plural = null, createName = null, updateName = null, deleteName = null) {
-        this.name = name;
-        this.oneQuery = oneQuery;
-        this.allQuery = allQuery;
-        this.createMutation = createMutation;
-        this.updateMutation = updateMutation;
-        this.deleteMutation = deleteMutation;
-        this.createName = createName;
-        this.updateName = updateName;
-        this.deleteName = deleteName;
-        this.plural = plural ?? makePlural(this.name);
-    }
-    /**
-     * List of individual fields validators
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getFormValidators(model) {
-        return {};
-    }
-    /**
-     * List of individual async fields validators
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getFormAsyncValidators(model) {
-        return {};
-    }
-    /**
-     * List of grouped fields validators (like password + confirm password)
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getFormGroupValidators(model) {
-        return [];
-    }
-    /**
-     * List of async group fields validators (like unique constraint on multiple columns)
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getFormGroupAsyncValidators(model) {
-        return [];
-    }
-    getFormConfig(model) {
-        const values = { ...this.getDefaultForServer(), ...this.getFormExtraFieldDefaultValues() };
-        const validators = this.getFormValidators(model);
-        const asyncValidators = this.getFormAsyncValidators(model);
-        const controls = {};
-        const disabled = model.permissions ? !model.permissions.update : false;
-        if (model.id) {
-            controls.id = new UntypedFormControl({ value: model.id, disabled: true });
-        }
-        // Configure form for each field of model
-        for (const key of Object.keys(values)) {
-            const value = model[key] !== undefined ? model[key] : values[key];
-            const formState = {
-                value: value,
-                disabled: disabled,
-            };
-            const validator = typeof validators[key] !== 'undefined' ? validators[key] : null;
-            const asyncValidator = typeof asyncValidators[key] !== 'undefined' ? asyncValidators[key] : null;
-            controls[key] = new UntypedFormControl(formState, validator, asyncValidator);
-        }
-        // Configure form for extra validators that are not on a specific field
-        for (const key of Object.keys(validators)) {
-            if (!controls[key]) {
-                const formState = {
-                    value: model[key] ? model[key] : null,
-                    disabled: disabled,
-                };
-                controls[key] = new UntypedFormControl(formState, validators[key]);
-            }
-        }
-        for (const key of Object.keys(asyncValidators)) {
-            if (controls[key] && asyncValidators[key]) {
-                controls[key].setAsyncValidators(asyncValidators[key]);
-            }
-            else {
-                const formState = {
-                    value: model[key] ? model[key] : null,
-                    disabled: disabled,
-                };
-                controls[key] = new UntypedFormControl(formState, null, asyncValidators[key]);
-            }
-        }
-        return controls;
-    }
-    /**
-     * Create the final FormGroup for the object, including all validators
-     *
-     * This method should **not** be overridden, but instead `getFormConfig`,
-     * `getFormGroupValidators`, `getFormGroupAsyncValidators` might be.
-     */
-    getFormGroup(model) {
-        const formConfig = this.getFormConfig(deepClone(model));
-        return new UntypedFormGroup(formConfig, {
-            validators: this.getFormGroupValidators(model),
-            asyncValidators: this.getFormGroupAsyncValidators(model),
-        });
-    }
-    /**
-     * Get a single object
-     *
-     * If available it will emit object from cache immediately, then it
-     * will **always** fetch from network and then the observable will be completed.
-     *
-     * You must subscribe to start getting results (and fetch from network).
-     */
-    getOne(id) {
-        return this.prepareOneQuery(id, 'cache-and-network').pipe(takeWhile(result => result.networkStatus !== NetworkStatus.ready, true), map$1(result => result.data[this.name]));
-    }
-    /**
-     * Watch a single object
-     *
-     * If available it will emit object from cache immediately, then it
-     * will **always** fetch from network, and then keep watching the cache forever.
-     *
-     * You must subscribe to start getting results (and fetch from network).
-     *
-     * You **MUST** unsubscribe.
-     */
-    watchOne(id, fetchPolicy = 'cache-and-network') {
-        return this.prepareOneQuery(id, fetchPolicy).pipe(map$1(result => result.data[this.name]));
-    }
-    prepareOneQuery(id, fetchPolicy) {
-        this.throwIfObservable(id);
-        this.throwIfNotQuery(this.oneQuery);
-        return this.getVariablesForOne(id).pipe(switchMap$1(variables => {
-            this.throwIfNotQuery(this.oneQuery);
-            return this.apollo.watchQuery({
-                query: this.oneQuery,
-                variables: variables,
-                fetchPolicy: fetchPolicy,
-                nextFetchPolicy: 'cache-only',
-            }).valueChanges;
-        }), filter(result => !!result.data));
-    }
-    /**
-     * Get a collection of objects
-     *
-     * It will **always** fetch from network and then the observable will be completed.
-     * No cache is ever used, so it's slow but correct.
-     */
-    getAll(queryVariablesManager) {
-        this.throwIfNotQuery(this.allQuery);
-        return this.getPartialVariablesForAll().pipe(first(), switchMap$1(partialVariables => {
-            this.throwIfNotQuery(this.allQuery);
-            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
-            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
-            manager.merge('partial-variables', partialVariables);
-            return this.apollo.query({
-                query: this.allQuery,
-                variables: manager.variables.value,
-                fetchPolicy: 'network-only',
-            });
-        }), this.mapAll());
-    }
-    /**
-     * Get a collection of objects
-     *
-     * Every time the observable variables change, and they are not undefined,
-     * it will return result from cache, then it will **always** fetch from network,
-     * and then keep watching the cache forever.
-     *
-     * You must subscribe to start getting results (and fetch from network).
-     *
-     * You **MUST** unsubscribe.
-     */
-    watchAll(queryVariablesManager, fetchPolicy = 'cache-and-network') {
-        this.throwIfNotQuery(this.allQuery);
-        return combineLatest({
-            variables: queryVariablesManager.variables.pipe(
-            // Ignore very fast variable changes
-            debounceTime$1(20), 
-            // Wait for variables to be defined to prevent duplicate query: with and without variables
-            // Null is accepted value for "no variables"
-            filter(variables => typeof variables !== 'undefined')),
-            partialVariables: this.getPartialVariablesForAll(),
-        }).pipe(switchMap$1(result => {
-            // Apply partial variables from service
-            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
-            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
-            manager.merge('partial-variables', result.partialVariables);
-            this.throwIfNotQuery(this.allQuery);
-            return this.apollo
-                .watchQuery({
-                query: this.allQuery,
-                variables: manager.variables.value,
-                fetchPolicy: fetchPolicy,
-            })
-                .valueChanges.pipe(catchError(() => EMPTY), filter(r => !!r.data), this.mapAll());
-        }));
-    }
-    /**
-     * This functions allow to quickly create or update objects.
-     *
-     * Manages a "creation is pending" status, and update when creation is ready.
-     * Uses regular update/updateNow and create methods.
-     * Used mainly when editing multiple objects in same controller (like in editable arrays)
-     */
-    createOrUpdate(object, now = false) {
-        this.throwIfObservable(object);
-        this.throwIfNotQuery(this.createMutation);
-        this.throwIfNotQuery(this.updateMutation);
-        // If creation is pending, listen to creation observable and when ready, fire update
-        const pendingCreation = this.creatingCache.get(object);
-        if (pendingCreation) {
-            return pendingCreation.pipe(switchMap$1(created => {
-                return this.update({
-                    id: created.id,
-                    ...object,
-                });
-            }));
-        }
-        // If object has Id, just save it
-        if ('id' in object && object.id) {
-            if (now) {
-                // used mainly for tests, because lodash debounced used in update() does not work fine with fakeAsync and tick()
-                return this.updateNow(object);
-            }
-            else {
-                return this.update(object);
-            }
-        }
-        // If object was not saving, and has no ID, create it
-        const creation = this.create(object).pipe(tap(() => {
-            this.creatingCache.delete(object); // remove from cache
-        }));
-        // stores creating observable in a cache replayable version of the observable,
-        // so several update() can subscribe to the same creation
-        this.creatingCache.set(object, creation.pipe(shareReplay$1()));
-        return creation;
-    }
-    /**
-     * Create an object in DB and then refetch the list of objects
-     */
-    create(object) {
-        this.throwIfObservable(object);
-        this.throwIfNotQuery(this.createMutation);
-        const variables = merge({ input: this.getInput(object, true) }, this.getPartialVariablesForCreation(object));
-        return this.apollo
-            .mutate({
-            mutation: this.createMutation,
-            variables: variables,
-        })
-            .pipe(map$1(result => {
-            this.apollo.client.reFetchObservableQueries();
-            return this.mapCreation(result);
-        }));
-    }
-    /**
-     * Update an object, after a short debounce
-     */
-    update(object) {
-        this.throwIfObservable(object);
-        this.throwIfNotQuery(this.updateMutation);
-        // Keep a single instance of the debounced update function
-        const id = object.id;
-        return this.naturalDebounceService.debounce(this, id, object);
-    }
-    /**
-     * Update an object immediately when subscribing
-     */
-    updateNow(object) {
-        this.throwIfObservable(object);
-        this.throwIfNotQuery(this.updateMutation);
-        const variables = merge({
-            id: object.id,
-            input: this.getInput(object, false),
-        }, this.getPartialVariablesForUpdate(object));
-        return this.apollo
-            .mutate({
-            mutation: this.updateMutation,
-            variables: variables,
-        })
-            .pipe(map$1(result => {
-            this.apollo.client.reFetchObservableQueries();
-            return this.mapUpdate(result);
-        }));
-    }
-    /**
-     * Delete objects and then refetch the list of objects
-     */
-    delete(objects) {
-        this.throwIfObservable(objects);
-        this.throwIfNotQuery(this.deleteMutation);
-        const ids = objects.map(o => {
-            // Cancel pending update
-            this.naturalDebounceService.cancelOne(this, o.id);
-            return o.id;
-        });
-        const variables = merge({
-            ids: ids,
-        }, this.getPartialVariablesForDelete(objects));
-        return this.apollo
-            .mutate({
-            mutation: this.deleteMutation,
-            variables: variables,
-        })
-            .pipe(
-        // Delay the observable until Apollo refetch is completed
-        switchMap$1(result => {
-            const mappedResult = this.mapDelete(result);
-            return from(this.apollo.client.reFetchObservableQueries()).pipe(map$1(() => mappedResult));
-        }));
-    }
-    /**
-     * If the id is provided, resolves an observable model. The observable model will only be emitted after we are sure
-     * that Apollo cache is fresh and warm. Then the component can subscribe to the observable model to get the model
-     * immediately from Apollo cache and any subsequents future mutations that may happen to Apollo cache.
-     *
-     * Without id, returns default values, in order to show a creation form.
-     */
-    resolve(id) {
-        if (id) {
-            const onlyNetwork = this.watchOne(id, 'network-only').pipe(first());
-            const onlyCache = this.watchOne(id, 'cache-first');
-            // In theory, we can rely on Apollo Cache to return a result instantly. It is very fast indeed,
-            // but it is still asynchronous, so there may be a very short time when we don't have the model
-            // available. To fix that, we can rely on RxJS, which is able to emit synchronously the value we just
-            // got from server. Once Apollo Client moves to RxJS (https://github.com/apollographql/apollo-feature-requests/issues/375),
-            // we could try to remove `startWith()`.
-            return onlyNetwork.pipe(map$1(firstValue => onlyCache.pipe(startWith(firstValue))));
-        }
-        else {
-            return of(of(this.getDefaultForServer()));
-        }
-    }
-    /**
-     * Return an object that match the GraphQL input type.
-     * It creates an object with manually filled data and add uncompleted data (like required attributes that can be empty strings)
-     */
-    getInput(object, forCreation) {
-        // Convert relations to their IDs for mutation
-        object = relationsToIds(object);
-        // Pick only attributes that we can find in the empty object
-        // In other words, prevent to select data that has unwanted attributes
-        const emptyObject = this.getDefaultForServer();
-        let input = pick(object, Object.keys(emptyObject));
-        // Complete a potentially uncompleted object with default values
-        if (forCreation) {
-            input = defaults(input, emptyObject);
-        }
-        return input;
-    }
-    /**
-     * Return the number of objects matching the query. It may never complete.
-     *
-     * This is used for the unique validator
-     */
-    count(queryVariablesManager) {
-        const queryName = 'Count' + upperCaseFirstLetter(this.plural);
-        const filterType = upperCaseFirstLetter(this.name) + 'Filter';
-        const query = gql `
-            query ${queryName} ($filter: ${filterType}) {
-            count: ${this.plural} (filter: $filter, pagination: {pageSize: 0, pageIndex: 0}) {
-            length
-            }
-            }`;
-        return this.getPartialVariablesForAll().pipe(switchMap$1(partialVariables => {
-            // Copy manager to prevent to apply internal variables to external QueryVariablesManager
-            const manager = new NaturalQueryVariablesManager(queryVariablesManager);
-            manager.merge('partial-variables', partialVariables);
-            return this.apollo.query({
-                query: query,
-                variables: manager.variables.value,
-                fetchPolicy: 'network-only',
-            });
-        }), map$1(result => result.data.count.length));
-    }
-    /**
-     * Return empty object with some default values from server perspective
-     *
-     * This is typically useful when showing a form for creation
-     */
-    getDefaultForServer() {
-        return {};
-    }
-    /**
-     * You probably **should not** use this.
-     *
-     * If you are trying to *call* this method, instead you probably want to call `getDefaultForServer()` to get default
-     * values for a model, or `getFormConfig()` to get a configured form that includes extra form fields.
-     *
-     * If you are trying to *override* this method, instead you probably want to override `getDefaultForServer()`.
-     *
-     * The only and **very rare** reason to override this method is if the client needs extra form fields that cannot be
-     * accepted by the server (not part of `XXXInput` type) and that are strictly for the client form needs. In that case,
-     * then you can return default values for those extra form fields, and the form returned by `getFormConfig()` will
-     * include those extra fields.
-     */
-    getFormExtraFieldDefaultValues() {
-        return {};
-    }
-    /**
-     * This is used to extract only the array of fetched objects out of the entire fetched data
-     */
-    mapAll() {
-        return map$1(result => result.data[this.plural]); // See https://github.com/apollographql/apollo-client/issues/5662
-    }
-    /**
-     * This is used to extract only the created object out of the entire fetched data
-     */
-    mapCreation(result) {
-        const name = this.createName ?? 'create' + upperCaseFirstLetter(this.name);
-        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
-    }
-    /**
-     * This is used to extract only the updated object out of the entire fetched data
-     */
-    mapUpdate(result) {
-        const name = this.updateName ?? 'update' + upperCaseFirstLetter(this.name);
-        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
-    }
-    /**
-     * This is used to extract only flag when deleting an object
-     */
-    mapDelete(result) {
-        const name = this.deleteName ?? 'delete' + upperCaseFirstLetter(this.plural);
-        return result.data[name]; // See https://github.com/apollographql/apollo-client/issues/5662
-    }
-    /**
-     * Returns additional variables to be used when getting a single object
-     *
-     * This is typically a site or state ID, and is needed to get appropriate access rights
-     */
-    getPartialVariablesForOne() {
-        return of({});
-    }
-    /**
-     * Returns additional variables to be used when getting multiple objects
-     *
-     * This is typically a site or state ID, but it could be something else to further filter the query
-     */
-    getPartialVariablesForAll() {
-        return of({});
-    }
-    /**
-     * Returns additional variables to be used when creating an object
-     *
-     * This is typically a site or state ID
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getPartialVariablesForCreation(object) {
-        return {};
-    }
-    /**
-     * Returns additional variables to be used when updating an object
-     *
-     * This is typically a site or state ID
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getPartialVariablesForUpdate(object) {
-        return {};
-    }
-    /**
-     * Return additional variables to be used when deleting an object
-     *
-     * This is typically a site or state ID
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    getPartialVariablesForDelete(objects) {
-        return {};
-    }
-    /**
-     * Throw exception to prevent executing queries with invalid variables
-     */
-    throwIfObservable(value) {
-        if (value instanceof Observable) {
-            throw new Error('Cannot use Observable as variables. Instead you should use .subscribe() to call the method with a real value');
-        }
-    }
-    /**
-     * Merge given ID with additional partial variables if there is any
-     */
-    getVariablesForOne(id) {
-        return this.getPartialVariablesForOne().pipe(map$1(partialVariables => merge({ id: id }, partialVariables)));
-    }
-    /**
-     * Throw exception to prevent executing null queries
-     */
-    throwIfNotQuery(query) {
-        if (!query) {
-            throw new Error('GraphQL query for this method was not configured in this service constructor');
-        }
-    }
-}
-
-/**
- * **DO NOT MODIFY UNLESS STRICTLY REQUIRED FOR VANILLA**
- *
- * This is a minimal service specialized for Vanilla and any modification,
- * including adding `import` in this file, might break https://navigations.ichtus.club.
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { NaturalAbstractModelService, NaturalQueryVariablesManager, formatIsoDateTime, graphqlQuerySigner };
-//# sourceMappingURL=ecodev-natural-vanilla.mjs.map