@igo2/geo 1.14.1 → 1.14.3

package/esm2020/lib/import-export/shared/import.errors.mjs

@@ -1,39 +1,39 @@
-export class ImportError extends Error {
-}
-export class ImportInvalidFileError extends ImportError {
-    constructor() {
-        super('Invalid file');
-        Object.setPrototypeOf(this, ImportInvalidFileError.prototype);
-    }
-}
-export class ImportUnreadableFileError extends ImportError {
-    constructor() {
-        super('Failed to read file');
-        Object.setPrototypeOf(this, ImportUnreadableFileError.prototype);
-    }
-}
-export class ImportNothingToImportError extends ImportError {
-    constructor() {
-        super('Nothing to import');
-        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
-    }
-}
-export class ImportSizeError extends ImportError {
-    constructor() {
-        super('File is too large');
-        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
-    }
-}
-export class ImportSRSError extends ImportError {
-    constructor() {
-        super('Invalid SRS definition');
-        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
-    }
-}
-export class ImportOgreServerError extends ImportError {
-    constructor() {
-        super('Error 500 with OGRE');
-        Object.setPrototypeOf(this, ImportOgreServerError.prototype);
-    }
-}
+export class ImportError extends Error {
+}
+export class ImportInvalidFileError extends ImportError {
+    constructor() {
+        super('Invalid file');
+        Object.setPrototypeOf(this, ImportInvalidFileError.prototype);
+    }
+}
+export class ImportUnreadableFileError extends ImportError {
+    constructor() {
+        super('Failed to read file');
+        Object.setPrototypeOf(this, ImportUnreadableFileError.prototype);
+    }
+}
+export class ImportNothingToImportError extends ImportError {
+    constructor() {
+        super('Nothing to import');
+        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
+    }
+}
+export class ImportSizeError extends ImportError {
+    constructor() {
+        super('File is too large');
+        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
+    }
+}
+export class ImportSRSError extends ImportError {
+    constructor() {
+        super('Invalid SRS definition');
+        Object.setPrototypeOf(this, ImportNothingToImportError.prototype);
+    }
+}
+export class ImportOgreServerError extends ImportError {
+    constructor() {
+        super('Error 500 with OGRE');
+        Object.setPrototypeOf(this, ImportOgreServerError.prototype);
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/import-export/shared/import.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2ltcG9ydC1leHBvcnQvc2hhcmVkL2ltcG9ydC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV4cG9ydEZvcm1hdCB9IGZyb20gXCIuL2V4cG9ydC50eXBlXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSW1wb3J0RXhwb3J0U2VydmljZU9wdGlvbnMge1xuICB1cmw6IHN0cmluZztcbiAgY2xpZW50U2lkZUZpbGVTaXplTWF4TWI/OiBudW1iZXI7XG4gIGZvcmNlTmFtaW5nPzogYm9vbGVhbjtcbiAgZm9ybWF0cz86IEV4cG9ydEZvcm1hdFtdO1xuICBjb25maWdGaWxlVG9HZW9EQlNlcnZpY2U/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2020/lib/import-export/shared/import.service.mjs

@@ -1,215 +1,215 @@
-import { Injectable } from '@angular/core';
-import { HttpHeaders } from '@angular/common/http';
-import { uuid } from '@igo2/utils';
-import { Observable } from 'rxjs';
-import * as olformat from 'ol/format';
-import { ImportInvalidFileError, ImportUnreadableFileError, ImportSizeError, ImportSRSError, ImportOgreServerError } from './import.errors';
-import { computeLayerTitleFromFile, getFileExtension } from './import.utils';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-import * as i2 from "@igo2/core";
-export class ImportService {
-    constructor(http, config) {
-        this.http = http;
-        this.config = config;
-        const importConfig = this.config.getConfig('importExport');
-        this.ogreUrl = importConfig.url;
-        const configFileSizeMb = importConfig.clientSideFileSizeMaxMb;
-        this.clientSideFileSizeMax = (configFileSizeMb ? configFileSizeMb : 30) * Math.pow(1024, 2);
-        if (importConfig.formats) {
-            ImportService.allowedExtensions = importConfig.formats
-                .map(format => ImportService.formatExtensionAssociation[format])
-                .filter(e => e);
-            if (ImportService.allowedExtensions.includes('geojson')) {
-                ImportService.allowedExtensions.push('json');
-            }
-        }
-    }
-    import(file, projectionIn = 'EPSG:4326', projectionOut = 'EPSG:4326') {
-        return this.importAsync(file, projectionIn, projectionOut);
-    }
-    getFileImporter(file) {
-        const extension = getFileExtension(file);
-        const allowedExtensions = ImportService.allowedExtensions;
-        let zipMimeTypes = [];
-        if (allowedExtensions.includes('zip')) {
-            zipMimeTypes = ImportService.allowedZipMimeTypes;
-        }
-        const mimeType = file.type;
-        const allowedMimeTypes = [
-            ...ImportService.allowedMimeTypes,
-            ...zipMimeTypes
-        ];
-        if (allowedMimeTypes.indexOf(mimeType) < 0 &&
-            allowedExtensions.indexOf(extension) < 0) {
-            return undefined;
-        }
-        else if (mimeType === 'application/json' ||
-            ['json', 'geojson', 'kml', 'gpx'].indexOf(extension) >= 0) {
-            return this.importFile;
-        }
-        else if (this.ogreUrl !== undefined) {
-            return this.importFileWithOgre;
-        }
-        return undefined;
-    }
-    importAsync(file, projectionIn, projectionOut) {
-        const doImport = (observer) => {
-            if (file.size >= this.clientSideFileSizeMax) {
-                observer.error(new ImportSizeError());
-                return;
-            }
-            const importer = this.getFileImporter(file);
-            if (importer === undefined) {
-                observer.error(new ImportInvalidFileError());
-                return;
-            }
-            importer.call(this, file, observer, projectionIn, projectionOut);
-        };
-        return new Observable(doImport);
-    }
-    importFile(file, observer, projectionIn, projectionOut) {
-        const reader = new FileReader();
-        reader.onload = (event) => {
-            try {
-                const features = this.parseFeaturesFromFile(file, event.target.result, projectionIn, projectionOut);
-                observer.next(features);
-            }
-            catch (e) {
-                observer.error(new ImportUnreadableFileError());
-            }
-            observer.complete();
-        };
-        reader.onerror = evt => {
-            observer.error(new ImportUnreadableFileError());
-        };
-        reader.readAsText(file, 'UTF-8');
-    }
-    importFileWithOgre(file, observer, projectionIn, projectionOut) {
-        const url = `${this.ogreUrl}/convert`;
-        const formData = new FormData();
-        formData.append('upload', file);
-        formData.append('sourceSrs', projectionIn);
-        formData.append('targetSrs', projectionOut);
-        formData.append('formatOutput', 'GEOJSON');
-        formData.append('skipFailures', '');
-        this.http.post(url, formData, { headers: new HttpHeaders() })
-            .subscribe((response) => {
-            if (response === null) {
-                observer.error(new ImportUnreadableFileError());
-                return;
-            }
-            const errors = response.errors || [];
-            if (errors.length > 0) {
-                observer.error(new ImportUnreadableFileError());
-            }
-            else {
-                const features = this.parseFeaturesFromGeoJSON(file, response, projectionOut);
-                observer.next(features);
-                observer.complete();
-            }
-        }, (error) => {
-            error.error.caught = true;
-            const errMsg = error.error.msg || '';
-            if (errMsg === 'No valid files found') {
-                observer.error(new ImportInvalidFileError());
-            }
-            else if (errMsg && errMsg.startWith('ERROR 1: Failed to process SRS definition')) {
-                observer.error(new ImportSRSError());
-            }
-            else if (error.status === 500) {
-                observer.error(new ImportOgreServerError());
-            }
-            else {
-                observer.error(new ImportUnreadableFileError());
-            }
-        });
-    }
-    parseFeaturesFromFile(file, data, projectionIn, projectionOut) {
-        const extension = getFileExtension(file);
-        const mimeType = file.type;
-        const GeoJSON = new olformat.GeoJSON();
-        let format;
-        if (mimeType === 'application/vnd.google-earth.kml+xml') {
-            format = new olformat.KML();
-        }
-        else if (mimeType === 'application/gml+xml') {
-            format = new olformat.GML();
-        }
-        else if (mimeType === 'application/gpx+xml') {
-            format = new olformat.GPX();
-        }
-        else {
-            switch (extension) {
-                case 'kml':
-                    format = new olformat.KML();
-                    break;
-                case 'gpx':
-                    format = new olformat.GPX();
-                    break;
-                case 'gml':
-                    format = new olformat.GML();
-                    break;
-                default:
-                    format = GeoJSON;
-                    break;
-            }
-        }
-        const olFeatures = format.readFeatures(data, {
-            dataProjection: projectionIn,
-            featureProjection: projectionOut
-        });
-        const features = olFeatures.map((olFeature) => {
-            return Object.assign(GeoJSON.writeFeatureObject(olFeature), {
-                projection: projectionOut,
-                meta: {
-                    id: uuid(),
-                    title: computeLayerTitleFromFile(file)
-                }
-            });
-        });
-        return features;
-    }
-    parseFeaturesFromGeoJSON(file, data, projectionOut) {
-        const olFormat = new olformat.GeoJSON();
-        const olFeatures = olFormat.readFeatures(data);
-        const features = olFeatures.map((olFeature) => {
-            return Object.assign(olFormat.writeFeatureObject(olFeature), {
-                projection: projectionOut,
-                meta: {
-                    id: uuid(),
-                    title: computeLayerTitleFromFile(file)
-                }
-            });
-        });
-        return features;
-    }
-}
-ImportService.formatExtensionAssociation = {
-    GeoJSON: 'geojson',
-    GML: 'gml',
-    GPX: 'gpx',
-    KML: 'kml',
-    Shapefile: 'zip'
-};
-ImportService.allowedMimeTypes = [
-    'application/gml+xml',
-    'application/vnd.google-earth.kml+xml',
-    'application/gpx+xml',
-    'application/json'
-];
-ImportService.allowedZipMimeTypes = [
-    'application/zip',
-    'application/x-zip-compressed',
-    'application/x-zip'
-];
-ImportService.allowedExtensions = ['geojson', 'kml', 'gpx', 'json', 'gml', 'zip'];
-ImportService.ɵfac = function ImportService_Factory(t) { return new (t || ImportService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); };
-ImportService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ImportService, factory: ImportService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImportService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; }, null); })();
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { uuid } from '@igo2/utils';
+import { Observable } from 'rxjs';
+import * as olformat from 'ol/format';
+import { ImportInvalidFileError, ImportUnreadableFileError, ImportSizeError, ImportSRSError, ImportOgreServerError } from './import.errors';
+import { computeLayerTitleFromFile, getFileExtension } from './import.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@igo2/core";
+export class ImportService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        const importConfig = this.config.getConfig('importExport');
+        this.ogreUrl = importConfig.url;
+        const configFileSizeMb = importConfig.clientSideFileSizeMaxMb;
+        this.clientSideFileSizeMax = (configFileSizeMb ? configFileSizeMb : 30) * Math.pow(1024, 2);
+        if (importConfig.formats) {
+            ImportService.allowedExtensions = importConfig.formats
+                .map(format => ImportService.formatExtensionAssociation[format])
+                .filter(e => e);
+            if (ImportService.allowedExtensions.includes('geojson')) {
+                ImportService.allowedExtensions.push('json');
+            }
+        }
+    }
+    import(file, projectionIn = 'EPSG:4326', projectionOut = 'EPSG:4326') {
+        return this.importAsync(file, projectionIn, projectionOut);
+    }
+    getFileImporter(file) {
+        const extension = getFileExtension(file);
+        const allowedExtensions = ImportService.allowedExtensions;
+        let zipMimeTypes = [];
+        if (allowedExtensions.includes('zip')) {
+            zipMimeTypes = ImportService.allowedZipMimeTypes;
+        }
+        const mimeType = file.type;
+        const allowedMimeTypes = [
+            ...ImportService.allowedMimeTypes,
+            ...zipMimeTypes
+        ];
+        if (allowedMimeTypes.indexOf(mimeType) < 0 &&
+            allowedExtensions.indexOf(extension) < 0) {
+            return undefined;
+        }
+        else if (mimeType === 'application/json' ||
+            ['json', 'geojson', 'kml', 'gpx'].indexOf(extension) >= 0) {
+            return this.importFile;
+        }
+        else if (this.ogreUrl !== undefined) {
+            return this.importFileWithOgre;
+        }
+        return undefined;
+    }
+    importAsync(file, projectionIn, projectionOut) {
+        const doImport = (observer) => {
+            if (file.size >= this.clientSideFileSizeMax) {
+                observer.error(new ImportSizeError());
+                return;
+            }
+            const importer = this.getFileImporter(file);
+            if (importer === undefined) {
+                observer.error(new ImportInvalidFileError());
+                return;
+            }
+            importer.call(this, file, observer, projectionIn, projectionOut);
+        };
+        return new Observable(doImport);
+    }
+    importFile(file, observer, projectionIn, projectionOut) {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+            try {
+                const features = this.parseFeaturesFromFile(file, event.target.result, projectionIn, projectionOut);
+                observer.next(features);
+            }
+            catch (e) {
+                observer.error(new ImportUnreadableFileError());
+            }
+            observer.complete();
+        };
+        reader.onerror = evt => {
+            observer.error(new ImportUnreadableFileError());
+        };
+        reader.readAsText(file, 'UTF-8');
+    }
+    importFileWithOgre(file, observer, projectionIn, projectionOut) {
+        const url = `${this.ogreUrl}/convert`;
+        const formData = new FormData();
+        formData.append('upload', file);
+        formData.append('sourceSrs', projectionIn);
+        formData.append('targetSrs', projectionOut);
+        formData.append('formatOutput', 'GEOJSON');
+        formData.append('skipFailures', '');
+        this.http.post(url, formData, { headers: new HttpHeaders() })
+            .subscribe((response) => {
+            if (response === null) {
+                observer.error(new ImportUnreadableFileError());
+                return;
+            }
+            const errors = response.errors || [];
+            if (errors.length > 0) {
+                observer.error(new ImportUnreadableFileError());
+            }
+            else {
+                const features = this.parseFeaturesFromGeoJSON(file, response, projectionOut);
+                observer.next(features);
+                observer.complete();
+            }
+        }, (error) => {
+            error.error.caught = true;
+            const errMsg = error.error.msg || '';
+            if (errMsg === 'No valid files found') {
+                observer.error(new ImportInvalidFileError());
+            }
+            else if (errMsg && errMsg.startWith('ERROR 1: Failed to process SRS definition')) {
+                observer.error(new ImportSRSError());
+            }
+            else if (error.status === 500) {
+                observer.error(new ImportOgreServerError());
+            }
+            else {
+                observer.error(new ImportUnreadableFileError());
+            }
+        });
+    }
+    parseFeaturesFromFile(file, data, projectionIn, projectionOut) {
+        const extension = getFileExtension(file);
+        const mimeType = file.type;
+        const GeoJSON = new olformat.GeoJSON();
+        let format;
+        if (mimeType === 'application/vnd.google-earth.kml+xml') {
+            format = new olformat.KML();
+        }
+        else if (mimeType === 'application/gml+xml') {
+            format = new olformat.GML();
+        }
+        else if (mimeType === 'application/gpx+xml') {
+            format = new olformat.GPX();
+        }
+        else {
+            switch (extension) {
+                case 'kml':
+                    format = new olformat.KML();
+                    break;
+                case 'gpx':
+                    format = new olformat.GPX();
+                    break;
+                case 'gml':
+                    format = new olformat.GML();
+                    break;
+                default:
+                    format = GeoJSON;
+                    break;
+            }
+        }
+        const olFeatures = format.readFeatures(data, {
+            dataProjection: projectionIn,
+            featureProjection: projectionOut
+        });
+        const features = olFeatures.map((olFeature) => {
+            return Object.assign(GeoJSON.writeFeatureObject(olFeature), {
+                projection: projectionOut,
+                meta: {
+                    id: uuid(),
+                    title: computeLayerTitleFromFile(file)
+                }
+            });
+        });
+        return features;
+    }
+    parseFeaturesFromGeoJSON(file, data, projectionOut) {
+        const olFormat = new olformat.GeoJSON();
+        const olFeatures = olFormat.readFeatures(data);
+        const features = olFeatures.map((olFeature) => {
+            return Object.assign(olFormat.writeFeatureObject(olFeature), {
+                projection: projectionOut,
+                meta: {
+                    id: uuid(),
+                    title: computeLayerTitleFromFile(file)
+                }
+            });
+        });
+        return features;
+    }
+}
+ImportService.formatExtensionAssociation = {
+    GeoJSON: 'geojson',
+    GML: 'gml',
+    GPX: 'gpx',
+    KML: 'kml',
+    Shapefile: 'zip'
+};
+ImportService.allowedMimeTypes = [
+    'application/gml+xml',
+    'application/vnd.google-earth.kml+xml',
+    'application/gpx+xml',
+    'application/json'
+];
+ImportService.allowedZipMimeTypes = [
+    'application/zip',
+    'application/x-zip-compressed',
+    'application/x-zip'
+];
+ImportService.allowedExtensions = ['geojson', 'kml', 'gpx', 'json', 'gml', 'zip'];
+ImportService.ɵfac = function ImportService_Factory(t) { return new (t || ImportService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); };
+ImportService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ImportService, factory: ImportService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImportService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; }, null); })();
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/import-export/shared/import.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\n\nimport { ConfigService } from '@igo2/core';\nimport { uuid } from '@igo2/utils';\n\nimport { Observable, Observer } from 'rxjs';\n\nimport * as olformat from 'ol/format';\nimport OlFeature from 'ol/Feature';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\n\nimport { Feature } from '../../feature/shared/feature.interfaces';\nimport {\n  ImportInvalidFileError,\n  ImportUnreadableFileError,\n  ImportSizeError,\n  ImportSRSError,\n  ImportOgreServerError\n} from './import.errors';\nimport { computeLayerTitleFromFile, getFileExtension } from './import.utils';\nimport { ImportExportServiceOptions } from './import.interface';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ImportService {\n\n  static formatExtensionAssociation = {\n    GeoJSON: 'geojson',\n    GML: 'gml',\n    GPX: 'gpx',\n    KML: 'kml',\n    Shapefile: 'zip'\n  };\n\n  static allowedMimeTypes = [\n    'application/gml+xml',\n    'application/vnd.google-earth.kml+xml',\n    'application/gpx+xml',\n    'application/json'\n  ];\n\n  static allowedZipMimeTypes = [\n    'application/zip',\n    'application/x-zip-compressed',\n    'application/x-zip'\n  ];\n\n  static allowedExtensions = ['geojson', 'kml', 'gpx', 'json', 'gml', 'zip'];\n\n  private ogreUrl: string;\n  private clientSideFileSizeMax: number;\n\n  constructor(private http: HttpClient, private config: ConfigService) {\n    const importConfig = this.config.getConfig('importExport') as ImportExportServiceOptions;\n    this.ogreUrl = importConfig.url;\n    const configFileSizeMb = importConfig.clientSideFileSizeMaxMb;\n    this.clientSideFileSizeMax = (configFileSizeMb ? configFileSizeMb : 30) * Math.pow(1024, 2);\n    if (importConfig.formats) {\n      ImportService.allowedExtensions = importConfig.formats\n        .map(format => ImportService.formatExtensionAssociation[format])\n        .filter(e => e);\n      if (ImportService.allowedExtensions.includes('geojson')) {\n        ImportService.allowedExtensions.push('json');\n      }\n    }\n  }\n\n  import(\n    file: File,\n    projectionIn = 'EPSG:4326',\n    projectionOut = 'EPSG:4326'\n  ): Observable<Feature[]> {\n    return this.importAsync(file, projectionIn, projectionOut);\n  }\n\n  private getFileImporter(\n    file: File\n  ): (\n      file: File,\n      observer: Observer<Feature[]>,\n      projectionIn: string,\n      projectionOut: string\n    ) => void {\n    const extension = getFileExtension(file);\n    const allowedExtensions = ImportService.allowedExtensions;\n    let zipMimeTypes = [];\n    if (allowedExtensions.includes('zip')) {\n      zipMimeTypes = ImportService.allowedZipMimeTypes;\n    }\n    const mimeType = file.type;\n    const allowedMimeTypes = [\n      ...ImportService.allowedMimeTypes,\n      ...zipMimeTypes\n    ];\n\n    if (\n      allowedMimeTypes.indexOf(mimeType) < 0 &&\n      allowedExtensions.indexOf(extension) < 0\n    ) {\n      return undefined;\n    } else if (\n      mimeType === 'application/json' ||\n      ['json', 'geojson', 'kml', 'gpx'].indexOf(extension) >= 0\n    ) {\n      return this.importFile;\n    } else if (this.ogreUrl !== undefined) {\n      return this.importFileWithOgre;\n    }\n\n    return undefined;\n  }\n\n  private importAsync(\n    file: File,\n    projectionIn: string,\n    projectionOut: string\n  ): Observable<Feature[]> {\n    const doImport = (observer: Observer<Feature[]>) => {\n      if (file.size >= this.clientSideFileSizeMax) {\n        observer.error(new ImportSizeError());\n        return;\n      }\n      const importer = this.getFileImporter(file);\n      if (importer === undefined) {\n        observer.error(new ImportInvalidFileError());\n        return;\n      }\n\n      importer.call(this, file, observer, projectionIn, projectionOut);\n    };\n\n    return new Observable(doImport);\n  }\n\n  private importFile(\n    file: File,\n    observer: Observer<Feature[]>,\n    projectionIn: string,\n    projectionOut: string\n  ) {\n    const reader = new FileReader();\n\n    reader.onload = (event: any) => {\n      try {\n        const features = this.parseFeaturesFromFile(\n          file,\n          event.target.result,\n          projectionIn,\n          projectionOut\n        );\n        observer.next(features);\n      } catch (e) {\n        observer.error(new ImportUnreadableFileError());\n      }\n\n      observer.complete();\n    };\n\n    reader.onerror = evt => {\n      observer.error(new ImportUnreadableFileError());\n    };\n\n    reader.readAsText(file, 'UTF-8');\n  }\n\n  private importFileWithOgre(\n    file: File,\n    observer: Observer<Feature[]>,\n    projectionIn: string,\n    projectionOut: string\n  ) {\n    const url = `${this.ogreUrl}/convert`;\n    const formData = new FormData();\n    formData.append('upload', file);\n    formData.append('sourceSrs', projectionIn);\n    formData.append('targetSrs', projectionOut);\n    formData.append('formatOutput', 'GEOJSON');\n    formData.append('skipFailures', '');\n\n    this.http.post(url, formData, { headers: new HttpHeaders() })\n      .subscribe(\n        (response: { errors?: string[] } | object | null) => {\n          if (response === null) {\n            observer.error(new ImportUnreadableFileError());\n            return;\n          }\n\n          const errors = (response as any).errors || [];\n          if (errors.length > 0) {\n            observer.error(new ImportUnreadableFileError());\n          } else {\n            const features = this.parseFeaturesFromGeoJSON(\n              file,\n              response,\n              projectionOut\n            );\n            observer.next(features);\n            observer.complete();\n          }\n        },\n        (error: any) => {\n          error.error.caught = true;\n          const errMsg = error.error.msg || '';\n          if (errMsg === 'No valid files found') {\n            observer.error(new ImportInvalidFileError());\n          } else if (errMsg && errMsg.startWith('ERROR 1: Failed to process SRS definition')\n          ) {\n            observer.error(new ImportSRSError());\n          } else if (error.status === 500) {\n            observer.error(new ImportOgreServerError());\n          } else {\n            observer.error(new ImportUnreadableFileError());\n          }\n        }\n      );\n  }\n\n  private parseFeaturesFromFile(\n    file: File,\n    data: string,\n    projectionIn: string,\n    projectionOut: string\n  ): Feature[] {\n    const extension = getFileExtension(file);\n    const mimeType = file.type;\n\n    const GeoJSON = new olformat.GeoJSON();\n\n    let format;\n    if (mimeType === 'application/vnd.google-earth.kml+xml') {\n      format = new olformat.KML();\n    } else if (mimeType === 'application/gml+xml') {\n      format = new olformat.GML();\n    } else if (mimeType === 'application/gpx+xml') {\n      format = new olformat.GPX();\n    } else {\n      switch (extension) {\n        case 'kml':\n          format = new olformat.KML();\n          break;\n        case 'gpx':\n          format = new olformat.GPX();\n          break;\n        case 'gml':\n          format = new olformat.GML();\n          break;\n        default:\n          format = GeoJSON;\n          break;\n      }\n    }\n\n    const olFeatures = format.readFeatures(data, {\n      dataProjection: projectionIn,\n      featureProjection: projectionOut\n    });\n    const features = olFeatures.map((olFeature: OlFeature<OlGeometry>) => {\n      return Object.assign(GeoJSON.writeFeatureObject(olFeature), {\n        projection: projectionOut,\n        meta: {\n          id: uuid(),\n          title: computeLayerTitleFromFile(file)\n        }\n      });\n    });\n\n    return features;\n  }\n\n  private parseFeaturesFromGeoJSON(\n    file: File,\n    data: object,\n    projectionOut: string\n  ): Feature[] {\n    const olFormat = new olformat.GeoJSON();\n    const olFeatures = olFormat.readFeatures(data);\n    const features = olFeatures.map((olFeature: OlFeature<OlGeometry>) => {\n      return Object.assign(olFormat.writeFeatureObject(olFeature), {\n        projection: projectionOut,\n        meta: {\n          id: uuid(),\n          title: computeLayerTitleFromFile(file)\n        }\n      });\n    });\n\n    return features as Feature[];\n  }\n}\n"]}