@ecodev/natural 41.3.0 → 42.0.0

package/esm2020/lib/services/enum.service.mjs

@@ -0,0 +1,67 @@
+import { gql } from 'apollo-angular';
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+const enumTypeQuery = gql `
+    query EnumType($name: String!) {
+        __type(name: $name) {
+            __typename
+            enumValues {
+                name
+                description
+            }
+        }
+    }
+`;
+export class NaturalEnumService {
+    constructor(apollo) {
+        this.apollo = apollo;
+    }
+    /**
+     * Return a list of observable enumerables considering the given name
+     */
+    get(name) {
+        // Load possible action statuses
+        return this.apollo
+            .query({
+            query: enumTypeQuery,
+            variables: { name: name },
+            fetchPolicy: 'cache-first',
+        })
+            .pipe(map(result => {
+            const values = [];
+            if (result.data.__type && result.data.__type.enumValues) {
+                for (const enumValue of result.data.__type.enumValues) {
+                    values.push({
+                        value: enumValue.name,
+                        name: enumValue.description || '',
+                    });
+                }
+            }
+            return values;
+        }));
+    }
+    /**
+     * Returns the enum user-friendly name, instead of its value.
+     */
+    getValueName(value, enumName) {
+        return this.get(enumName).pipe(map(values => {
+            for (const v of values) {
+                if (v.value === value) {
+                    return v.name;
+                }
+            }
+            return '';
+        }));
+    }
+}
+NaturalEnumService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumService, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalEnumService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalEnumService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/link-mutation.service.mjs

@@ -0,0 +1,153 @@
+import { gql } from 'apollo-angular';
+import { Injectable } from '@angular/core';
+import { clone } from 'lodash-es';
+import { forkJoin, of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { upperCaseFirstLetter } from '../classes/utility';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+/**
+ * Query to get list of mutations
+ */
+const queriesQuery = gql `
+    query Mutations {
+        __type(name: "Mutation") {
+            fields {
+                name
+                args {
+                    name
+                    type {
+                        ofType {
+                            name
+                        }
+                    }
+                }
+            }
+        }
+    }
+`;
+export class NaturalLinkMutationService {
+    constructor(apollo) {
+        this.apollo = apollo;
+    }
+    /**
+     * Link two objects together
+     */
+    link(obj1, obj2, otherName = null, variables = {}) {
+        // clone prevents to affect the original reference
+        const clonedVariables = clone(variables);
+        return this.getMutation('link', obj1, obj2, otherName, clonedVariables).pipe(switchMap(mutation => this.execute(mutation)));
+    }
+    /**
+     * Link many objects
+     */
+    linkMany(obj1, objects, otherName = null, variables = {}) {
+        return forkJoin(objects.map(obj2 => this.link(obj1, obj2, otherName, variables)));
+    }
+    /**
+     * Unlink two objects
+     */
+    unlink(obj1, obj2, otherName = null) {
+        return this.getMutation('unlink', obj1, obj2, otherName).pipe(switchMap(mutation => this.execute(mutation)));
+    }
+    /**
+     * Return the list of all available mutation names
+     */
+    getAllMutationNames() {
+        if (this.allMutations) {
+            return of(this.allMutations);
+        }
+        const mapArg = (arg) => {
+            return {
+                name: arg.name,
+                type: arg.type?.ofType?.name?.replace(/ID$/, '') || 'should-never-happen',
+            };
+        };
+        return this.apollo
+            .query({
+            query: queriesQuery,
+            fetchPolicy: 'cache-first',
+        })
+            .pipe(map(({ data }) => {
+            if (data.__type && data.__type.fields) {
+                this.allMutations = data.__type.fields
+                    .filter(v => v.name.match(/^(link|unlink)/))
+                    .map(v => {
+                    return {
+                        name: v.name,
+                        arg1: mapArg(v.args[0]),
+                        arg2: mapArg(v.args[1]),
+                    };
+                });
+            }
+            else {
+                this.allMutations = [];
+            }
+            return this.allMutations;
+        }));
+    }
+    /**
+     * Generate mutation using patterns and replacing variables
+     */
+    getMutation(action, obj1, obj2, otherName, variables = {}) {
+        otherName = otherName ? upperCaseFirstLetter(otherName) : otherName;
+        const mutationName = action + obj1.__typename + (otherName || obj2.__typename);
+        const reversedMutationName = action + obj2.__typename + (otherName || obj1.__typename);
+        return this.getAllMutationNames().pipe(map(allMutationNames => {
+            const mutation = allMutationNames.find(mut => mut.name === mutationName) ||
+                allMutationNames.find(mut => mut.name === reversedMutationName);
+            if (mutation) {
+                return this.buildTemplate(mutation, obj1, obj2, variables);
+            }
+            throw TypeError('API does not allow to ' + action + ' ' + obj1.__typename + ' and ' + obj2.__typename);
+        }));
+    }
+    /**
+     * Execute mutation
+     */
+    execute(mutation) {
+        return this.apollo
+            .mutate({
+            mutation: gql(mutation),
+        })
+            .pipe(map(r => {
+            this.apollo.client.reFetchObservableQueries();
+            return r;
+        }));
+    }
+    /**
+     * Build the actual mutation string
+     */
+    buildTemplate(mutation, obj1, obj2, variables = {}) {
+        let name1;
+        let name2;
+        if (obj1.__typename === mutation.arg1.type) {
+            name1 = mutation.arg1.name;
+            name2 = mutation.arg2.name;
+        }
+        else {
+            name1 = mutation.arg2.name;
+            name2 = mutation.arg1.name;
+        }
+        variables[name1] = obj1.id;
+        variables[name2] = obj2.id;
+        let serializedVariables = '';
+        for (const key of Object.keys(variables)) {
+            serializedVariables += key + ': ' + JSON.stringify(variables[key]) + ' ';
+        }
+        return `mutation linkAndUnlink {
+            ${mutation.name}(${serializedVariables}) {
+                id
+            }
+        }`;
+    }
+}
+NaturalLinkMutationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalLinkMutationService, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalLinkMutationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalLinkMutationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalLinkMutationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link-mutation.service.js","sourceRoot":"","sources":["../../../../../projects/natural/src/lib/services/link-mutation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Apollo, gql} from 'apollo-angular';\nimport {FetchResult} from '@apollo/client/core';\nimport {Injectable} from '@angular/core';\n\nimport {clone} from 'lodash-es';\nimport {forkJoin, Observable, of} from 'rxjs';\nimport {map, switchMap} from 'rxjs/operators';\nimport {Literal} from '../types/types';\nimport {upperCaseFirstLetter} from '../classes/utility';\n\n/**\n * Query to get list of mutations\n */\nconst queriesQuery = gql`\n    query Mutations {\n        __type(name: \"Mutation\") {\n            fields {\n                name\n                args {\n                    name\n                    type {\n                        ofType {\n                            name\n                        }\n                    }\n                }\n            }\n        }\n    }\n`;\n\ntype IntrospectedArg = {\n    name: string;\n    type: {\n        ofType: null | {\n            name: null | string;\n        };\n    };\n};\n\ninterface IntrospectedMutations {\n    __type: null | {\n        fields: null | Array<{\n            name: string;\n            args: Array<IntrospectedArg>;\n        }>;\n    };\n}\n\nexport interface LinkableObject {\n    id: string;\n    __typename: string;\n}\n\ninterface MutationArg {\n    name: string;\n    type: string;\n}\n\ninterface Mutation {\n    name: string;\n    arg1: MutationArg;\n    arg2: MutationArg;\n}\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class NaturalLinkMutationService {\n    /**\n     * Receives the list of available mutations\n     */\n    private allMutations?: Mutation[];\n\n    public constructor(private readonly apollo: Apollo) {}\n\n    /**\n     * Link two objects together\n     */\n    public link(\n        obj1: LinkableObject,\n        obj2: LinkableObject,\n        otherName: string | null = null,\n        variables: Literal = {},\n    ): Observable<FetchResult<{id: string}>> {\n        // clone prevents to affect the original reference\n        const clonedVariables = clone(variables);\n\n        return this.getMutation('link', obj1, obj2, otherName, clonedVariables).pipe(\n            switchMap(mutation => this.execute(mutation)),\n        );\n    }\n\n    /**\n     * Link many objects\n     */\n    public linkMany(\n        obj1: LinkableObject,\n        objects: LinkableObject[],\n        otherName: string | null = null,\n        variables: Literal = {},\n    ): Observable<FetchResult<{id: string}>[]> {\n        return forkJoin(objects.map(obj2 => this.link(obj1, obj2, otherName, variables)));\n    }\n\n    /**\n     * Unlink two objects\n     */\n    public unlink(\n        obj1: LinkableObject,\n        obj2: LinkableObject,\n        otherName: string | null = null,\n    ): Observable<FetchResult<{id: string}>> {\n        return this.getMutation('unlink', obj1, obj2, otherName).pipe(switchMap(mutation => this.execute(mutation)));\n    }\n\n    /**\n     * Return the list of all available mutation names\n     */\n    private getAllMutationNames(): Observable<Mutation[]> {\n        if (this.allMutations) {\n            return of(this.allMutations);\n        }\n\n        const mapArg = (arg: IntrospectedArg): MutationArg => {\n            return {\n                name: arg.name,\n                type: arg.type?.ofType?.name?.replace(/ID$/, '') || 'should-never-happen',\n            };\n        };\n\n        return this.apollo\n            .query<IntrospectedMutations>({\n                query: queriesQuery,\n                fetchPolicy: 'cache-first',\n            })\n            .pipe(\n                map(({data}) => {\n                    if (data.__type && data.__type.fields) {\n                        this.allMutations = data.__type.fields\n                            .filter(v => v.name.match(/^(link|unlink)/))\n                            .map(v => {\n                                return {\n                                    name: v.name,\n                                    arg1: mapArg(v.args[0]),\n                                    arg2: mapArg(v.args[1]),\n                                };\n                            });\n                    } else {\n                        this.allMutations = [];\n                    }\n\n                    return this.allMutations;\n                }),\n            );\n    }\n\n    /**\n     * Generate mutation using patterns and replacing variables\n     */\n    private getMutation(\n        action: string,\n        obj1: LinkableObject,\n        obj2: LinkableObject,\n        otherName: string | null,\n        variables: Literal = {},\n    ): Observable<string> {\n        otherName = otherName ? upperCaseFirstLetter(otherName) : otherName;\n        const mutationName = action + obj1.__typename + (otherName || obj2.__typename);\n        const reversedMutationName = action + obj2.__typename + (otherName || obj1.__typename);\n\n        return this.getAllMutationNames().pipe(\n            map(allMutationNames => {\n                const mutation =\n                    allMutationNames.find(mut => mut.name === mutationName) ||\n                    allMutationNames.find(mut => mut.name === reversedMutationName);\n\n                if (mutation) {\n                    return this.buildTemplate(mutation, obj1, obj2, variables);\n                }\n\n                throw TypeError('API does not allow to ' + action + ' ' + obj1.__typename + ' and ' + obj2.__typename);\n            }),\n        );\n    }\n\n    /**\n     * Execute mutation\n     */\n    private execute(mutation: string): Observable<FetchResult<{id: string}>> {\n        return this.apollo\n            .mutate<{id: string}>({\n                mutation: gql(mutation),\n            })\n            .pipe(\n                map(r => {\n                    this.apollo.client.reFetchObservableQueries();\n                    return r;\n                }),\n            );\n    }\n\n    /**\n     * Build the actual mutation string\n     */\n    private buildTemplate(\n        mutation: Mutation,\n        obj1: LinkableObject,\n        obj2: LinkableObject,\n        variables: Literal = {},\n    ): string {\n        let name1;\n        let name2;\n        if (obj1.__typename === mutation.arg1.type) {\n            name1 = mutation.arg1.name;\n            name2 = mutation.arg2.name;\n        } else {\n            name1 = mutation.arg2.name;\n            name2 = mutation.arg1.name;\n        }\n        variables[name1] = obj1.id;\n        variables[name2] = obj2.id;\n\n        let serializedVariables = '';\n        for (const key of Object.keys(variables)) {\n            serializedVariables += key + ': ' + JSON.stringify(variables[key]) + ' ';\n        }\n\n        return `mutation linkAndUnlink {\n            ${mutation.name}(${serializedVariables}) {\n                id\n            }\n        }`;\n    }\n}\n"]}

package/esm2020/lib/services/persistence.service.mjs

@@ -0,0 +1,113 @@
+import { Inject, Injectable } from '@angular/core';
+import { clone } from 'lodash-es';
+import { SESSION_STORAGE } from '../modules/common/services/memory-storage';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class NaturalPersistenceService {
+    constructor(router, sessionStorage) {
+        this.router = router;
+        this.sessionStorage = sessionStorage;
+    }
+    /**
+     * Persist in url and local storage the given value with the given key.
+     * When stored in storage, we need more "key" to identify the controller.
+     */
+    persist(key, value, route, storageKey, navigationExtras) {
+        this.persistInStorage(key, value, storageKey);
+        return this.persistInUrl(key, value, route, navigationExtras);
+    }
+    /**
+     * Return object with persisted data in url or in session storage
+     * Url has priority over session storage because of url sharing. When url is provided, session storage is ignored.
+     * Url and storage are synced when arriving in a component :
+     *  - When loading with url parameters, storage is updated to stay synced
+     *  - When loading without url, but with storage data, the url is updated
+     */
+    get(key, route, storageKey) {
+        // From url
+        let params = this.getFromUrl(key, route);
+        if (!this.isFalseyValue(params)) {
+            this.persistInStorage(key, params, storageKey);
+            return params;
+        }
+        // From storage
+        params = this.getFromStorage(key, storageKey);
+        if (!this.isFalseyValue(params)) {
+            this.persistInUrl(key, params, route);
+            return params;
+        }
+        return null;
+    }
+    /**
+     * Get given key from the url parameters
+     */
+    getFromUrl(key, route) {
+        const value = route.snapshot.paramMap.get(key);
+        if (value) {
+            try {
+                return JSON.parse(value);
+            }
+            catch (e) { }
+        }
+        return null;
+    }
+    /**
+     * Add/override given pair key-value in the url
+     * Always JSON.stringify() the given value
+     * If the value is falsey, the pair key-value is removed from the url.
+     */
+    persistInUrl(key, value, route, navigationExtras) {
+        const params = clone(route.snapshot.url[route.snapshot.url.length - 1].parameters);
+        if (this.isFalseyValue(value)) {
+            delete params[key];
+        }
+        else {
+            params[key] = JSON.stringify(value);
+        }
+        navigationExtras = Object.assign(navigationExtras || {}, { relativeTo: route });
+        return this.router.navigate(['.', params], navigationExtras);
+    }
+    getFromStorage(key, storageKey) {
+        const value = this.sessionStorage.getItem(this.getStorageKey(key, storageKey));
+        if (value) {
+            try {
+                return JSON.parse(value);
+            }
+            catch (e) { }
+        }
+        return null;
+    }
+    /**
+     * Store value in session storage.
+     * If value is falsy, the entry is removed
+     */
+    persistInStorage(key, value, storageKey) {
+        if (this.isFalseyValue(value)) {
+            this.sessionStorage.removeItem(this.getStorageKey(key, storageKey));
+        }
+        else {
+            this.sessionStorage.setItem(this.getStorageKey(key, storageKey), JSON.stringify(value));
+        }
+    }
+    getStorageKey(key, storageKey) {
+        return storageKey + '-' + key;
+    }
+    // Returns if the given value is falsey
+    // Falsey values are : null, undefined and empty string.
+    // This cause usually the parameter to be removed from url/storage instead of being stored with no value. Url would be polluted.
+    isFalseyValue(value) {
+        return value == null || value === ''; // == means null or undefined;
+    }
+}
+NaturalPersistenceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalPersistenceService, deps: [{ token: i1.Router }, { token: SESSION_STORAGE }], target: i0.ɵɵFactoryTarget.Injectable });
+NaturalPersistenceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalPersistenceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalPersistenceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SESSION_STORAGE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persistence.service.js","sourceRoot":"","sources":["../../../../../projects/natural/src/lib/services/persistence.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {ActivatedRoute, NavigationExtras, Router} from '@angular/router';\nimport {clone} from 'lodash-es';\nimport {NaturalStorage, SESSION_STORAGE} from '../modules/common/services/memory-storage';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class NaturalPersistenceService {\n    public constructor(\n        private readonly router: Router,\n        @Inject(SESSION_STORAGE) private readonly sessionStorage: NaturalStorage,\n    ) {}\n\n    /**\n     * Persist in url and local storage the given value with the given key.\n     * When stored in storage, we need more \"key\" to identify the controller.\n     */\n    public persist(\n        key: string,\n        value: any,\n        route: ActivatedRoute,\n        storageKey: string,\n        navigationExtras?: NavigationExtras,\n    ): Promise<boolean> {\n        this.persistInStorage(key, value, storageKey);\n        return this.persistInUrl(key, value, route, navigationExtras);\n    }\n\n    /**\n     * Return object with persisted data in url or in session storage\n     * Url has priority over session storage because of url sharing. When url is provided, session storage is ignored.\n     * Url and storage are synced when arriving in a component :\n     *  - When loading with url parameters, storage is updated to stay synced\n     *  - When loading without url, but with storage data, the url is updated\n     */\n    public get(key: string, route: ActivatedRoute, storageKey: string): any | null {\n        // From url\n        let params = this.getFromUrl(key, route);\n        if (!this.isFalseyValue(params)) {\n            this.persistInStorage(key, params, storageKey);\n            return params;\n        }\n\n        // From storage\n        params = this.getFromStorage(key, storageKey);\n        if (!this.isFalseyValue(params)) {\n            this.persistInUrl(key, params, route);\n            return params;\n        }\n\n        return null;\n    }\n\n    /**\n     * Get given key from the url parameters\n     */\n    public getFromUrl(key: string, route: ActivatedRoute): any | null {\n        const value = route.snapshot.paramMap.get(key);\n\n        if (value) {\n            try {\n                return JSON.parse(value);\n            } catch (e) {}\n        }\n\n        return null;\n    }\n\n    /**\n     * Add/override given pair key-value in the url\n     * Always JSON.stringify() the given value\n     * If the value is falsey, the pair key-value is removed from the url.\n     */\n    public persistInUrl(\n        key: string,\n        value: any,\n        route: ActivatedRoute,\n        navigationExtras?: NavigationExtras,\n    ): Promise<boolean> {\n        const params = clone(route.snapshot.url[route.snapshot.url.length - 1].parameters);\n\n        if (this.isFalseyValue(value)) {\n            delete params[key];\n        } else {\n            params[key] = JSON.stringify(value);\n        }\n\n        navigationExtras = Object.assign(navigationExtras || {}, {relativeTo: route});\n\n        return this.router.navigate(['.', params], navigationExtras);\n    }\n\n    public getFromStorage(key: string, storageKey: string): any | null {\n        const value = this.sessionStorage.getItem(this.getStorageKey(key, storageKey));\n\n        if (value) {\n            try {\n                return JSON.parse(value);\n            } catch (e) {}\n        }\n\n        return null;\n    }\n\n    /**\n     * Store value in session storage.\n     * If value is falsy, the entry is removed\n     */\n    public persistInStorage(key: string, value: any, storageKey: string): void {\n        if (this.isFalseyValue(value)) {\n            this.sessionStorage.removeItem(this.getStorageKey(key, storageKey));\n        } else {\n            this.sessionStorage.setItem(this.getStorageKey(key, storageKey), JSON.stringify(value));\n        }\n    }\n\n    private getStorageKey(key: string, storageKey: string): string {\n        return storageKey + '-' + key;\n    }\n\n    // Returns if the given value is falsey\n    // Falsey values are : null, undefined and empty string.\n    // This cause usually the parameter to be removed from url/storage instead of being stored with no value. Url would be polluted.\n    private isFalseyValue(value: any): boolean {\n        return value == null || value === ''; // == means null or undefined;\n    }\n}\n"]}

package/esm2020/lib/services/swiss-parsing-date-adapter.service.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import { NativeDateAdapter } from '@angular/material/core';
+import * as i0 from "@angular/core";
+export class NaturalSwissParsingDateAdapter extends NativeDateAdapter {
+    /**
+     * Parse commonly accepted swiss format, such as:
+     *
+     * - 24.12.2018
+     * - 1.4.18
+     * - 2018-12-24
+     */
+    parse(value) {
+        if (typeof value === 'number') {
+            return new Date(value);
+        }
+        if (typeof value === 'string') {
+            let m = value.match(/(\d{1,2})\.(\d{1,2})\.(\d{4}|\d{2})/);
+            if (m) {
+                let year = +m[3];
+                // Assume year 2000 if only two digits
+                if (year < 100) {
+                    year += 2000;
+                }
+                return this.createDateIfValid(year, +m[2], +m[1]);
+            }
+            // Attempt strict ISO format
+            m = value.match(/(\d{4})-(\d{2})-(\d{2})/);
+            if (m) {
+                return this.createDateIfValid(+m[1], +m[2], +m[3]);
+            }
+        }
+        return null;
+    }
+    createDateIfValid(year, month, date) {
+        month = month - 1;
+        if (month >= 0 && month <= 11 && date >= 1 && date <= 31) {
+            return this.createDate(year, month, date);
+        }
+        return null;
+    }
+    getFirstDayOfWeek() {
+        // Always starts on Monday, even though it is not true for Canada, U.S., Mexico and many more
+        // Also see https://github.com/tc39/ecma402/issues/6
+        return 1;
+    }
+}
+NaturalSwissParsingDateAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissParsingDateAdapter, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+NaturalSwissParsingDateAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissParsingDateAdapter, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: NaturalSwissParsingDateAdapter, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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