@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/import-export/shared/export.utils.mjs

@@ -0,0 +1,47 @@
+import { getEntityProperty, EntityTableColumnRenderer } from '@igo2/common';
+import { downloadContent } from '@igo2/utils';
+import { ExportNothingToExportError } from './export.errors';
+export function handleFileExportError(error, messageService) {
+    if (error instanceof ExportNothingToExportError) {
+        handleNothingToExportError(messageService);
+        return;
+    }
+    messageService.error('igo.geo.export.failed.text', 'igo.geo.export.failed.title');
+}
+export function handleFileExportSuccess(messageService) {
+    messageService.success('igo.geo.export.success.text', 'igo.geo.export.success.title');
+}
+export function handleNothingToExportError(messageService) {
+    messageService.error('igo.geo.export.nothing.text', 'igo.geo.export.nothing.title');
+}
+/**
+ * Export array to CSV
+ *
+ * @param rows Array of arrays to export as CSV
+ * @param separator Cell separator
+ */
+export function exportToCSV(rows, fileName, separator = ';') {
+    const lines = rows.map((row, index) => row.join(separator));
+    const csvContent = lines.join('\n');
+    downloadContent(csvContent, 'text/csv;charset=utf-8', fileName);
+}
+/**
+ * Return an array of values from an array of entities.
+ *
+ * @param entities Array of entities
+ * @param scolumns Columns definition of the output data
+ */
+export function entitiesToRowData(entities, columns) {
+    return entities.map((entity) => {
+        return columns.map((column) => {
+            let valueAccessor;
+            if (column.renderer === undefined ||
+                column.renderer === EntityTableColumnRenderer.Default) {
+                valueAccessor = column.valueAccessor;
+            }
+            valueAccessor = valueAccessor ? valueAccessor : getEntityProperty;
+            return valueAccessor(entity, column.name);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0LmVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2ltcG9ydC1leHBvcnQvc2hhcmVkL2ltcG9ydC5lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFdBQVksU0FBUSxLQUFLO0NBQUc7QUFFekMsTUFBTSxPQUFPLHNCQUF1QixTQUFRLFdBQVc7SUFDckQ7UUFDRSxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDdEIsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsc0JBQXNCLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDaEUsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLHlCQUEwQixTQUFRLFdBQVc7SUFDeEQ7UUFDRSxLQUFLLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUM3QixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSx5QkFBeUIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNuRSxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sMEJBQTJCLFNBQVEsV0FBVztJQUN6RDtRQUNFLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO1FBQzNCLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLDBCQUEwQixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3BFLENBQUM7Q0FDRjtBQUVELE1BQU0sT0FBTyxlQUFnQixTQUFRLFdBQVc7SUFDOUM7UUFDRSxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUMzQixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSwwQkFBMEIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwRSxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8sY0FBZSxTQUFRLFdBQVc7SUFDN0M7UUFDRSxLQUFLLENBQUMsd0JBQXdCLENBQUMsQ0FBQztRQUNoQyxNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSwwQkFBMEIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwRSxDQUFDO0NBQ0Y7QUFFRCxNQUFNLE9BQU8scUJBQXNCLFNBQVEsV0FBVztJQUNwRDtRQUNFLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBQzdCLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLHFCQUFxQixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQy9ELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBJbXBvcnRFcnJvciBleHRlbmRzIEVycm9yIHt9XG5cbmV4cG9ydCBjbGFzcyBJbXBvcnRJbnZhbGlkRmlsZUVycm9yIGV4dGVuZHMgSW1wb3J0RXJyb3Ige1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcignSW52YWxpZCBmaWxlJyk7XG4gICAgT2JqZWN0LnNldFByb3RvdHlwZU9mKHRoaXMsIEltcG9ydEludmFsaWRGaWxlRXJyb3IucHJvdG90eXBlKTtcbiAgfVxufVxuXG5leHBvcnQgY2xhc3MgSW1wb3J0VW5yZWFkYWJsZUZpbGVFcnJvciBleHRlbmRzIEltcG9ydEVycm9yIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoJ0ZhaWxlZCB0byByZWFkIGZpbGUnKTtcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgSW1wb3J0VW5yZWFkYWJsZUZpbGVFcnJvci5wcm90b3R5cGUpO1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBJbXBvcnROb3RoaW5nVG9JbXBvcnRFcnJvciBleHRlbmRzIEltcG9ydEVycm9yIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoJ05vdGhpbmcgdG8gaW1wb3J0Jyk7XG4gICAgT2JqZWN0LnNldFByb3RvdHlwZU9mKHRoaXMsIEltcG9ydE5vdGhpbmdUb0ltcG9ydEVycm9yLnByb3RvdHlwZSk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEltcG9ydFNpemVFcnJvciBleHRlbmRzIEltcG9ydEVycm9yIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoJ0ZpbGUgaXMgdG9vIGxhcmdlJyk7XG4gICAgT2JqZWN0LnNldFByb3RvdHlwZU9mKHRoaXMsIEltcG9ydE5vdGhpbmdUb0ltcG9ydEVycm9yLnByb3RvdHlwZSk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEltcG9ydFNSU0Vycm9yIGV4dGVuZHMgSW1wb3J0RXJyb3Ige1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcignSW52YWxpZCBTUlMgZGVmaW5pdGlvbicpO1xuICAgIE9iamVjdC5zZXRQcm90b3R5cGVPZih0aGlzLCBJbXBvcnROb3RoaW5nVG9JbXBvcnRFcnJvci5wcm90b3R5cGUpO1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBJbXBvcnRPZ3JlU2VydmVyRXJyb3IgZXh0ZW5kcyBJbXBvcnRFcnJvciB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKCdFcnJvciA1MDAgd2l0aCBPR1JFJyk7XG4gICAgT2JqZWN0LnNldFByb3RvdHlwZU9mKHRoaXMsIEltcG9ydE9ncmVTZXJ2ZXJFcnJvci5wcm90b3R5cGUpO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1wb3J0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2ltcG9ydC1leHBvcnQvc2hhcmVkL2ltcG9ydC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV4cG9ydEZvcm1hdCB9IGZyb20gJy4vZXhwb3J0LnR5cGUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEltcG9ydEV4cG9ydFNlcnZpY2VPcHRpb25zIHtcbiAgdXJsOiBzdHJpbmc7XG4gIGNsaWVudFNpZGVGaWxlU2l6ZU1heE1iPzogbnVtYmVyO1xuICBmb3JjZU5hbWluZz86IGJvb2xlYW47XG4gIGZvcm1hdHM/OiBFeHBvcnRGb3JtYXRbXTtcbiAgY29uZmlnRmlsZVRvR2VvREJTZXJ2aWNlPzogc3RyaW5nO1xuICBhbGxvd1RvU3RvcmVMYXllcj86IGJvb2xlYW47XG4gIGltcG9ydFdpdGhTdHlsZT86IGJvb2xlYW47XG59XG4iXX0=

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

@@ -0,0 +1,221 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { ConfigService } from '@igo2/core';
+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 {
+    http;
+    config;
+    static formatExtensionAssociation = {
+        GeoJSON: 'geojson',
+        GML: 'gml',
+        GPX: 'gpx',
+        KML: 'kml',
+        Shapefile: 'zip'
+    };
+    static allowedMimeTypes = [
+        'application/gml+xml',
+        'application/vnd.google-earth.kml+xml',
+        'application/gpx+xml',
+        'application/json'
+    ];
+    static allowedZipMimeTypes = [
+        'application/zip',
+        'application/x-zip-compressed',
+        'application/x-zip'
+    ];
+    static allowedExtensions = ['geojson', 'kml', 'gpx', 'json', 'gml', 'zip'];
+    ogreUrl;
+    clientSideFileSizeMax;
+    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;
+    }
+    static ɵfac = function ImportService_Factory(t) { return new (t || ImportService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.ConfigService)); };
+    static ɵ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  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(\n    private http: HttpClient,\n    private config: ConfigService\n  ) {\n    const importConfig = this.config.getConfig(\n      'importExport'\n    ) as ImportExportServiceOptions;\n    this.ogreUrl = importConfig.url;\n    const configFileSizeMb = importConfig.clientSideFileSizeMaxMb;\n    this.clientSideFileSizeMax =\n      (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() }).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 (\n          errMsg &&\n          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"]}

package/esm2022/lib/import-export/shared/import.utils.mjs

@@ -0,0 +1,203 @@
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { featureToOl, moveToOlFeatures, computeOlFeaturesExtent } from '../../feature/shared/feature.utils';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';
+import { uuid } from '@igo2/utils';
+import { featureRandomStyle, featureRandomStyleFunction } from '../../style/shared/feature/feature-style';
+import { first, of } from 'rxjs';
+export function addLayerAndFeaturesToMap(features, map, contextUri, layerTitle, layerService, storeToIdb = false) {
+    const olFeatures = features.map((feature) => featureToOl(feature, map.projection));
+    const id = uuid();
+    const sourceOptions = {
+        id,
+        type: 'vector',
+        queryable: true
+    };
+    const source = new FeatureDataSource(sourceOptions);
+    source.ol.addFeatures(olFeatures);
+    let randomStyle;
+    let editable = false;
+    if (olFeatures[0].getKeys().includes('_style') ||
+        olFeatures[0].getKeys().includes('_mapTitle')) {
+        randomStyle = featureRandomStyleFunction();
+    }
+    else {
+        randomStyle = featureRandomStyle();
+        editable = true;
+    }
+    const layer = layerService.createLayer({
+        id,
+        title: layerTitle,
+        workspace: { enabled: true, searchIndexEnabled: true },
+        isIgoInternalLayer: true,
+        source,
+        igoStyle: { editable },
+        idbInfo: { firstLoad: true, storeToIdb, contextUri: contextUri || '*' },
+        style: randomStyle
+    });
+    layer.setExtent(computeOlFeaturesExtent(olFeatures, map.viewProjection));
+    map.addLayer(layer);
+    moveToOlFeatures(map.viewController, olFeatures);
+    return layer;
+}
+export function addLayerAndFeaturesStyledToMap(features, map, layerTitle, styleListService, styleService, layerId, imposedSourceOptions, imposedLayerOptions, zoomTo = true) {
+    const olFeatures = features.map((feature) => featureToOl(feature, map.projection));
+    let style;
+    let distance;
+    if (styleListService.getStyleList(layerTitle.toString() + '.styleByAttribute')) {
+        const styleByAttribute = styleListService.getStyleList(layerTitle.toString() + '.styleByAttribute');
+        style = (feature, resolution) => {
+            return styleService.createStyleByAttribute(feature, styleByAttribute, resolution);
+        };
+    }
+    else if (styleListService.getStyleList(layerTitle.toString() + '.clusterStyle')) {
+        const clusterParam = styleListService.getStyleList(layerTitle.toString() + '.clusterParam');
+        distance = styleListService.getStyleList(layerTitle.toString() + '.distance');
+        style = (feature, resolution) => {
+            const baseStyle = styleService.createStyle(styleListService.getStyleList(layerTitle.toString() + '.clusterStyle'), feature, resolution);
+            return styleService.createClusterStyle(feature, resolution, clusterParam, baseStyle);
+        };
+    }
+    else if (styleListService.getStyleList(layerTitle.toString() + '.style')) {
+        style = (feature, resolution) => styleService.createStyle(styleListService.getStyleList(layerTitle.toString() + '.style'), feature, resolution);
+    }
+    else if (styleListService.getStyleList('default.clusterStyle') &&
+        features[0].geometry.type === 'Point') {
+        const clusterParam = styleListService.getStyleList('default.clusterParam');
+        distance = styleListService.getStyleList('default.distance');
+        style = (feature, resolution) => {
+            const baseStyle = styleService.createStyle(styleListService.getStyleList('default.clusterStyle'), feature, resolution);
+            return styleService.createClusterStyle(feature, resolution, clusterParam, baseStyle);
+        };
+    }
+    else {
+        style = (feature, resolution) => styleService.createStyle(styleListService.getStyleList('default.style'), feature, resolution);
+    }
+    let source;
+    if (styleListService.getStyleList(layerTitle.toString() + '.clusterStyle')) {
+        const sourceOptions = {
+            distance,
+            type: 'cluster',
+            queryable: true
+        };
+        source = new ClusterDataSource(Object.assign(sourceOptions, imposedSourceOptions));
+        source.ol.source.addFeatures(olFeatures);
+    }
+    else if (styleListService.getStyleList(layerTitle.toString())) {
+        const sourceOptions = {
+            type: 'vector',
+            queryable: true
+        };
+        source = new FeatureDataSource(Object.assign(sourceOptions, imposedSourceOptions));
+        source.ol.addFeatures(olFeatures);
+    }
+    else if (styleListService.getStyleList('default.clusterStyle') &&
+        features[0].geometry.type === 'Point') {
+        const sourceOptions = {
+            distance,
+            type: 'cluster',
+            queryable: true
+        };
+        source = new ClusterDataSource(Object.assign(sourceOptions, imposedSourceOptions));
+        source.ol.source.addFeatures(olFeatures);
+    }
+    else {
+        const sourceOptions = {
+            type: 'vector',
+            queryable: true
+        };
+        source = new FeatureDataSource(Object.assign(sourceOptions, imposedSourceOptions));
+        source.ol.addFeatures(olFeatures);
+    }
+    const layer = new VectorLayer(Object.assign({
+        title: layerTitle,
+        id: layerId || uuid(),
+        isIgoInternalLayer: true,
+        source,
+        style
+    }, imposedLayerOptions));
+    map.addLayer(layer);
+    if (zoomTo) {
+        moveToOlFeatures(map.viewController, olFeatures);
+    }
+    return layer;
+}
+function padTo2Digits(num) {
+    return num.toString().padStart(2, '0');
+}
+export function handleFileImportSuccess(file, features, map, contextUri, messageService, layerService, confirmDialogService, styleListService, styleService) {
+    if (features.length === 0) {
+        handleNothingToImportError(file, messageService);
+        return;
+    }
+    let layerTitle = computeLayerTitleFromFile(file);
+    const obs$ = confirmDialogService
+        ? confirmDialogService.open('igo.geo.import.promptStoreToIdb')
+        : of(false);
+    obs$.pipe(first()).subscribe((confirm) => {
+        const d = new Date();
+        const dformat = [
+            d.getFullYear(),
+            padTo2Digits(d.getMonth() + 1),
+            padTo2Digits(d.getDate())
+        ].join('/') +
+            ' ' +
+            [padTo2Digits(d.getHours()), padTo2Digits(d.getMinutes())].join(':');
+        layerTitle = confirm ? `${layerTitle} (${dformat})` : layerTitle;
+        if (!styleListService) {
+            addLayerAndFeaturesToMap(features, map, contextUri, layerTitle, layerService, confirm);
+        }
+        else {
+            addLayerAndFeaturesStyledToMap(features, map, layerTitle, styleListService, styleService);
+        }
+        messageService.success('igo.geo.dropGeoFile.success.text', 'igo.geo.dropGeoFile.success.title', undefined, { value: layerTitle });
+    });
+}
+export function handleFileImportError(file, error, messageService, sizeMb) {
+    sizeMb = sizeMb ? sizeMb : 30;
+    const errMapping = {
+        'Invalid file': handleInvalidFileImportError,
+        'File is too large': handleSizeFileImportError,
+        'Failed to read file': handleUnreadbleFileImportError,
+        'Invalid SRS definition': handleSRSImportError,
+        'Error 500 with OGRE': handleOgreServerImportError
+    };
+    errMapping[error.message](file, error, messageService, sizeMb);
+}
+export function handleInvalidFileImportError(file, error, messageService) {
+    messageService.error('igo.geo.dropGeoFile.invalid.text', 'igo.geo.dropGeoFile.invalid.title', undefined, {
+        value: file.name,
+        mimeType: file.type
+    });
+}
+export function handleUnreadbleFileImportError(file, error, messageService) {
+    messageService.error('igo.geo.dropGeoFile.unreadable.text', 'igo.geo.dropGeoFile.unreadable.title', undefined, { value: file.name });
+}
+export function handleSizeFileImportError(file, error, messageService, sizeMb) {
+    messageService.error('igo.geo.dropGeoFile.tooLarge.text', 'igo.geo.dropGeoFile.tooLarge.title', undefined, {
+        value: file.name,
+        size: sizeMb
+    });
+}
+export function handleNothingToImportError(file, messageService) {
+    messageService.error('igo.geo.dropGeoFile.empty.text', 'igo.geo.dropGeoFile.empty.title', undefined, {
+        value: file.name,
+        mimeType: file.type
+    });
+}
+export function handleSRSImportError(file, messageService) {
+    messageService.error('igo.geo.dropGeoFile.invalidSRS.text', 'igo.geo.dropGeoFile.invalidSRS.title', undefined, {
+        value: file.name,
+        mimeType: file.type
+    });
+}
+export function handleOgreServerImportError(file, error, messageService) {
+    messageService.error('igo.geo.dropGeoFile.ogreServer.text', 'igo.geo.dropGeoFile.ogreServer.title');
+}
+export function getFileExtension(file) {
+    return file.name.split('.').pop().toLowerCase();
+}
+export function computeLayerTitleFromFile(file) {
+    return file.name.substr(0, file.name.lastIndexOf('.'));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/import-export/shared/import.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { MessageService } from '@igo2/core';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\nimport { FeatureDataSourceOptions } from '../../datasource/shared/datasources/feature-datasource.interface';\nimport { Feature } from '../../feature/shared/feature.interfaces';\nimport {\n  featureToOl,\n  moveToOlFeatures,\n  computeOlFeaturesExtent\n} from '../../feature/shared/feature.utils';\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\nimport { IgoMap } from '../../map/shared/map';\nimport { QueryableDataSourceOptions } from '../../query/shared/query.interfaces';\nimport { StyleService } from '../../style/style-service/style.service';\nimport { StyleByAttribute } from '../../style/shared/vector/vector-style.interface';\nimport { StyleListService } from '../../style/style-list/style-list.service';\nimport { ClusterParam } from '../../layer/shared/clusterParam';\nimport { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';\nimport { ClusterDataSourceOptions } from '../../datasource/shared/datasources/cluster-datasource.interface';\nimport { uuid } from '@igo2/utils';\nimport {\n  featureRandomStyle,\n  featureRandomStyleFunction\n} from '../../style/shared/feature/feature-style';\nimport { LayerService } from '../../layer/shared/layer.service';\nimport { ConfirmDialogService } from '@igo2/common';\nimport { first, of } from 'rxjs';\n\nexport function addLayerAndFeaturesToMap(\n  features: Feature[],\n  map: IgoMap,\n  contextUri: string,\n  layerTitle: string,\n  layerService: LayerService,\n  storeToIdb: boolean = false\n): VectorLayer {\n  const olFeatures = features.map((feature: Feature) =>\n    featureToOl(feature, map.projection)\n  );\n\n  const id = uuid();\n  const sourceOptions: FeatureDataSourceOptions & QueryableDataSourceOptions = {\n    id,\n    type: 'vector',\n    queryable: true\n  };\n  const source = new FeatureDataSource(sourceOptions);\n  source.ol.addFeatures(olFeatures);\n  let randomStyle;\n  let editable: boolean = false;\n  if (\n    olFeatures[0].getKeys().includes('_style') ||\n    olFeatures[0].getKeys().includes('_mapTitle')\n  ) {\n    randomStyle = featureRandomStyleFunction();\n  } else {\n    randomStyle = featureRandomStyle();\n    editable = true;\n  }\n  const layer = layerService.createLayer({\n    id,\n    title: layerTitle,\n    workspace: { enabled: true, searchIndexEnabled: true },\n    isIgoInternalLayer: true,\n    source,\n    igoStyle: { editable },\n    idbInfo: { firstLoad: true, storeToIdb, contextUri: contextUri || '*' },\n    style: randomStyle\n  }) as VectorLayer;\n  layer.setExtent(computeOlFeaturesExtent(olFeatures, map.viewProjection));\n  map.addLayer(layer);\n  moveToOlFeatures(map.viewController, olFeatures);\n\n  return layer;\n}\n\nexport function addLayerAndFeaturesStyledToMap(\n  features: Feature[],\n  map: IgoMap,\n  layerTitle: string,\n  styleListService: StyleListService,\n  styleService: StyleService,\n  layerId?: string,\n  imposedSourceOptions?,\n  imposedLayerOptions?,\n  zoomTo: boolean = true\n): VectorLayer {\n  const olFeatures = features.map((feature: Feature) =>\n    featureToOl(feature, map.projection)\n  );\n  let style;\n  let distance: number;\n\n  if (\n    styleListService.getStyleList(layerTitle.toString() + '.styleByAttribute')\n  ) {\n    const styleByAttribute: StyleByAttribute = styleListService.getStyleList(\n      layerTitle.toString() + '.styleByAttribute'\n    );\n\n    style = (feature, resolution) => {\n      return styleService.createStyleByAttribute(\n        feature,\n        styleByAttribute,\n        resolution\n      );\n    };\n  } else if (\n    styleListService.getStyleList(layerTitle.toString() + '.clusterStyle')\n  ) {\n    const clusterParam: ClusterParam = styleListService.getStyleList(\n      layerTitle.toString() + '.clusterParam'\n    );\n    distance = styleListService.getStyleList(\n      layerTitle.toString() + '.distance'\n    );\n\n    style = (feature, resolution) => {\n      const baseStyle = styleService.createStyle(\n        styleListService.getStyleList(layerTitle.toString() + '.clusterStyle'),\n        feature,\n        resolution\n      );\n      return styleService.createClusterStyle(\n        feature,\n        resolution,\n        clusterParam,\n        baseStyle\n      );\n    };\n  } else if (styleListService.getStyleList(layerTitle.toString() + '.style')) {\n    style = (feature, resolution) =>\n      styleService.createStyle(\n        styleListService.getStyleList(layerTitle.toString() + '.style'),\n        feature,\n        resolution\n      );\n  } else if (\n    styleListService.getStyleList('default.clusterStyle') &&\n    features[0].geometry.type === 'Point'\n  ) {\n    const clusterParam: ClusterParam = styleListService.getStyleList(\n      'default.clusterParam'\n    );\n    distance = styleListService.getStyleList('default.distance');\n\n    style = (feature, resolution) => {\n      const baseStyle = styleService.createStyle(\n        styleListService.getStyleList('default.clusterStyle'),\n        feature,\n        resolution\n      );\n      return styleService.createClusterStyle(\n        feature,\n        resolution,\n        clusterParam,\n        baseStyle\n      );\n    };\n  } else {\n    style = (feature, resolution) =>\n      styleService.createStyle(\n        styleListService.getStyleList('default.style'),\n        feature,\n        resolution\n      );\n  }\n\n  let source;\n  if (styleListService.getStyleList(layerTitle.toString() + '.clusterStyle')) {\n    const sourceOptions: ClusterDataSourceOptions & QueryableDataSourceOptions =\n      {\n        distance,\n        type: 'cluster',\n        queryable: true\n      };\n    source = new ClusterDataSource(\n      Object.assign(sourceOptions, imposedSourceOptions)\n    );\n    source.ol.source.addFeatures(olFeatures);\n  } else if (styleListService.getStyleList(layerTitle.toString())) {\n    const sourceOptions: FeatureDataSourceOptions & QueryableDataSourceOptions =\n      {\n        type: 'vector',\n        queryable: true\n      };\n    source = new FeatureDataSource(\n      Object.assign(sourceOptions, imposedSourceOptions)\n    );\n    source.ol.addFeatures(olFeatures);\n  } else if (\n    styleListService.getStyleList('default.clusterStyle') &&\n    features[0].geometry.type === 'Point'\n  ) {\n    const sourceOptions: ClusterDataSourceOptions & QueryableDataSourceOptions =\n      {\n        distance,\n        type: 'cluster',\n        queryable: true\n      };\n    source = new ClusterDataSource(\n      Object.assign(sourceOptions, imposedSourceOptions)\n    );\n    source.ol.source.addFeatures(olFeatures);\n  } else {\n    const sourceOptions: FeatureDataSourceOptions & QueryableDataSourceOptions =\n      {\n        type: 'vector',\n        queryable: true\n      };\n    source = new FeatureDataSource(\n      Object.assign(sourceOptions, imposedSourceOptions)\n    );\n    source.ol.addFeatures(olFeatures);\n  }\n\n  const layer = new VectorLayer(\n    Object.assign(\n      {\n        title: layerTitle,\n        id: layerId || uuid(),\n        isIgoInternalLayer: true,\n        source,\n        style\n      },\n      imposedLayerOptions\n    )\n  );\n  map.addLayer(layer);\n  if (zoomTo) {\n    moveToOlFeatures(map.viewController, olFeatures);\n  }\n  return layer;\n}\n\nfunction padTo2Digits(num) {\n  return num.toString().padStart(2, '0');\n}\n\nexport function handleFileImportSuccess(\n  file: File,\n  features: Feature[],\n  map: IgoMap,\n  contextUri: string,\n  messageService: MessageService,\n  layerService: LayerService,\n  confirmDialogService?: ConfirmDialogService,\n  styleListService?: StyleListService,\n  styleService?: StyleService\n) {\n  if (features.length === 0) {\n    handleNothingToImportError(file, messageService);\n    return;\n  }\n\n  let layerTitle = computeLayerTitleFromFile(file);\n\n  const obs$ = confirmDialogService\n    ? confirmDialogService.open('igo.geo.import.promptStoreToIdb')\n    : of(false);\n\n  obs$.pipe(first()).subscribe((confirm) => {\n    const d = new Date();\n    const dformat =\n      [\n        d.getFullYear(),\n        padTo2Digits(d.getMonth() + 1),\n        padTo2Digits(d.getDate())\n      ].join('/') +\n      ' ' +\n      [padTo2Digits(d.getHours()), padTo2Digits(d.getMinutes())].join(':');\n\n    layerTitle = confirm ? `${layerTitle} (${dformat})` : layerTitle;\n    if (!styleListService) {\n      addLayerAndFeaturesToMap(\n        features,\n        map,\n        contextUri,\n        layerTitle,\n        layerService,\n        confirm\n      );\n    } else {\n      addLayerAndFeaturesStyledToMap(\n        features,\n        map,\n        layerTitle,\n        styleListService,\n        styleService\n      );\n    }\n\n    messageService.success(\n      'igo.geo.dropGeoFile.success.text',\n      'igo.geo.dropGeoFile.success.title',\n      undefined,\n      { value: layerTitle }\n    );\n  });\n}\n\nexport function handleFileImportError(\n  file: File,\n  error: Error,\n  messageService: MessageService,\n  sizeMb?: number\n) {\n  sizeMb = sizeMb ? sizeMb : 30;\n  const errMapping = {\n    'Invalid file': handleInvalidFileImportError,\n    'File is too large': handleSizeFileImportError,\n    'Failed to read file': handleUnreadbleFileImportError,\n    'Invalid SRS definition': handleSRSImportError,\n    'Error 500 with OGRE': handleOgreServerImportError\n  };\n  errMapping[error.message](file, error, messageService, sizeMb);\n}\n\nexport function handleInvalidFileImportError(\n  file: File,\n  error: Error,\n  messageService: MessageService\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.invalid.text',\n    'igo.geo.dropGeoFile.invalid.title',\n    undefined,\n    {\n      value: file.name,\n      mimeType: file.type\n    }\n  );\n}\n\nexport function handleUnreadbleFileImportError(\n  file: File,\n  error: Error,\n  messageService: MessageService\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.unreadable.text',\n    'igo.geo.dropGeoFile.unreadable.title',\n    undefined,\n    { value: file.name }\n  );\n}\n\nexport function handleSizeFileImportError(\n  file: File,\n  error: Error,\n  messageService: MessageService,\n  sizeMb: number\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.tooLarge.text',\n    'igo.geo.dropGeoFile.tooLarge.title',\n    undefined,\n    {\n      value: file.name,\n      size: sizeMb\n    }\n  );\n}\n\nexport function handleNothingToImportError(\n  file: File,\n  messageService: MessageService\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.empty.text',\n    'igo.geo.dropGeoFile.empty.title',\n    undefined,\n    {\n      value: file.name,\n      mimeType: file.type\n    }\n  );\n}\n\nexport function handleSRSImportError(\n  file: File,\n  messageService: MessageService\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.invalidSRS.text',\n    'igo.geo.dropGeoFile.invalidSRS.title',\n    undefined,\n    {\n      value: file.name,\n      mimeType: file.type\n    }\n  );\n}\n\nexport function handleOgreServerImportError(\n  file: File,\n  error: Error,\n  messageService: MessageService\n) {\n  messageService.error(\n    'igo.geo.dropGeoFile.ogreServer.text',\n    'igo.geo.dropGeoFile.ogreServer.title'\n  );\n}\n\nexport function getFileExtension(file: File): string {\n  return file.name.split('.').pop().toLowerCase();\n}\n\nexport function computeLayerTitleFromFile(file: File): string {\n  return file.name.substr(0, file.name.lastIndexOf('.'));\n}\n"]}

package/esm2022/lib/import-export/shared/index.mjs

@@ -0,0 +1,11 @@
+export * from './drop-geo-file.directive';
+export * from './export.errors';
+export * from './export.interface';
+export * from './export.service';
+export * from './export.type';
+export * from './export.utils';
+export * from './import.errors';
+export * from './import.interface';
+export * from './import.service';
+export * from './import.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9pbXBvcnQtZXhwb3J0L3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJvcC1nZW8tZmlsZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9leHBvcnQuZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vZXhwb3J0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2V4cG9ydC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZXhwb3J0LnR5cGUnO1xuZXhwb3J0ICogZnJvbSAnLi9leHBvcnQudXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbXBvcnQuZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vaW1wb3J0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2ltcG9ydC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaW1wb3J0LnV0aWxzJztcbiJdfQ==