@igo2/geo 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/import-export/import-export/import-export.component.mjs

@@ -0,0 +1,1350 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { UntypedFormBuilder, Validators } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { MessageService, LanguageService, ConfigService, StorageService } from '@igo2/core';
+import { strEnum } from '@igo2/utils';
+import { IgoMap } from '../../map/shared/map';
+import { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import olPoint from 'ol/geom/Point';
+import { circular } from 'ol/geom/Polygon';
+import { handleFileExportError, handleFileExportSuccess } from '../shared/export.utils';
+import { ExportFormat, EncodingFormat } from '../shared/export.type';
+import { ExportService } from '../shared/export.service';
+import { ImportService } from '../shared/import.service';
+import { handleFileImportSuccess, handleFileImportError } from '../shared/import.utils';
+import { StyleService } from '../../style/style-service/style.service';
+import { StyleListService } from '../../style/style-list/style-list.service';
+import { skipWhile } from 'rxjs/operators';
+import { ConfirmDialogService } from '@igo2/common';
+import { DownloadService } from '../../download/shared/download.service';
+import { computeProjectionsConstraints } from '../../map/shared';
+import { LayerService } from '../../layer/shared/layer.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared/import.service";
+import * as i2 from "../shared/export.service";
+import * as i3 from "@igo2/core";
+import * as i4 from "../../style/style-list/style-list.service";
+import * as i5 from "../../style/style-service/style.service";
+import * as i6 from "@angular/forms";
+import * as i7 from "../../download/shared/download.service";
+import * as i8 from "../../layer/shared/layer.service";
+import * as i9 from "@igo2/common";
+import * as i10 from "@angular/material/tooltip";
+import * as i11 from "@angular/common";
+import * as i12 from "@angular/material/button";
+import * as i13 from "@angular/material/button-toggle";
+import * as i14 from "@angular/material/form-field";
+import * as i15 from "@angular/material/select";
+import * as i16 from "@angular/material/core";
+import * as i17 from "@angular/material/input";
+import * as i18 from "@angular/material/slide-toggle";
+import * as i19 from "@ngx-translate/core";
+function ImportExportComponent_form_8_mat_option_7_p_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "p", 16);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const projection_r6 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind2(2, 1, "igo.geo.importExportForm.projections." + projection_r6.translateKey, projection_r6), " ");
+} }
+function ImportExportComponent_form_8_mat_option_7_p_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "p", 16);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const projection_r6 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", projection_r6.alias, " ");
+} }
+function ImportExportComponent_form_8_mat_option_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 14);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_8_mat_option_7_Template_mat_option_click_0_listener($event) { return $event.stopPropagation(); });
+    i0.ɵɵtemplate(1, ImportExportComponent_form_8_mat_option_7_p_1_Template, 3, 4, "p", 15);
+    i0.ɵɵtemplate(2, ImportExportComponent_form_8_mat_option_7_p_2_Template, 2, 1, "p", 15);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const projection_r6 = ctx.$implicit;
+    i0.ɵɵproperty("value", projection_r6);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", projection_r6.translateKey);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", !projection_r6.translateKey);
+} }
+function ImportExportComponent_form_8_Template(rf, ctx) { if (rf & 1) {
+    const _r13 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "form", 5)(1, "div", 6)(2, "mat-form-field")(3, "mat-label");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(6, "mat-select", 7);
+    i0.ɵɵlistener("valueChange", function ImportExportComponent_form_8_Template_mat_select_valueChange_6_listener($event) { i0.ɵɵrestoreView(_r13); const ctx_r12 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r12.inputProj = $event); });
+    i0.ɵɵtemplate(7, ImportExportComponent_form_8_mat_option_7_Template, 3, 3, "mat-option", 8);
+    i0.ɵɵpipe(8, "async");
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵelementStart(9, "div", 9);
+    i0.ɵɵpipe(10, "translate");
+    i0.ɵɵpipe(11, "translate");
+    i0.ɵɵelementStart(12, "button", 10);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_8_Template_button_click_12_listener() { i0.ɵɵrestoreView(_r13); const _r5 = i0.ɵɵreference(19); return i0.ɵɵresetView(_r5.click()); });
+    i0.ɵɵpipe(13, "async");
+    i0.ɵɵtext(14);
+    i0.ɵɵpipe(15, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(16, "igo-spinner", 11);
+    i0.ɵɵpipe(17, "async");
+    i0.ɵɵelementStart(18, "input", 12, 13);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_8_Template_input_click_18_listener() { i0.ɵɵrestoreView(_r13); const _r5 = i0.ɵɵreference(19); return i0.ɵɵresetView(_r5.value = null); })("change", function ImportExportComponent_form_8_Template_input_change_18_listener($event) { i0.ɵɵrestoreView(_r13); const ctx_r16 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r16.importFiles($event.target.files)); });
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r0.importForm);
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(5, 10, "igo.geo.importExportForm.importProjPlaceholder"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("value", ctx_r0.inputProj);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(8, 12, ctx_r0.projections$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("matTooltip", ctx_r0.importForm.invalid ? i0.ɵɵpipeBind1(10, 14, "igo.geo.importExportForm.projections.choose") : i0.ɵɵpipeBind1(11, 16, "igo.geo.importExportForm.importButton"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("disabled", ctx_r0.importForm.invalid || i0.ɵɵpipeBind1(13, 18, ctx_r0.loading$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(15, 20, "igo.geo.importExportForm.importButton"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("shown", i0.ɵɵpipeBind1(17, 22, ctx_r0.loading$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵstyleProp("display", "none");
+} }
+const _c0 = function (a0) { return { size: a0 }; };
+function ImportExportComponent_section_9_div_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div")(1, "h4");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(4, "ul")(5, "li");
+    i0.ɵɵtext(6);
+    i0.ɵɵpipe(7, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(8, "li");
+    i0.ɵɵtext(9);
+    i0.ɵɵpipe(10, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(11, "li");
+    i0.ɵɵtext(12);
+    i0.ɵɵpipe(13, "translate");
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r17 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 4, "igo.geo.importExportForm.importClarifications"));
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind2(7, 6, "igo.geo.importExportForm.importSizeMax", i0.ɵɵpureFunction1(13, _c0, ctx_r17.fileSizeMb)), " ");
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(10, 9, "igo.geo.importExportForm.importFormatAuthorized"), " ");
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(13, 11, "igo.geo.importExportForm.importShpZip"));
+} }
+function ImportExportComponent_section_9_igo_custom_html_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "igo-custom-html", 20);
+} if (rf & 2) {
+    const ctx_r18 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("html", ctx_r18.importHtmlClarifications);
+} }
+function ImportExportComponent_section_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "section", 17);
+    i0.ɵɵtemplate(1, ImportExportComponent_section_9_div_1_Template, 14, 15, "div", 18);
+    i0.ɵɵtemplate(2, ImportExportComponent_section_9_igo_custom_html_2_Template, 1, 1, "igo-custom-html", 19);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r1.importHtmlClarifications === "");
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r1.importHtmlClarifications !== "");
+} }
+function ImportExportComponent_section_10_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "section", 17)(1, "h4");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 1, "igo.geo.importExportForm.exportNoLayersExportable"));
+} }
+function ImportExportComponent_form_12_span_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span", 31);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r19 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate2(" (+", ctx_r19.layers.length - 1, " ", i0.ɵɵpipeBind1(2, 2, (ctx_r19.layers == null ? null : ctx_r19.layers.length) === 2 ? "igo.geo.importExportForm.other" : "igo.geo.importExportForm.others"), ") ");
+} }
+function ImportExportComponent_form_12_mat_option_10_mat_slide_toggle_4_Template(rf, ctx) { if (rf & 1) {
+    const _r33 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 34);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_12_mat_option_10_mat_slide_toggle_4_Template_mat_slide_toggle_click_0_listener($event) { i0.ɵɵrestoreView(_r33); const layer_r29 = i0.ɵɵnextContext().$implicit; const ctx_r31 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r31.onlySelectedClick($event, layer_r29.id)); })("checked", function ImportExportComponent_form_12_mat_option_10_mat_slide_toggle_4_Template_mat_slide_toggle_checked_0_listener() { i0.ɵɵrestoreView(_r33); const layer_r29 = i0.ɵɵnextContext().$implicit; const ctx_r34 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r34.inLayersIdToExportSelectionOnly(layer_r29)); })("change", function ImportExportComponent_form_12_mat_option_10_mat_slide_toggle_4_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r33); const layer_r29 = i0.ɵɵnextContext().$implicit; const ctx_r36 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r36.onlySelected($event, layer_r29.id)); });
+    i0.ɵɵelementStart(1, "small");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 1, "igo.geo.importExportForm.exportSelectedFeature"));
+} }
+const _c1 = function (a0) { return { "igo-export-layer-mat-option": a0 }; };
+function ImportExportComponent_form_12_mat_option_10_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 32);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_12_mat_option_10_Template_mat_option_click_0_listener($event) { return $event.stopPropagation(); });
+    i0.ɵɵelementStart(1, "p", 16);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(3, "p", 16);
+    i0.ɵɵtemplate(4, ImportExportComponent_form_12_mat_option_10_mat_slide_toggle_4_Template, 4, 3, "mat-slide-toggle", 33);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const layer_r29 = ctx.$implicit;
+    const ctx_r20 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(4, _c1, ctx_r20.layerHasSelectedFeatures(layer_r29)))("value", layer_r29.id);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(layer_r29.title);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", ctx_r20.layerHasSelectedFeatures(layer_r29));
+} }
+function ImportExportComponent_form_12_ng_container_18_mat_option_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const format_r40 = ctx.$implicit;
+    i0.ɵɵproperty("value", format_r40.key);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 2, "igo.geo.export.format." + format_r40.value), " ");
+} }
+function ImportExportComponent_form_12_ng_container_18_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, ImportExportComponent_form_12_ng_container_18_mat_option_1_Template, 3, 4, "mat-option", 35);
+    i0.ɵɵpipe(2, "keyvalue");
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r21 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(2, 1, i0.ɵɵpipeBind1(3, 3, ctx_r21.formats$)));
+} }
+function ImportExportComponent_form_12_mat_option_20_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 36);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, "igo.geo.export.noFormat.title"), " ");
+} }
+function ImportExportComponent_form_12_div_22_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 6)(1, "mat-form-field");
+    i0.ɵɵelement(2, "input", 37);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(2);
+    i0.ɵɵpropertyInterpolate("placeholder", i0.ɵɵpipeBind1(3, 1, "igo.geo.importExportForm.exportFileNamePlaceholder"));
+} }
+function ImportExportComponent_form_12_div_23_ng_container_6_mat_option_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-option", 2);
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const encoding_r43 = ctx.$implicit;
+    i0.ɵɵproperty("value", encoding_r43.key);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 2, "igo.geo.export.encoding." + encoding_r43.value), " ");
+} }
+function ImportExportComponent_form_12_div_23_ng_container_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, ImportExportComponent_form_12_div_23_ng_container_6_mat_option_1_Template, 3, 4, "mat-option", 35);
+    i0.ɵɵpipe(2, "keyvalue");
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r41 = i0.ɵɵnextContext(3);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(2, 1, i0.ɵɵpipeBind1(3, 3, ctx_r41.encodings$)));
+} }
+function ImportExportComponent_form_12_div_23_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 6)(1, "mat-form-field")(2, "mat-label");
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(5, "mat-select", 38);
+    i0.ɵɵtemplate(6, ImportExportComponent_form_12_div_23_ng_container_6_Template, 4, 5, "ng-container", 18);
+    i0.ɵɵpipe(7, "async");
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r24 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(4, 2, "igo.geo.importExportForm.encodingPlaceholder"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(7, 4, ctx_r24.encodings$).length !== 0);
+} }
+function ImportExportComponent_form_12_div_24_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 39)(1, "mat-slide-toggle", 40);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 2, "igo.geo.importExportForm.exportCombineResults"), " ");
+} }
+function ImportExportComponent_form_12_div_25_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 41)(1, "mat-slide-toggle", 42);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 2, "igo.geo.importExportForm.exportSeparator"), " ");
+} }
+function ImportExportComponent_form_12_div_26_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 43)(1, "mat-slide-toggle", 44);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 2, "igo.geo.importExportForm.exportFeatureInExtent"), " ");
+} }
+function ImportExportComponent_form_12_igo_custom_html_36_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "igo-custom-html", 20);
+} if (rf & 2) {
+    const ctx_r28 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("html", ctx_r28.exportHtmlClarifications);
+} }
+function ImportExportComponent_form_12_Template(rf, ctx) { if (rf & 1) {
+    const _r45 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "form", 5)(1, "div", 6)(2, "mat-form-field")(3, "mat-label");
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(6, "mat-select", 21);
+    i0.ɵɵlistener("valueChange", function ImportExportComponent_form_12_Template_mat_select_valueChange_6_listener($event) { i0.ɵɵrestoreView(_r45); const ctx_r44 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r44.layers = $event); });
+    i0.ɵɵelementStart(7, "mat-select-trigger");
+    i0.ɵɵtext(8);
+    i0.ɵɵtemplate(9, ImportExportComponent_form_12_span_9_Template, 3, 4, "span", 22);
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(10, ImportExportComponent_form_12_mat_option_10_Template, 5, 6, "mat-option", 23);
+    i0.ɵɵpipe(11, "async");
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵelementStart(12, "div", 6)(13, "mat-form-field")(14, "mat-label");
+    i0.ɵɵtext(15);
+    i0.ɵɵpipe(16, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(17, "mat-select", 24);
+    i0.ɵɵtemplate(18, ImportExportComponent_form_12_ng_container_18_Template, 4, 5, "ng-container", 18);
+    i0.ɵɵpipe(19, "async");
+    i0.ɵɵtemplate(20, ImportExportComponent_form_12_mat_option_20_Template, 3, 3, "mat-option", 25);
+    i0.ɵɵpipe(21, "async");
+    i0.ɵɵelementEnd()()();
+    i0.ɵɵtemplate(22, ImportExportComponent_form_12_div_22_Template, 4, 3, "div", 26);
+    i0.ɵɵtemplate(23, ImportExportComponent_form_12_div_23_Template, 8, 6, "div", 26);
+    i0.ɵɵtemplate(24, ImportExportComponent_form_12_div_24_Template, 4, 4, "div", 27);
+    i0.ɵɵtemplate(25, ImportExportComponent_form_12_div_25_Template, 4, 4, "div", 28);
+    i0.ɵɵtemplate(26, ImportExportComponent_form_12_div_26_Template, 4, 4, "div", 29);
+    i0.ɵɵelementStart(27, "div", 30)(28, "button", 10);
+    i0.ɵɵlistener("click", function ImportExportComponent_form_12_Template_button_click_28_listener() { i0.ɵɵrestoreView(_r45); const ctx_r46 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r46.handleExportFormSubmit(ctx_r46.form.value)); });
+    i0.ɵɵpipe(29, "async");
+    i0.ɵɵtext(30);
+    i0.ɵɵpipe(31, "translate");
+    i0.ɵɵpipe(32, "translate");
+    i0.ɵɵpipe(33, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(34, "igo-spinner", 11);
+    i0.ɵɵpipe(35, "async");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(36, ImportExportComponent_form_12_igo_custom_html_36_Template, 1, 1, "igo-custom-html", 19);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("formGroup", ctx_r3.form);
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(5, 18, "igo.geo.importExportForm.exportLayerPlaceholder"));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("value", ctx_r3.layers);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", ctx_r3.layers.length ? ctx_r3.getLayerTitleById(ctx_r3.layers[0]) : "", " ");
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r3.layers.length > 1);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngForOf", i0.ɵɵpipeBind1(11, 20, ctx_r3.exportableLayers$));
+    i0.ɵɵadvance(5);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(16, 22, "igo.geo.importExportForm.exportFormatPlaceholder"));
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(19, 24, ctx_r3.formats$).length !== 0);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(21, 26, ctx_r3.formats$).length === 0);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", ctx_r3.forceNaming && ctx_r3.form.value.format !== "URL");
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r3.form.value.format === "CSVcomma" || ctx_r3.form.value.format === "CSVsemicolon");
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r3.layers.length > 1 && (ctx_r3.form.value.format === "CSVcomma" || ctx_r3.form.value.format === "CSVsemicolon"));
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r3.layers.length > 1 && (ctx_r3.form.value.format === "CSVcomma" || ctx_r3.form.value.format === "CSVsemicolon") && ctx_r3.form.value.combineLayers);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r3.form.value.format !== "URL");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("disabled", !ctx_r3.form.valid || i0.ɵɵpipeBind1(29, 28, ctx_r3.loading$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", ctx_r3.form.value.format !== "URL" ? i0.ɵɵpipeBind1(31, 30, "igo.geo.importExportForm.exportButton") : ctx_r3.form.value.layers.length > 1 ? i0.ɵɵpipeBind1(32, 32, "igo.geo.importExportForm.exportButtonLinks") : i0.ɵɵpipeBind1(33, 34, "igo.geo.importExportForm.exportButtonLink"), " ");
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("shown", i0.ɵɵpipeBind1(35, 36, ctx_r3.loading$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", ctx_r3.exportHtmlClarifications !== "");
+} }
+export class ImportExportComponent {
+    importService;
+    exportService;
+    languageService;
+    messageService;
+    styleListService;
+    styleService;
+    formBuilder;
+    config;
+    cdRef;
+    storageService;
+    downloadService;
+    layerService;
+    confirmDialogService;
+    form;
+    importForm;
+    formats$ = new BehaviorSubject(undefined);
+    encodings$ = new BehaviorSubject(undefined);
+    exportableLayers$ = new BehaviorSubject([]);
+    loading$ = new BehaviorSubject(false);
+    forceNaming = false;
+    controlFormat = 'format';
+    layers$$;
+    exportableLayers$$;
+    formats$$;
+    encodings$$;
+    formLayer$$;
+    exportOptions$$;
+    importHtmlClarifications;
+    exportHtmlClarifications;
+    espgCodeRegex = new RegExp('^\\d{4,6}');
+    clientSideFileSizeMax;
+    fileSizeMb;
+    projections$ = new BehaviorSubject([]);
+    projectionsConstraints;
+    popupChecked = false;
+    previousLayerSpecs$ = new BehaviorSubject(undefined);
+    selectFirstProj = false;
+    map;
+    contextUri;
+    _projectionsLimitations = {};
+    set projectionsLimitations(value) {
+        this._projectionsLimitations = value;
+        this.computeProjections();
+    }
+    get projectionsLimitations() {
+        return this._projectionsLimitations || {};
+    }
+    /**
+     * Store that holds the available workspaces.
+     */
+    store;
+    selectedMode = 'import';
+    selectMode = new EventEmitter();
+    exportOptions$ = new BehaviorSubject(undefined);
+    exportOptionsChange = new EventEmitter();
+    get layers() {
+        return this.form.get('layers').value;
+    }
+    set layers(value) {
+        this.form.patchValue({ layers: value });
+    }
+    get inputProj() {
+        return this.importForm.get('inputProj').value;
+    }
+    set inputProj(value) {
+        this.importForm.patchValue({ inputProj: value });
+    }
+    get popupAllowed() {
+        return (this.storageService.get('importExportPopupAllowed') || false);
+    }
+    set popupAllowed(value) {
+        this.storageService.set('importExportPopupAllowed', value);
+    }
+    constructor(importService, exportService, languageService, messageService, styleListService, styleService, formBuilder, config, cdRef, storageService, downloadService, layerService, confirmDialogService) {
+        this.importService = importService;
+        this.exportService = exportService;
+        this.languageService = languageService;
+        this.messageService = messageService;
+        this.styleListService = styleListService;
+        this.styleService = styleService;
+        this.formBuilder = formBuilder;
+        this.config = config;
+        this.cdRef = cdRef;
+        this.storageService = storageService;
+        this.downloadService = downloadService;
+        this.layerService = layerService;
+        this.confirmDialogService = confirmDialogService;
+        this.loadConfig();
+        this.buildForm();
+        this.computeProjections();
+        this.importHtmlClarifications = this.languageService.translate.instant('igo.geo.importExportForm.importHtmlClarifications');
+        this.exportHtmlClarifications = this.languageService.translate.instant('igo.geo.importExportForm.exportHtmlClarifications');
+    }
+    ngOnInit() {
+        this.layers$$ = this.map.layers$.subscribe((layers) => {
+            this.exportableLayers$.next(layers.filter((layer) => {
+                return ((layer instanceof VectorLayer && layer.exportable === true) ||
+                    (layer.dataSource.options.download &&
+                        layer.dataSource.options.download.url));
+            }));
+        });
+        const configFileSizeMb = this.config.getConfig('importExport.clientSideFileSizeMaxMb');
+        this.clientSideFileSizeMax =
+            (configFileSizeMb ? configFileSizeMb : 30) * Math.pow(1024, 2);
+        this.fileSizeMb = this.clientSideFileSizeMax / Math.pow(1024, 2);
+        this.exportOptions$$ = this.exportOptions$
+            .pipe(skipWhile((exportOptions) => !exportOptions))
+            .subscribe((exportOptions) => {
+            this.form.patchValue(exportOptions, { emitEvent: true });
+            if (exportOptions.layers) {
+                this.computeFormats(exportOptions.layers.map((l) => this.map.getLayerById(l)));
+            }
+        });
+        this.formLayer$$ = this.form
+            .get('format')
+            .valueChanges.subscribe((format) => {
+            const ogreFormats = Object.keys(ExportService.ogreFormats);
+            if (!this.popupChecked &&
+                this.form.get('layers').value?.length > 1 &&
+                (ogreFormats.indexOf(format) >= 0 || format === ExportFormat.URL)) {
+                if (!this.handlePopup(true)) {
+                    this.form.patchValue({ format: undefined }, { emitEvent: false });
+                }
+            }
+        });
+        this.formLayer$$ = this.form
+            .get('layers')
+            .valueChanges.subscribe((layersId) => {
+            this.handlePreviousLayerSpecs();
+            const selectedLayers = layersId instanceof Array ? layersId : [layersId];
+            this.form.patchValue({ layers: selectedLayers }, { emitEvent: false });
+            const layers = selectedLayers.map((l) => this.map.getLayerById(l));
+            this.computeFormats(layers);
+            if (Object.keys(this.formats$.value).indexOf(this.form.value.format) ===
+                -1) {
+                this.form.patchValue({ format: undefined });
+            }
+            this.loading$.next(true);
+            const previousSpecs = [];
+            layers.forEach((layer) => {
+                if (layer instanceof VectorLayer &&
+                    layer.dataSource.ol.getFeatures().length === 0) {
+                    previousSpecs.push({
+                        id: layer.id,
+                        visible: layer.visible,
+                        opacity: layer.opacity,
+                        queryable: layer.queryable
+                    });
+                    layer.opacity = 0;
+                    layer.visible = true;
+                }
+            });
+            this.previousLayerSpecs$.next(previousSpecs);
+            setTimeout(() => {
+                this.loading$.next(false);
+            }, 500);
+        });
+        this.formats$$ = this.formats$
+            .pipe(skipWhile((formats) => !formats))
+            .subscribe((formats) => {
+            if (Object.keys(formats).length === 1) {
+                this.form.patchValue({ format: formats[Object.keys(formats)[0]] });
+            }
+        });
+        this.encodings$$ = this.encodings$
+            .pipe(skipWhile((encodings) => !encodings))
+            .subscribe((encodings) => {
+            if (Object.keys(encodings).length === 1) {
+                this.form.patchValue({
+                    encoding: encodings[Object.keys(encodings)[0]]
+                });
+            }
+        });
+        this.exportableLayers$$ = this.exportableLayers$
+            .pipe(skipWhile((layers) => !layers))
+            .subscribe((layers) => {
+            if (layers.length === 1) {
+                this.form.patchValue({ layers: layers[0].id });
+            }
+        });
+        this.form.controls[this.controlFormat].valueChanges.subscribe((format) => {
+            if (format === ExportFormat.CSVcomma ||
+                format === ExportFormat.CSVsemicolon) {
+                this.form.patchValue({ encoding: EncodingFormat.LATIN1 });
+            }
+            else {
+                this.form.patchValue({ encoding: EncodingFormat.UTF8 });
+            }
+            this.cdRef.detectChanges();
+        });
+        if (this.selectFirstProj) {
+            if (this.projections$.value.length === 0) {
+                this.importForm.patchValue({
+                    inputProj: {
+                        translateKey: 'nad83',
+                        alias: 'NAD83',
+                        code: 'EPSG:4326',
+                        zone: ''
+                    }
+                });
+            }
+            else {
+                this.importForm.patchValue({ inputProj: this.projections$.value[0] });
+            }
+        }
+        else {
+            this.importForm.patchValue({ inputProj: undefined });
+        }
+    }
+    computeProjections() {
+        this.projectionsConstraints = computeProjectionsConstraints(this.projectionsLimitations);
+        const projections = [];
+        if (this.projectionsConstraints.nad83) {
+            projections.push({
+                translateKey: 'nad83',
+                alias: 'NAD83',
+                code: 'EPSG:4269',
+                zone: ''
+            });
+        }
+        if (this.projectionsConstraints.wgs84) {
+            projections.push({
+                translateKey: 'wgs84',
+                alias: 'WGS84',
+                code: 'EPSG:4326',
+                zone: ''
+            });
+        }
+        if (this.projectionsConstraints.webMercator) {
+            projections.push({
+                translateKey: 'webMercator',
+                alias: 'Web Mercator',
+                code: 'EPSG:3857',
+                zone: ''
+            });
+        }
+        if (this.projectionsConstraints.mtm) {
+            // all mtm zones
+            const minZone = this.projectionsConstraints.mtmZone.minZone;
+            const maxZone = this.projectionsConstraints.mtmZone.maxZone;
+            for (let mtmZone = minZone; mtmZone <= maxZone; mtmZone++) {
+                const code = mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;
+                projections.push({
+                    translateKey: 'mtm',
+                    alias: `MTM ${mtmZone}`,
+                    code,
+                    zone: `${mtmZone}`
+                });
+            }
+        }
+        if (this.projectionsConstraints.utm) {
+            // all utm zones
+            const minZone = this.projectionsConstraints.utmZone.minZone;
+            const maxZone = this.projectionsConstraints.utmZone.maxZone;
+            for (let utmZone = minZone; utmZone <= maxZone; utmZone++) {
+                const code = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;
+                projections.push({
+                    translateKey: 'utm',
+                    alias: `UTM ${utmZone}`,
+                    code,
+                    zone: `${utmZone}`
+                });
+            }
+        }
+        let configProjection = [];
+        if (this.projectionsConstraints.projFromConfig) {
+            configProjection = this.config.getConfig('projections') || [];
+        }
+        this.projections$.next(configProjection.concat(projections));
+    }
+    getWorkspaceByLayerId(id) {
+        const wksFromLayerId = this.store
+            .all()
+            .find((workspace) => workspace
+            .layer.id === id);
+        if (wksFromLayerId) {
+            return wksFromLayerId;
+        }
+        return;
+    }
+    getLayerTitleById(id) {
+        return this.map.getLayerById(id)?.title;
+    }
+    layerHasSelectedFeatures(layer) {
+        const wksFromLayer = this.getWorkspaceByLayerId(layer.id);
+        if (wksFromLayer) {
+            const recs = wksFromLayer.entityStore.stateView.firstBy((record) => {
+                return record.state.selected === true;
+            });
+            return recs ? true : false;
+        }
+    }
+    onlySelected(event, id) {
+        let layersWithSelection = this.form.value.layersWithSelection;
+        if (event.checked) {
+            layersWithSelection.push(id);
+        }
+        else {
+            layersWithSelection = layersWithSelection.filter((layerId) => layerId !== id);
+        }
+        this.form.patchValue({ layersWithSelection });
+    }
+    onlySelectedClick(event, id) {
+        if (this.form.value.layers.find((layerId) => layerId === id)) {
+            event.stopPropagation();
+        }
+    }
+    inLayersIdToExportSelectionOnly(layer) {
+        return this.form.value.layersWithSelection.find((layerId) => layerId === layer.id)
+            ? true
+            : false;
+    }
+    ngOnDestroy() {
+        this.layers$$.unsubscribe();
+        this.exportableLayers$$.unsubscribe();
+        this.formats$$.unsubscribe();
+        this.encodings$$.unsubscribe();
+        this.formLayer$$.unsubscribe();
+        if (this.exportOptions$$) {
+            this.exportOptions$$.unsubscribe();
+        }
+        this.exportOptionsChange.emit(this.form.value);
+        this.handlePreviousLayerSpecs();
+    }
+    handlePreviousLayerSpecs() {
+        const previousSpecs = this.previousLayerSpecs$.value;
+        if (previousSpecs && previousSpecs.length) {
+            previousSpecs.forEach((specs) => {
+                const previousLayer = this.map.getLayerById(specs.id);
+                previousLayer.visible = specs.visible;
+                previousLayer.opacity = specs.opacity;
+                previousLayer.queryable = specs.queryable;
+            });
+        }
+        this.previousLayerSpecs$.next(undefined);
+    }
+    importFiles(files) {
+        let inputProj = this.inputProj.code;
+        if (this.espgCodeRegex.test(inputProj)) {
+            inputProj = `EPSG:${inputProj}`;
+        }
+        this.loading$.next(true);
+        for (const file of files) {
+            this.importService.import(file, inputProj).subscribe((features) => this.onFileImportSuccess(file, features), (error) => this.onFileImportError(file, error), () => {
+                this.loading$.next(false);
+            });
+        }
+    }
+    handlePopup(preCheck = true) {
+        const p1 = window.open('', 'popup', 'width=1, height=1');
+        p1.close();
+        const p2 = window.open('', 'popup', 'width=1, height=1');
+        if (!p2 || p2.closed || typeof p2.closed === 'undefined' || p2 === null) {
+            this.onPopupBlockedError(preCheck);
+            this.popupAllowed = false;
+        }
+        else {
+            p2.close();
+            this.popupAllowed = true;
+            this.popupChecked = true;
+        }
+        return this.popupAllowed;
+    }
+    handleExportFormSubmit(data) {
+        this.loading$.next(true);
+        const ogreFormats = Object.keys(ExportService.ogreFormats);
+        if (!this.popupChecked &&
+            data.layers.length > 1 &&
+            (ogreFormats.indexOf(data.format) >= 0 ||
+                data.format === ExportFormat.URL) &&
+            !this.popupAllowed) {
+            this.handlePopup();
+        }
+        let geomTypesCSV = [];
+        let featuresCSV = [];
+        let filename = '';
+        for (const [layerIndex, layer] of data.layers.entries()) {
+            const lay = this.map.getLayerById(layer);
+            if (!(data.format === ExportFormat.CSVsemicolon ||
+                data.format === ExportFormat.CSVcomma) ||
+                !data.combineLayers ||
+                data.layers.length === 1) {
+                filename = lay.title;
+                if (data.name) {
+                    filename = data.name;
+                }
+            }
+            else {
+                filename = this.languageService.translate.instant('igo.geo.export.combinedLayers');
+            }
+            const dSOptions = lay.dataSource.options;
+            if (data.format === ExportFormat.URL &&
+                dSOptions.download &&
+                (dSOptions.download.url || dSOptions.download.dynamicUrl)) {
+                setTimeout(() => {
+                    // better look an feel
+                    const url = dSOptions.download.url || dSOptions.download.dynamicUrl;
+                    url.match(/service=wfs/gi)
+                        ? this.downloadService.open(lay)
+                        : window.open(url, '_blank');
+                    this.loading$.next(false);
+                }, 500);
+                return;
+            }
+            const wks = this.getWorkspaceByLayerId(layer);
+            let olFeatures;
+            if (wks && wks.entityStore && wks.entityStore.stateView.all().length) {
+                if (data.layersWithSelection.indexOf(layer) !== -1 &&
+                    data.featureInMapExtent) {
+                    // Only export selected feature && into map extent
+                    olFeatures = wks.entityStore.stateView
+                        .all()
+                        .filter((e) => e.state.inMapExtent && e.state.selected)
+                        .map((e) => e.entity.ol);
+                }
+                else if (data.layersWithSelection.indexOf(layer) !== -1 &&
+                    !data.featureInMapExtent) {
+                    // Only export selected feature &&  (into map extent OR not)
+                    olFeatures = wks.entityStore.stateView
+                        .all()
+                        .filter((e) => e.state.selected)
+                        .map((e) => e.entity.ol);
+                }
+                else if (data.featureInMapExtent) {
+                    // Only into map extent
+                    olFeatures = wks.entityStore.stateView
+                        .all()
+                        .filter((e) => e.state.inMapExtent)
+                        .map((e) => e.entity.ol);
+                }
+                else {
+                    // All features
+                    olFeatures = wks.entityStore.stateView
+                        .all()
+                        .map((e) => e.entity.ol);
+                }
+            }
+            else {
+                const ol = lay.dataSource.ol;
+                if (data.featureInMapExtent) {
+                    olFeatures = ol.getFeaturesInExtent(lay.map.viewController.getExtent());
+                }
+                else {
+                    olFeatures = ol.getFeatures();
+                }
+                if (lay.dataSource instanceof ClusterDataSource) {
+                    olFeatures = olFeatures.flatMap((cluster) => cluster.get('features'));
+                }
+            }
+            let geomTypes = [];
+            if (data.format === ExportFormat.Shapefile ||
+                data.format === ExportFormat.GPX) {
+                olFeatures.forEach((olFeature) => {
+                    const featureGeomType = olFeature.getGeometry().getType();
+                    const currentGeomType = geomTypes.find((geomType) => geomType.geometryType === featureGeomType);
+                    if (currentGeomType) {
+                        currentGeomType.features.push(olFeature);
+                    }
+                    else {
+                        geomTypes.push({
+                            geometryType: featureGeomType,
+                            features: [olFeature]
+                        });
+                    }
+                });
+            }
+            else {
+                geomTypes = [{ geometryType: '', features: olFeatures }];
+            }
+            geomTypes.forEach((geomType) => {
+                geomType.features.forEach((feature) => {
+                    const radius = feature.get('rad');
+                    if (radius) {
+                        const center4326 = [
+                            feature.get('longitude'),
+                            feature.get('latitude')
+                        ];
+                        const circle = circular(center4326, radius, 500);
+                        circle.transform('EPSG:4326', feature.get('_projection'));
+                        feature.setGeometry(circle);
+                    }
+                });
+            });
+            if (data.format === ExportFormat.GPX) {
+                const gpxFeatureCnt = geomTypes.length;
+                geomTypes = geomTypes.filter((geomType) => ['LineString', 'Point'].includes(geomType.geometryType));
+                const gpxFeatureCntPointOrPoly = geomTypes.length;
+                if (gpxFeatureCnt > gpxFeatureCntPointOrPoly) {
+                    this.messageService.error('igo.geo.export.gpx.error.poly.text', 'igo.geo.export.gpx.error.poly.title', { timeOut: 20000 });
+                }
+            }
+            else if ((data.format === ExportFormat.CSVsemicolon ||
+                data.format === ExportFormat.CSVcomma) &&
+                data.combineLayers) {
+                geomTypes.forEach((geomType) => geomTypesCSV.push(geomType));
+                if (layerIndex !== data.layers.length - 1) {
+                    continue;
+                }
+                else {
+                    let previousFeature = undefined;
+                    geomTypesCSV.forEach((geomType) => {
+                        geomType.features.forEach((currentFeature) => {
+                            if (data.separator) {
+                                if (previousFeature) {
+                                    if (currentFeature.get('_featureStore').layer.options.title !==
+                                        previousFeature.get('_featureStore').layer.options.title) {
+                                        const titleEmptyRows = this.createTitleEmptyRows(previousFeature, currentFeature);
+                                        featuresCSV.push(titleEmptyRows[2]);
+                                        featuresCSV.push(titleEmptyRows[0]);
+                                        featuresCSV.push(titleEmptyRows[1]);
+                                    }
+                                }
+                                else {
+                                    const titleEmptyRows = this.createTitleEmptyRows(currentFeature, currentFeature);
+                                    featuresCSV.push(titleEmptyRows[0]);
+                                }
+                            }
+                            featuresCSV.push(currentFeature);
+                            previousFeature = currentFeature;
+                        });
+                    });
+                }
+            }
+            if (geomTypes.length === 0) {
+                this.loading$.next(false);
+                this.messageService.error('igo.geo.export.nothing.text', 'igo.geo.export.nothing.title', { timeOut: 20000 });
+            }
+            else {
+                if (!(data.format === ExportFormat.CSVsemicolon ||
+                    data.format === ExportFormat.CSVcomma) ||
+                    !data.combineLayers) {
+                    geomTypes.map((geomType) => this.exportService
+                        .export(geomType.features, data.format, filename + geomType.geometryType, data.encoding, this.map.projection)
+                        .subscribe(() => { }, (error) => this.onFileExportError(error), () => {
+                        this.onFileExportSuccess();
+                        geomType.features.forEach((feature) => {
+                            this.circleToPoint(feature);
+                        });
+                        this.loading$.next(false);
+                    }));
+                }
+            }
+        }
+        if ((data.format === ExportFormat.CSVsemicolon ||
+            data.format === ExportFormat.CSVcomma) &&
+            data.combineLayers) {
+            this.exportService
+                .export(featuresCSV, data.format, filename, data.encoding, this.map.projection)
+                .subscribe(() => { }, (error) => this.onFileExportError(error), () => {
+                this.onFileExportSuccess();
+                featuresCSV.forEach((feature) => {
+                    this.circleToPoint(feature);
+                });
+                this.loading$.next(false);
+            });
+        }
+    }
+    createTitleEmptyRows(previousFeature, currentFeature) {
+        const titleRow = currentFeature.clone();
+        const headerRow = currentFeature.clone();
+        const emptyRow = currentFeature.clone();
+        const previousFeatureKeys = previousFeature.getKeys();
+        let firstKeyPrevious = '';
+        for (const key in previousFeatureKeys) {
+            if (previousFeatureKeys[key] !== 'geometry') {
+                firstKeyPrevious = previousFeatureKeys[key];
+                break;
+            }
+        }
+        const currentFeatureKeys = currentFeature.getKeys();
+        let firstKeyCurrent = '';
+        for (const key in currentFeatureKeys) {
+            if (currentFeatureKeys[key] !== 'geometry') {
+                firstKeyCurrent = currentFeatureKeys[key];
+                break;
+            }
+        }
+        const allKeys = currentFeature.getKeys();
+        previousFeatureKeys.forEach((previousKey) => {
+            if (allKeys.includes(previousKey) && previousKey !== firstKeyPrevious) {
+                allKeys.push(previousKey);
+            }
+        });
+        allKeys.unshift(firstKeyPrevious);
+        let firstKeyAll = '';
+        for (const key in allKeys) {
+            if (allKeys[key] !== 'geometry') {
+                firstKeyAll = allKeys[key];
+                break;
+            }
+        }
+        allKeys.forEach((key) => {
+            const sameKeys = previousFeatureKeys.length === currentFeatureKeys.length &&
+                previousFeatureKeys.every((value, index) => value === currentFeatureKeys[index]);
+            if (key === firstKeyAll && !sameKeys) {
+                titleRow.set(key, currentFeature.get('_featureStore').layer.options.title +
+                    ' ===============>', true);
+                headerRow.set(key, key, true);
+                emptyRow.unset(key, true);
+            }
+            else if (key === firstKeyAll && sameKeys) {
+                titleRow.set(key, currentFeature.get('_featureStore').layer.options.title, true);
+                headerRow.set(key, key, true);
+                emptyRow.unset(key, true);
+            }
+            else if (key === firstKeyCurrent) {
+                titleRow.set(key, currentFeature.get('_featureStore').layer.options.title, true);
+                headerRow.set(key, key, true);
+                emptyRow.unset(key, true);
+            }
+            else if (key !== 'geometry') {
+                titleRow.unset(key, true);
+                headerRow.set(key, key, true);
+                emptyRow.unset(key, true);
+            }
+            else {
+                titleRow.unset(key, true);
+                emptyRow.unset(key, true);
+            }
+            if (!currentFeatureKeys.includes(key)) {
+                headerRow.unset(key, true);
+            }
+        });
+        const titleEmptyRows = [titleRow, headerRow, emptyRow];
+        return titleEmptyRows;
+    }
+    circleToPoint(feature) {
+        const radius = feature.get('rad');
+        if (radius) {
+            const point = new olPoint([
+                feature.get('longitude'),
+                feature.get('latitude')
+            ]);
+            point.transform('EPSG:4326', feature.get('_projection'));
+            feature.setGeometry(point);
+        }
+    }
+    buildForm() {
+        this.importForm = this.formBuilder.group({
+            inputProj: ['', [Validators.required]]
+        });
+        if (this.forceNaming) {
+            this.form = this.formBuilder.group({
+                format: ['', [Validators.required]],
+                layers: [[], [Validators.required]],
+                layersWithSelection: [[]],
+                encoding: [EncodingFormat.UTF8, [Validators.required]],
+                combineLayers: [true, [Validators.required]],
+                separator: [false, [Validators.required]],
+                featureInMapExtent: [false, [Validators.required]],
+                name: ['', [Validators.required]]
+            });
+        }
+        else {
+            this.form = this.formBuilder.group({
+                format: ['', [Validators.required]],
+                layers: [[], [Validators.required]],
+                layersWithSelection: [[]],
+                encoding: [EncodingFormat.UTF8, [Validators.required]],
+                combineLayers: [true, [Validators.required]],
+                separator: [false, [Validators.required]],
+                featureInMapExtent: [false, [Validators.required]]
+            });
+        }
+    }
+    onFileImportSuccess(file, features) {
+        const importExportOptions = this.config.getConfig('importExport');
+        const confirmDialogService = importExportOptions?.allowToStoreLayer
+            ? this.confirmDialogService
+            : undefined;
+        const importWithStyle = importExportOptions?.importWithStyle ||
+            this.config.getConfig('importWithStyle');
+        if (this.config.getConfig('importWithStyle')) {
+            console.warn(`
+      The location of this config importWithStyle is deprecated.
+      Please move this property within importExport configuration.
+      Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }
+      Refer to environnement.ts OR config/config.json
+      This legacy conversion will be deleted in 2024.
+      `);
+        }
+        if (!importWithStyle) {
+            handleFileImportSuccess(file, features, this.map, this.contextUri, this.messageService, this.layerService, confirmDialogService);
+        }
+        else {
+            handleFileImportSuccess(file, features, this.map, this.contextUri, this.messageService, this.layerService, confirmDialogService, this.styleListService, this.styleService);
+        }
+    }
+    onFileImportError(file, error) {
+        this.loading$.next(false);
+        handleFileImportError(file, error, this.messageService, this.fileSizeMb);
+    }
+    onPopupBlockedError(preCheck = true) {
+        this.loading$.next(false);
+        const extraMessage = preCheck
+            ? 'igo.geo.export.popupBlocked.selectAgain'
+            : 'igo.geo.export.popupBlocked.retry';
+        this.messageService.error('igo.geo.export.popupBlocked.text', 'igo.geo.export.popupBlocked.title', { timeOut: 20000 }, { extraMessage });
+    }
+    onFileExportError(error) {
+        this.loading$.next(false);
+        handleFileExportError(error, this.messageService);
+    }
+    loadConfig() {
+        if (this.config.getConfig('importExport.forceNaming') !== undefined) {
+            this.forceNaming = this.config.getConfig('importExport.forceNaming');
+        }
+        this.computeFormats();
+        this.loadEncodings();
+    }
+    encodingDefaultValue(format) {
+        if (format === ExportFormat.CSVcomma ||
+            format === ExportFormat.CSVsemicolon) {
+            this.form.patchValue({ encoding: EncodingFormat.LATIN1 });
+            return EncodingFormat.LATIN1;
+        }
+        else {
+            this.form.patchValue({ encoding: EncodingFormat.UTF8 });
+            return EncodingFormat.UTF8;
+        }
+    }
+    loadEncodings() {
+        this.encodings$.next(EncodingFormat);
+    }
+    computeFormats(layers) {
+        let appliedformats = Object.keys(ExportFormat);
+        const formatsType = {
+            onlyUrl: false,
+            onlyVector: false,
+            vectorAndUrl: false,
+            customList: false
+        };
+        const customList = [];
+        if (layers && layers.length) {
+            layers.forEach((layer) => {
+                if (!layer) {
+                    return;
+                }
+                if (layer.dataSource.options.download?.allowedFormats) {
+                    formatsType.customList = true;
+                    customList.push({
+                        layer: layer.title,
+                        formats: this.validateListFormat(layer.dataSource.options.download.allowedFormats)
+                    });
+                }
+                else if (!(layer instanceof VectorLayer) &&
+                    layer.dataSource.options.download &&
+                    layer.dataSource.options.download.url) {
+                    formatsType.onlyUrl = true;
+                }
+                else if (layer.dataSource.options.download &&
+                    (layer.dataSource.options.download.url ||
+                        layer.dataSource.options.download.dynamicUrl)) {
+                    formatsType.vectorAndUrl = true;
+                }
+                else if (layer instanceof VectorLayer) {
+                    formatsType.onlyVector = true;
+                }
+            });
+            if (formatsType.onlyUrl === true && formatsType.onlyVector === false) {
+                appliedformats = ['URL'];
+            }
+            else if (formatsType.onlyVector === true &&
+                formatsType.onlyUrl === false) {
+                this.computeFormats(); // reset
+                if (ExportFormat.URL in this.formats$.value) {
+                    const keys = Object.keys(this.formats$.value).filter((key) => key !== 'URL');
+                    appliedformats = keys;
+                }
+            }
+            else if (formatsType.vectorAndUrl === true &&
+                formatsType.onlyUrl === false &&
+                formatsType.onlyVector === false) {
+                this.computeFormats(); // reset
+                if (!(ExportFormat.URL in this.formats$.value)) {
+                    const keys = Object.keys(this.formats$.value);
+                    keys.push('URL');
+                    appliedformats = keys;
+                }
+            }
+        }
+        const configImportExportFormats = this.config.getConfig('importExport.formats');
+        if (configImportExportFormats) {
+            const validatedListFormat = this.validateListFormat(configImportExportFormats);
+            appliedformats = appliedformats.filter((af) => validatedListFormat.includes(af));
+        }
+        if (formatsType.customList) {
+            let commonFormats;
+            const layersWithCustomFormats = [];
+            let previousCustomListFormats = customList[0].formats;
+            customList.map((list) => {
+                layersWithCustomFormats.push(list.layer);
+                commonFormats = list.formats.filter((value) => previousCustomListFormats.includes(value));
+                previousCustomListFormats = list.formats;
+            });
+            const finalFormats = commonFormats.filter((value) => appliedformats.includes(value));
+            if (finalFormats.length > 0) {
+                this.formats$.next(strEnum(finalFormats));
+                if (layers && layers.length) {
+                    if (layers.length > 1) {
+                        this.messageService.alert('igo.geo.export.customList.text', 'igo.geo.export.customList.title', undefined, { value: layersWithCustomFormats.join() });
+                    }
+                }
+            }
+            else {
+                this.formats$.next([]);
+                this.messageService.alert('igo.geo.export.noFormat.text', 'igo.geo.export.noFormat.title');
+            }
+            return;
+        }
+        else {
+            this.formats$.next(strEnum(appliedformats));
+        }
+    }
+    validateListFormat(formats) {
+        return formats
+            .filter((format) => {
+            if (format.toUpperCase() === ExportFormat.CSVcomma.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.CSVsemicolon.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.GML.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.GPX.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.GeoJSON.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.KML.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.Shapefile.toUpperCase() ||
+                format.toUpperCase() === ExportFormat.URL.toUpperCase()) {
+                return format;
+            }
+        })
+            .map((format) => {
+            if (format.toUpperCase() === ExportFormat.CSVcomma.toUpperCase()) {
+                format = ExportFormat.CSVcomma;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.CSVsemicolon.toUpperCase()) {
+                format = ExportFormat.CSVsemicolon;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.GML.toUpperCase()) {
+                format = ExportFormat.GML;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.GPX.toUpperCase()) {
+                format = ExportFormat.GPX;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.GeoJSON.toUpperCase()) {
+                format = ExportFormat.GeoJSON;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.KML.toUpperCase()) {
+                format = ExportFormat.KML;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.Shapefile.toUpperCase()) {
+                format = ExportFormat.Shapefile;
+                return format;
+            }
+            if (format.toUpperCase() === ExportFormat.URL.toUpperCase()) {
+                format = ExportFormat.URL;
+                return format;
+            }
+        });
+    }
+    modeChanged(mode) {
+        this.selectMode.emit(mode);
+    }
+    onFileExportSuccess() {
+        handleFileExportSuccess(this.messageService);
+    }
+    onImportExportChange(event) {
+        this.selectedMode = event.value;
+    }
+    static ɵfac = function ImportExportComponent_Factory(t) { return new (t || ImportExportComponent)(i0.ɵɵdirectiveInject(i1.ImportService), i0.ɵɵdirectiveInject(i2.ExportService), i0.ɵɵdirectiveInject(i3.LanguageService), i0.ɵɵdirectiveInject(i3.MessageService), i0.ɵɵdirectiveInject(i4.StyleListService), i0.ɵɵdirectiveInject(i5.StyleService), i0.ɵɵdirectiveInject(i6.UntypedFormBuilder), i0.ɵɵdirectiveInject(i3.ConfigService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i3.StorageService), i0.ɵɵdirectiveInject(i7.DownloadService), i0.ɵɵdirectiveInject(i8.LayerService), i0.ɵɵdirectiveInject(i9.ConfirmDialogService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ImportExportComponent, selectors: [["igo-import-export"]], inputs: { selectFirstProj: "selectFirstProj", map: "map", contextUri: "contextUri", projectionsLimitations: "projectionsLimitations", store: "store", selectedMode: "selectedMode", exportOptions$: "exportOptions$" }, outputs: { selectMode: "selectMode", exportOptionsChange: "exportOptionsChange" }, decls: 14, vars: 17, consts: [[1, "import-export-toggle", "mat-typography"], [3, "value", "change"], [3, "value"], ["class", "igo-form", 3, "formGroup", 4, "ngIf"], ["class", "mat-typography", 4, "ngIf"], [1, "igo-form", 3, "formGroup"], [1, "igo-input-container"], [3, "value", "valueChange"], [3, "value", "click", 4, "ngFor", "ngForOf"], ["tooltip-position", "below", "matTooltipShowDelay", "500", 1, "igo-form-button-group", 3, "matTooltip"], ["mat-raised-button", "", "type", "button", 3, "disabled", "click"], [3, "shown"], ["hidden", "", "type", "file", 3, "click", "change"], ["fileInput", ""], [3, "value", "click"], ["matListItemTitle", "", 4, "ngIf"], ["matListItemTitle", ""], [1, "mat-typography"], [4, "ngIf"], ["class", "mat-typography", 3, "html", 4, "ngIf"], [1, "mat-typography", 3, "html"], ["multiple", "", 3, "value", "valueChange"], ["class", "export-select-trigger", 4, "ngIf"], [3, "ngClass", "value", "click", 4, "ngFor", "ngForOf"], ["formControlName", "format"], ["disabled", "true", 4, "ngIf"], ["class", "igo-input-container", 4, "ngIf"], ["class", "export-combine-layers mat-typography", 4, "ngIf"], ["class", "export-separator mat-typography", 4, "ngIf"], ["class", "export-options mat-typography", 4, "ngIf"], [1, "igo-form-button-group"], [1, "export-select-trigger"], [3, "ngClass", "value", "click"], [3, "click", "checked", "change", 4, "ngIf"], [3, "click", "checked", "change"], [3, "value", 4, "ngFor", "ngForOf"], ["disabled", "true"], ["matInput", "", "formControlName", "name", 3, "placeholder"], ["formControlName", "encoding"], [1, "export-combine-layers", "mat-typography"], ["formControlName", "combineLayers", 3, "labelPosition"], [1, "export-separator", "mat-typography"], ["formControlName", "separator", 3, "labelPosition"], [1, "export-options", "mat-typography"], ["formControlName", "featureInMapExtent", 3, "labelPosition"]], template: function ImportExportComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "mat-button-toggle-group", 1);
+            i0.ɵɵlistener("change", function ImportExportComponent_Template_mat_button_toggle_group_change_1_listener($event) { return ctx.onImportExportChange($event); });
+            i0.ɵɵelementStart(2, "mat-button-toggle", 2);
+            i0.ɵɵtext(3);
+            i0.ɵɵpipe(4, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(5, "mat-button-toggle", 2);
+            i0.ɵɵtext(6);
+            i0.ɵɵpipe(7, "translate");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵtemplate(8, ImportExportComponent_form_8_Template, 20, 24, "form", 3);
+            i0.ɵɵtemplate(9, ImportExportComponent_section_9_Template, 3, 2, "section", 4);
+            i0.ɵɵtemplate(10, ImportExportComponent_section_10_Template, 4, 3, "section", 4);
+            i0.ɵɵpipe(11, "async");
+            i0.ɵɵtemplate(12, ImportExportComponent_form_12_Template, 37, 38, "form", 3);
+            i0.ɵɵpipe(13, "async");
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("value", ctx.selectedMode);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("value", "import");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(4, 9, "igo.geo.importExportForm.importTabTitle"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", "export");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(7, 11, "igo.geo.importExportForm.exportTabTitle"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.selectedMode === "import");
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngIf", ctx.selectedMode === "import");
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(11, 13, ctx.exportableLayers$).length === 0 && ctx.selectedMode === "export");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(13, 15, ctx.exportableLayers$).length > 0 && ctx.selectedMode === "export");
+        } }, dependencies: [i10.MatTooltip, i6.ɵNgNoValidate, i6.DefaultValueAccessor, i6.NgControlStatus, i6.NgControlStatusGroup, i6.FormGroupDirective, i6.FormControlName, i11.NgClass, i11.NgForOf, i11.NgIf, i12.MatButton, i13.MatButtonToggleGroup, i13.MatButtonToggle, i14.MatFormField, i14.MatLabel, i15.MatSelect, i15.MatSelectTrigger, i16.MatOption, i17.MatInput, i18.MatSlideToggle, i9.SpinnerComponent, i9.CustomHtmlComponent, i11.AsyncPipe, i19.TranslatePipe, i9.KeyValuePipe], styles: ["[_nghost-%COMP%]   mat-option.igo-export-layer-mat-option[_ngcontent-%COMP%]{height:5em;line-height:1em}[_nghost-%COMP%]   .import-export-toggle[_ngcontent-%COMP%]{padding:10px;text-align:center}[_nghost-%COMP%]   .import-export-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]{width:100%}[_nghost-%COMP%]   .import-export-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]   mat-button-toggle[_ngcontent-%COMP%]{width:50%}[_nghost-%COMP%]   h4[_ngcontent-%COMP%]{padding:0 5px}[_nghost-%COMP%]   .igo-form[_ngcontent-%COMP%]{padding:15px 5px}[_nghost-%COMP%]   .igo-input-container[_ngcontent-%COMP%]   mat-form-field[_ngcontent-%COMP%]{width:100%}[_nghost-%COMP%]   .igo-form-button-group[_ngcontent-%COMP%]{text-align:center;padding-top:10px}[_nghost-%COMP%]   igo-spinner[_ngcontent-%COMP%]{position:absolute;padding-left:10px}[_nghost-%COMP%]   .export-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%], [_nghost-%COMP%]   .export-combine-layers[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%], [_nghost-%COMP%]   .export-separator[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]{width:100%;padding:10px}[_nghost-%COMP%]   .export-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-form-field, [_nghost-%COMP%]   .export-combine-layers[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-form-field, [_nghost-%COMP%]   .export-separator[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-form-field{width:100%}[_nghost-%COMP%]   .export-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-label, [_nghost-%COMP%]   .export-combine-layers[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-label, [_nghost-%COMP%]   .export-separator[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-label{margin-left:0;width:calc(100% - 60px)}[_nghost-%COMP%]   .export-select-trigger[_ngcontent-%COMP%]{opacity:.75;font-size:.75em}"] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImportExportComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-import-export', template: "<div class=\"import-export-toggle mat-typography\">\r\n  <mat-button-toggle-group\r\n    [value]=\"selectedMode\"\r\n    (change)=\"onImportExportChange($event)\"\r\n  >\r\n    <mat-button-toggle [value]=\"'import'\">\r\n      {{ 'igo.geo.importExportForm.importTabTitle' | translate }}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle [value]=\"'export'\">\r\n      {{ 'igo.geo.importExportForm.exportTabTitle' | translate }}\r\n    </mat-button-toggle>\r\n  </mat-button-toggle-group>\r\n</div>\r\n\r\n<form\r\n  class=\"igo-form\"\r\n  [formGroup]=\"importForm\"\r\n  *ngIf=\"selectedMode === 'import'\"\r\n>\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.importProjPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select [(value)]=\"inputProj\">\r\n        <mat-option\r\n          *ngFor=\"let projection of projections$ | async\"\r\n          [value]=\"projection\"\r\n          (click)=\"$event.stopPropagation()\"\r\n        >\r\n          <p matListItemTitle *ngIf=\"projection.translateKey\">\r\n            {{\r\n              'igo.geo.importExportForm.projections.' + projection.translateKey\r\n                | translate: projection\r\n            }}\r\n          </p>\r\n          <p matListItemTitle *ngIf=\"!projection.translateKey\">\r\n            {{ projection.alias }}\r\n          </p>\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    tooltip-position=\"below\"\r\n    matTooltipShowDelay=\"500\"\r\n    [matTooltip]=\"\r\n      importForm.invalid\r\n        ? ('igo.geo.importExportForm.projections.choose' | translate)\r\n        : ('igo.geo.importExportForm.importButton' | translate)\r\n    \"\r\n    class=\"igo-form-button-group\"\r\n  >\r\n    <button\r\n      [disabled]=\"importForm.invalid || (loading$ | async)\"\r\n      mat-raised-button\r\n      type=\"button\"\r\n      (click)=\"fileInput.click()\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.importButton' | translate }}\r\n    </button>\r\n    <igo-spinner [shown]=\"loading$ | async\"></igo-spinner>\r\n    <input\r\n      hidden\r\n      #fileInput\r\n      type=\"file\"\r\n      [style.display]=\"'none'\"\r\n      (click)=\"fileInput.value = null\"\r\n      (change)=\"importFiles($event.target.files)\"\r\n    />\r\n  </div>\r\n</form>\r\n<section class=\"mat-typography\" *ngIf=\"selectedMode === 'import'\">\r\n  <div *ngIf=\"importHtmlClarifications === ''\">\r\n    <h4>{{ 'igo.geo.importExportForm.importClarifications' | translate }}</h4>\r\n    <ul>\r\n      <li>\r\n        {{\r\n          'igo.geo.importExportForm.importSizeMax'\r\n            | translate: { size: fileSizeMb }\r\n        }}\r\n      </li>\r\n      <li>\r\n        {{ 'igo.geo.importExportForm.importFormatAuthorized' | translate }}\r\n      </li>\r\n      <li>{{ 'igo.geo.importExportForm.importShpZip' | translate }}</li>\r\n    </ul>\r\n  </div>\r\n  <igo-custom-html\r\n    *ngIf=\"importHtmlClarifications !== ''\"\r\n    class=\"mat-typography\"\r\n    [html]=\"importHtmlClarifications\"\r\n  >\r\n  </igo-custom-html>\r\n</section>\r\n\r\n<section\r\n  class=\"mat-typography\"\r\n  *ngIf=\"(exportableLayers$ | async).length === 0 && selectedMode === 'export'\"\r\n>\r\n  <h4>{{ 'igo.geo.importExportForm.exportNoLayersExportable' | translate }}</h4>\r\n</section>\r\n\r\n<form\r\n  class=\"igo-form\"\r\n  [formGroup]=\"form\"\r\n  *ngIf=\"(exportableLayers$ | async).length > 0 && selectedMode === 'export'\"\r\n>\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.exportLayerPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select [(value)]=\"layers\" multiple>\r\n        <mat-select-trigger>\r\n          {{ layers.length ? getLayerTitleById(layers[0]) : '' }}\r\n          <span *ngIf=\"layers.length > 1\" class=\"export-select-trigger\">\r\n            (+{{ layers.length - 1 }}\r\n            {{\r\n              (layers?.length === 2\r\n                ? 'igo.geo.importExportForm.other'\r\n                : 'igo.geo.importExportForm.others'\r\n              ) | translate\r\n            }})\r\n          </span>\r\n        </mat-select-trigger>\r\n        <mat-option\r\n          *ngFor=\"let layer of exportableLayers$ | async\"\r\n          [ngClass]=\"{\r\n            'igo-export-layer-mat-option': layerHasSelectedFeatures(layer)\r\n          }\"\r\n          [value]=\"layer.id\"\r\n          (click)=\"$event.stopPropagation()\"\r\n        >\r\n          <p matListItemTitle>{{ layer.title }}</p>\r\n          <p matListItemTitle>\r\n            <mat-slide-toggle\r\n              *ngIf=\"layerHasSelectedFeatures(layer)\"\r\n              (click)=\"onlySelectedClick($event, layer.id)\"\r\n              (checked)=\"inLayersIdToExportSelectionOnly(layer)\"\r\n              (change)=\"onlySelected($event, layer.id)\"\r\n            >\r\n              <small>{{\r\n                'igo.geo.importExportForm.exportSelectedFeature' | translate\r\n              }}</small>\r\n            </mat-slide-toggle>\r\n          </p>\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.exportFormatPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select formControlName=\"format\">\r\n        <ng-container *ngIf=\"(formats$ | async).length !== 0\">\r\n          <mat-option\r\n            *ngFor=\"let format of formats$ | async | keyvalue\"\r\n            [value]=\"format.key\"\r\n          >\r\n            {{ 'igo.geo.export.format.' + format.value | translate }}\r\n          </mat-option>\r\n        </ng-container>\r\n        <mat-option *ngIf=\"(formats$ | async).length === 0\" disabled=\"true\">\r\n          {{ 'igo.geo.export.noFormat.title' | translate }}\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"igo-input-container\"\r\n    *ngIf=\"forceNaming && form.value.format !== 'URL'\"\r\n  >\r\n    <mat-form-field>\r\n      <input\r\n        matInput\r\n        formControlName=\"name\"\r\n        placeholder=\"{{\r\n          'igo.geo.importExportForm.exportFileNamePlaceholder' | translate\r\n        }}\"\r\n      />\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"igo-input-container\"\r\n    *ngIf=\"\r\n      form.value.format === 'CSVcomma' || form.value.format === 'CSVsemicolon'\r\n    \"\r\n  >\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.encodingPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select formControlName=\"encoding\">\r\n        <ng-container *ngIf=\"(encodings$ | async).length !== 0\">\r\n          <mat-option\r\n            *ngFor=\"let encoding of encodings$ | async | keyvalue\"\r\n            [value]=\"encoding.key\"\r\n          >\r\n            {{ 'igo.geo.export.encoding.' + encoding.value | translate }}\r\n          </mat-option>\r\n        </ng-container>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-combine-layers mat-typography\"\r\n    *ngIf=\"\r\n      layers.length > 1 &&\r\n      (form.value.format === 'CSVcomma' || form.value.format === 'CSVsemicolon')\r\n    \"\r\n  >\r\n    <mat-slide-toggle\r\n      formControlName=\"combineLayers\"\r\n      [labelPosition]=\"'before'\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.exportCombineResults' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-separator mat-typography\"\r\n    *ngIf=\"\r\n      layers.length > 1 &&\r\n      (form.value.format === 'CSVcomma' ||\r\n        form.value.format === 'CSVsemicolon') &&\r\n      form.value.combineLayers\r\n    \"\r\n  >\r\n    <mat-slide-toggle formControlName=\"separator\" [labelPosition]=\"'before'\">\r\n      {{ 'igo.geo.importExportForm.exportSeparator' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-options mat-typography\"\r\n    *ngIf=\"form.value.format !== 'URL'\"\r\n  >\r\n    <mat-slide-toggle\r\n      formControlName=\"featureInMapExtent\"\r\n      [labelPosition]=\"'before'\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.exportFeatureInExtent' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div class=\"igo-form-button-group\">\r\n    <button\r\n      mat-raised-button\r\n      type=\"button\"\r\n      [disabled]=\"!form.valid || (loading$ | async)\"\r\n      (click)=\"handleExportFormSubmit(form.value)\"\r\n    >\r\n      {{\r\n        form.value.format !== 'URL'\r\n          ? ('igo.geo.importExportForm.exportButton' | translate)\r\n          : form.value.layers.length > 1\r\n          ? ('igo.geo.importExportForm.exportButtonLinks' | translate)\r\n          : ('igo.geo.importExportForm.exportButtonLink' | translate)\r\n      }}\r\n    </button>\r\n    <igo-spinner [shown]=\"loading$ | async\"></igo-spinner>\r\n  </div>\r\n\r\n  <igo-custom-html\r\n    *ngIf=\"exportHtmlClarifications !== ''\"\r\n    class=\"mat-typography\"\r\n    [html]=\"exportHtmlClarifications\"\r\n  >\r\n  </igo-custom-html>\r\n</form>\r\n", styles: [":host mat-option.igo-export-layer-mat-option{height:5em;line-height:1em}:host .import-export-toggle{padding:10px;text-align:center}:host .import-export-toggle mat-button-toggle-group{width:100%}:host .import-export-toggle mat-button-toggle-group mat-button-toggle{width:50%}:host h4{padding:0 5px}:host .igo-form{padding:15px 5px}:host .igo-input-container mat-form-field{width:100%}:host .igo-form-button-group{text-align:center;padding-top:10px}:host igo-spinner{position:absolute;padding-left:10px}:host .export-options mat-slide-toggle,:host .export-combine-layers mat-slide-toggle,:host .export-separator mat-slide-toggle{width:100%;padding:10px}:host .export-options mat-slide-toggle ::ng-deep .mdc-form-field,:host .export-combine-layers mat-slide-toggle ::ng-deep .mdc-form-field,:host .export-separator mat-slide-toggle ::ng-deep .mdc-form-field{width:100%}:host .export-options mat-slide-toggle ::ng-deep .mdc-label,:host .export-combine-layers mat-slide-toggle ::ng-deep .mdc-label,:host .export-separator mat-slide-toggle ::ng-deep .mdc-label{margin-left:0;width:calc(100% - 60px)}:host .export-select-trigger{opacity:.75;font-size:.75em}\n"] }]
+    }], function () { return [{ type: i1.ImportService }, { type: i2.ExportService }, { type: i3.LanguageService }, { type: i3.MessageService }, { type: i4.StyleListService }, { type: i5.StyleService }, { type: i6.UntypedFormBuilder }, { type: i3.ConfigService }, { type: i0.ChangeDetectorRef }, { type: i3.StorageService }, { type: i7.DownloadService }, { type: i8.LayerService }, { type: i9.ConfirmDialogService }]; }, { selectFirstProj: [{
+            type: Input
+        }], map: [{
+            type: Input
+        }], contextUri: [{
+            type: Input
+        }], projectionsLimitations: [{
+            type: Input
+        }], store: [{
+            type: Input
+        }], selectedMode: [{
+            type: Input
+        }], selectMode: [{
+            type: Output
+        }], exportOptions$: [{
+            type: Input
+        }], exportOptionsChange: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import-export.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/import-export/import-export/import-export.component.ts","../../../../../../packages/geo/src/lib/import-export/import-export/import-export.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  EventEmitter,\r\n  ChangeDetectorRef\r\n} from '@angular/core';\r\nimport {\r\n  UntypedFormGroup,\r\n  UntypedFormBuilder,\r\n  Validators\r\n} from '@angular/forms';\r\nimport { Subscription, BehaviorSubject } from 'rxjs';\r\n\r\nimport {\r\n  MessageService,\r\n  LanguageService,\r\n  ConfigService,\r\n  StorageService\r\n} from '@igo2/core';\r\nimport { strEnum } from '@igo2/utils';\r\n\r\nimport { Feature } from '../../feature/shared/feature.interfaces';\r\nimport { IgoMap } from '../../map/shared/map';\r\nimport { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';\r\nimport { Layer } from '../../layer/shared/layers/layer';\r\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\r\nimport { AnyLayer } from '../../layer/shared/layers/any-layer';\r\nimport { DataSourceOptions } from '../../datasource/shared/datasources/datasource.interface';\r\nimport olPoint from 'ol/geom/Point';\r\nimport { circular } from 'ol/geom/Polygon';\r\n\r\nimport {\r\n  handleFileExportError,\r\n  handleFileExportSuccess\r\n} from '../shared/export.utils';\r\nimport { ExportOptions } from '../shared/export.interface';\r\nimport { ExportFormat, EncodingFormat } from '../shared/export.type';\r\nimport { ExportService } from '../shared/export.service';\r\nimport { ImportService } from '../shared/import.service';\r\nimport {\r\n  handleFileImportSuccess,\r\n  handleFileImportError\r\n} from '../shared/import.utils';\r\nimport { StyleService } from '../../style/style-service/style.service';\r\nimport { StyleListService } from '../../style/style-list/style-list.service';\r\nimport { skipWhile } from 'rxjs/operators';\r\nimport { ConfirmDialogService, EntityRecord, Workspace } from '@igo2/common';\r\nimport type { WorkspaceStore } from '@igo2/common';\r\nimport { WfsWorkspace } from '../../workspace/shared/wfs-workspace';\r\nimport { EditionWorkspace } from '../../workspace/shared/edition-workspace';\r\nimport { FeatureWorkspace } from '../../workspace/shared/feature-workspace';\r\nimport { MatSlideToggleChange } from '@angular/material/slide-toggle';\r\nimport { InputProjections, ProjectionsLimitationsOptions } from '../../map/';\r\nimport { DownloadService } from '../../download/shared/download.service';\r\nimport { computeProjectionsConstraints } from '../../map/shared';\r\n\r\nimport olVectorSource from 'ol/source/Vector';\r\nimport olClusterSource from 'ol/source/Cluster';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport { LayerService } from '../../layer/shared/layer.service';\r\nimport { ImportExportServiceOptions } from '../shared/import.interface';\r\n\r\n@Component({\r\n  selector: 'igo-import-export',\r\n  templateUrl: './import-export.component.html',\r\n  styleUrls: ['./import-export.component.scss']\r\n})\r\nexport class ImportExportComponent implements OnDestroy, OnInit {\r\n  public form: UntypedFormGroup;\r\n  public importForm: UntypedFormGroup;\r\n  public formats$ = new BehaviorSubject(undefined);\r\n  public encodings$ = new BehaviorSubject(undefined);\r\n  public exportableLayers$: BehaviorSubject<AnyLayer[]> = new BehaviorSubject(\r\n    []\r\n  );\r\n  public loading$ = new BehaviorSubject(false);\r\n  public forceNaming = false;\r\n  public controlFormat = 'format';\r\n\r\n  private layers$$: Subscription;\r\n  private exportableLayers$$: Subscription;\r\n  private formats$$: Subscription;\r\n  private encodings$$: Subscription;\r\n  private formLayer$$: Subscription;\r\n  private exportOptions$$: Subscription;\r\n\r\n  public importHtmlClarifications: string;\r\n  public exportHtmlClarifications: string;\r\n\r\n  private espgCodeRegex = new RegExp('^\\\\d{4,6}');\r\n  private clientSideFileSizeMax: number;\r\n  public fileSizeMb: number;\r\n\r\n  public projections$: BehaviorSubject<InputProjections[]> =\r\n    new BehaviorSubject([]);\r\n  private projectionsConstraints: ProjectionsLimitationsOptions;\r\n\r\n  public popupChecked: boolean = false;\r\n\r\n  private previousLayerSpecs$: BehaviorSubject<\r\n    {\r\n      id: string;\r\n      visible: boolean;\r\n      opacity: number;\r\n      queryable: boolean;\r\n    }[]\r\n  > = new BehaviorSubject(undefined);\r\n\r\n  @Input() selectFirstProj: boolean = false;\r\n\r\n  @Input() map: IgoMap;\r\n\r\n  @Input() contextUri: string;\r\n\r\n  private _projectionsLimitations: ProjectionsLimitationsOptions = {};\r\n  @Input()\r\n  set projectionsLimitations(value: ProjectionsLimitationsOptions) {\r\n    this._projectionsLimitations = value;\r\n    this.computeProjections();\r\n  }\r\n  get projectionsLimitations(): ProjectionsLimitationsOptions {\r\n    return this._projectionsLimitations || {};\r\n  }\r\n\r\n  /**\r\n   * Store that holds the available workspaces.\r\n   */\r\n  @Input() store: WorkspaceStore;\r\n\r\n  @Input() selectedMode = 'import';\r\n\r\n  @Output() selectMode = new EventEmitter<string>();\r\n\r\n  @Input() exportOptions$: BehaviorSubject<ExportOptions> = new BehaviorSubject(\r\n    undefined\r\n  );\r\n\r\n  @Output() exportOptionsChange = new EventEmitter<ExportOptions>();\r\n\r\n  get layers() {\r\n    return this.form.get('layers').value;\r\n  }\r\n  set layers(value) {\r\n    this.form.patchValue({ layers: value });\r\n  }\r\n\r\n  get inputProj() {\r\n    return this.importForm.get('inputProj').value;\r\n  }\r\n  set inputProj(value) {\r\n    this.importForm.patchValue({ inputProj: value });\r\n  }\r\n\r\n  get popupAllowed(): boolean {\r\n    return (\r\n      (this.storageService.get('importExportPopupAllowed') as boolean) || false\r\n    );\r\n  }\r\n\r\n  set popupAllowed(value: boolean) {\r\n    this.storageService.set('importExportPopupAllowed', value);\r\n  }\r\n\r\n  constructor(\r\n    private importService: ImportService,\r\n    private exportService: ExportService,\r\n    private languageService: LanguageService,\r\n    private messageService: MessageService,\r\n    private styleListService: StyleListService,\r\n    private styleService: StyleService,\r\n    private formBuilder: UntypedFormBuilder,\r\n    private config: ConfigService,\r\n    private cdRef: ChangeDetectorRef,\r\n    private storageService: StorageService,\r\n    private downloadService: DownloadService,\r\n    private layerService: LayerService,\r\n    private confirmDialogService: ConfirmDialogService\r\n  ) {\r\n    this.loadConfig();\r\n    this.buildForm();\r\n    this.computeProjections();\r\n    this.importHtmlClarifications = this.languageService.translate.instant(\r\n      'igo.geo.importExportForm.importHtmlClarifications'\r\n    );\r\n    this.exportHtmlClarifications = this.languageService.translate.instant(\r\n      'igo.geo.importExportForm.exportHtmlClarifications'\r\n    );\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.layers$$ = this.map.layers$.subscribe((layers) => {\r\n      this.exportableLayers$.next(\r\n        layers.filter((layer: Layer) => {\r\n          return (\r\n            (layer instanceof VectorLayer && layer.exportable === true) ||\r\n            (layer.dataSource.options.download &&\r\n              layer.dataSource.options.download.url)\r\n          );\r\n        }) as AnyLayer[]\r\n      );\r\n    });\r\n    const configFileSizeMb = this.config.getConfig(\r\n      'importExport.clientSideFileSizeMaxMb'\r\n    );\r\n    this.clientSideFileSizeMax =\r\n      (configFileSizeMb ? configFileSizeMb : 30) * Math.pow(1024, 2);\r\n    this.fileSizeMb = this.clientSideFileSizeMax / Math.pow(1024, 2);\r\n\r\n    this.exportOptions$$ = this.exportOptions$\r\n      .pipe(skipWhile((exportOptions) => !exportOptions))\r\n      .subscribe((exportOptions) => {\r\n        this.form.patchValue(exportOptions, { emitEvent: true });\r\n        if (exportOptions.layers) {\r\n          this.computeFormats(\r\n            exportOptions.layers.map((l) => this.map.getLayerById(l))\r\n          );\r\n        }\r\n      });\r\n    this.formLayer$$ = this.form\r\n      .get('format')\r\n      .valueChanges.subscribe((format) => {\r\n        const ogreFormats = Object.keys(ExportService.ogreFormats);\r\n        if (\r\n          !this.popupChecked &&\r\n          this.form.get('layers').value?.length > 1 &&\r\n          (ogreFormats.indexOf(format) >= 0 || format === ExportFormat.URL)\r\n        ) {\r\n          if (!this.handlePopup(true)) {\r\n            this.form.patchValue({ format: undefined }, { emitEvent: false });\r\n          }\r\n        }\r\n      });\r\n\r\n    this.formLayer$$ = this.form\r\n      .get('layers')\r\n      .valueChanges.subscribe((layersId) => {\r\n        this.handlePreviousLayerSpecs();\r\n        const selectedLayers =\r\n          layersId instanceof Array ? layersId : [layersId];\r\n        this.form.patchValue({ layers: selectedLayers }, { emitEvent: false });\r\n        const layers = selectedLayers.map((l) => this.map.getLayerById(l));\r\n        this.computeFormats(layers);\r\n\r\n        if (\r\n          Object.keys(this.formats$.value).indexOf(this.form.value.format) ===\r\n          -1\r\n        ) {\r\n          this.form.patchValue({ format: undefined });\r\n        }\r\n\r\n        this.loading$.next(true);\r\n        const previousSpecs: {\r\n          id: string;\r\n          visible: boolean;\r\n          opacity: number;\r\n          queryable: boolean;\r\n        }[] = [];\r\n        layers.forEach((layer) => {\r\n          if (\r\n            layer instanceof VectorLayer &&\r\n            layer.dataSource.ol.getFeatures().length === 0\r\n          ) {\r\n            previousSpecs.push({\r\n              id: layer.id,\r\n              visible: layer.visible,\r\n              opacity: layer.opacity,\r\n              queryable: (layer as any).queryable\r\n            });\r\n            layer.opacity = 0;\r\n            layer.visible = true;\r\n          }\r\n        });\r\n\r\n        this.previousLayerSpecs$.next(previousSpecs);\r\n        setTimeout(() => {\r\n          this.loading$.next(false);\r\n        }, 500);\r\n      });\r\n\r\n    this.formats$$ = this.formats$\r\n      .pipe(skipWhile((formats) => !formats))\r\n      .subscribe((formats) => {\r\n        if (Object.keys(formats).length === 1) {\r\n          this.form.patchValue({ format: formats[Object.keys(formats)[0]] });\r\n        }\r\n      });\r\n\r\n    this.encodings$$ = this.encodings$\r\n      .pipe(skipWhile((encodings) => !encodings))\r\n      .subscribe((encodings) => {\r\n        if (Object.keys(encodings).length === 1) {\r\n          this.form.patchValue({\r\n            encoding: encodings[Object.keys(encodings)[0]]\r\n          });\r\n        }\r\n      });\r\n\r\n    this.exportableLayers$$ = this.exportableLayers$\r\n      .pipe(skipWhile((layers) => !layers))\r\n      .subscribe((layers) => {\r\n        if (layers.length === 1) {\r\n          this.form.patchValue({ layers: layers[0].id });\r\n        }\r\n      });\r\n\r\n    this.form.controls[this.controlFormat].valueChanges.subscribe((format) => {\r\n      if (\r\n        format === ExportFormat.CSVcomma ||\r\n        format === ExportFormat.CSVsemicolon\r\n      ) {\r\n        this.form.patchValue({ encoding: EncodingFormat.LATIN1 });\r\n      } else {\r\n        this.form.patchValue({ encoding: EncodingFormat.UTF8 });\r\n      }\r\n      this.cdRef.detectChanges();\r\n    });\r\n\r\n    if (this.selectFirstProj) {\r\n      if (this.projections$.value.length === 0) {\r\n        this.importForm.patchValue({\r\n          inputProj: {\r\n            translateKey: 'nad83',\r\n            alias: 'NAD83',\r\n            code: 'EPSG:4326',\r\n            zone: ''\r\n          }\r\n        });\r\n      } else {\r\n        this.importForm.patchValue({ inputProj: this.projections$.value[0] });\r\n      }\r\n    } else {\r\n      this.importForm.patchValue({ inputProj: undefined });\r\n    }\r\n  }\r\n\r\n  private computeProjections() {\r\n    this.projectionsConstraints = computeProjectionsConstraints(\r\n      this.projectionsLimitations\r\n    );\r\n    const projections: InputProjections[] = [];\r\n\r\n    if (this.projectionsConstraints.nad83) {\r\n      projections.push({\r\n        translateKey: 'nad83',\r\n        alias: 'NAD83',\r\n        code: 'EPSG:4269',\r\n        zone: ''\r\n      });\r\n    }\r\n    if (this.projectionsConstraints.wgs84) {\r\n      projections.push({\r\n        translateKey: 'wgs84',\r\n        alias: 'WGS84',\r\n        code: 'EPSG:4326',\r\n        zone: ''\r\n      });\r\n    }\r\n    if (this.projectionsConstraints.webMercator) {\r\n      projections.push({\r\n        translateKey: 'webMercator',\r\n        alias: 'Web Mercator',\r\n        code: 'EPSG:3857',\r\n        zone: ''\r\n      });\r\n    }\r\n\r\n    if (this.projectionsConstraints.mtm) {\r\n      // all mtm zones\r\n      const minZone = this.projectionsConstraints.mtmZone.minZone;\r\n      const maxZone = this.projectionsConstraints.mtmZone.maxZone;\r\n\r\n      for (let mtmZone = minZone; mtmZone <= maxZone; mtmZone++) {\r\n        const code =\r\n          mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;\r\n        projections.push({\r\n          translateKey: 'mtm',\r\n          alias: `MTM ${mtmZone}`,\r\n          code,\r\n          zone: `${mtmZone}`\r\n        });\r\n      }\r\n    }\r\n\r\n    if (this.projectionsConstraints.utm) {\r\n      // all utm zones\r\n      const minZone = this.projectionsConstraints.utmZone.minZone;\r\n      const maxZone = this.projectionsConstraints.utmZone.maxZone;\r\n\r\n      for (let utmZone = minZone; utmZone <= maxZone; utmZone++) {\r\n        const code =\r\n          utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;\r\n        projections.push({\r\n          translateKey: 'utm',\r\n          alias: `UTM ${utmZone}`,\r\n          code,\r\n          zone: `${utmZone}`\r\n        });\r\n      }\r\n    }\r\n\r\n    let configProjection = [];\r\n    if (this.projectionsConstraints.projFromConfig) {\r\n      configProjection = this.config.getConfig('projections') || [];\r\n    }\r\n\r\n    this.projections$.next(configProjection.concat(projections));\r\n  }\r\n\r\n  private getWorkspaceByLayerId(id: string): Workspace {\r\n    const wksFromLayerId = this.store\r\n      .all()\r\n      .find(\r\n        (workspace) =>\r\n          (workspace as WfsWorkspace | FeatureWorkspace | EditionWorkspace)\r\n            .layer.id === id\r\n      );\r\n    if (wksFromLayerId) {\r\n      return wksFromLayerId;\r\n    }\r\n    return;\r\n  }\r\n\r\n  public getLayerTitleById(id): string {\r\n    return this.map.getLayerById(id)?.title;\r\n  }\r\n\r\n  layerHasSelectedFeatures(layer: Layer): boolean {\r\n    const wksFromLayer = this.getWorkspaceByLayerId(layer.id);\r\n    if (wksFromLayer) {\r\n      const recs = wksFromLayer.entityStore.stateView.firstBy(\r\n        (record: EntityRecord<Feature>) => {\r\n          return record.state.selected === true;\r\n        }\r\n      );\r\n      return recs ? true : false;\r\n    }\r\n  }\r\n\r\n  public onlySelected(event: MatSlideToggleChange, id: string) {\r\n    let layersWithSelection = this.form.value.layersWithSelection;\r\n    if (event.checked) {\r\n      layersWithSelection.push(id);\r\n    } else {\r\n      layersWithSelection = layersWithSelection.filter(\r\n        (layerId) => layerId !== id\r\n      );\r\n    }\r\n    this.form.patchValue({ layersWithSelection });\r\n  }\r\n\r\n  public onlySelectedClick(event, id: string) {\r\n    if (this.form.value.layers.find((layerId) => layerId === id)) {\r\n      event.stopPropagation();\r\n    }\r\n  }\r\n\r\n  public inLayersIdToExportSelectionOnly(layer: Layer): boolean {\r\n    return this.form.value.layersWithSelection.find(\r\n      (layerId) => layerId === layer.id\r\n    )\r\n      ? true\r\n      : false;\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.layers$$.unsubscribe();\r\n    this.exportableLayers$$.unsubscribe();\r\n    this.formats$$.unsubscribe();\r\n    this.encodings$$.unsubscribe();\r\n    this.formLayer$$.unsubscribe();\r\n    if (this.exportOptions$$) {\r\n      this.exportOptions$$.unsubscribe();\r\n    }\r\n    this.exportOptionsChange.emit(this.form.value);\r\n    this.handlePreviousLayerSpecs();\r\n  }\r\n\r\n  private handlePreviousLayerSpecs() {\r\n    const previousSpecs = this.previousLayerSpecs$.value;\r\n    if (previousSpecs && previousSpecs.length) {\r\n      previousSpecs.forEach((specs) => {\r\n        const previousLayer = this.map.getLayerById(specs.id);\r\n        previousLayer.visible = specs.visible;\r\n        previousLayer.opacity = specs.opacity;\r\n        (previousLayer as any).queryable = specs.queryable;\r\n      });\r\n    }\r\n    this.previousLayerSpecs$.next(undefined);\r\n  }\r\n\r\n  importFiles(files: File[]) {\r\n    let inputProj = this.inputProj.code;\r\n    if (this.espgCodeRegex.test(inputProj)) {\r\n      inputProj = `EPSG:${inputProj}`;\r\n    }\r\n\r\n    this.loading$.next(true);\r\n    for (const file of files) {\r\n      this.importService.import(file, inputProj).subscribe(\r\n        (features: Feature[]) => this.onFileImportSuccess(file, features),\r\n        (error: Error) => this.onFileImportError(file, error),\r\n        () => {\r\n          this.loading$.next(false);\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  handlePopup(preCheck: boolean = true): boolean {\r\n    const p1 = window.open('', 'popup', 'width=1, height=1');\r\n    p1.close();\r\n    const p2 = window.open('', 'popup', 'width=1, height=1');\r\n    if (!p2 || p2.closed || typeof p2.closed === 'undefined' || p2 === null) {\r\n      this.onPopupBlockedError(preCheck);\r\n      this.popupAllowed = false;\r\n    } else {\r\n      p2.close();\r\n      this.popupAllowed = true;\r\n      this.popupChecked = true;\r\n    }\r\n    return this.popupAllowed;\r\n  }\r\n\r\n  handleExportFormSubmit(data: ExportOptions) {\r\n    this.loading$.next(true);\r\n\r\n    const ogreFormats = Object.keys(ExportService.ogreFormats);\r\n    if (\r\n      !this.popupChecked &&\r\n      data.layers.length > 1 &&\r\n      (ogreFormats.indexOf(data.format) >= 0 ||\r\n        data.format === ExportFormat.URL) &&\r\n      !this.popupAllowed\r\n    ) {\r\n      this.handlePopup();\r\n    }\r\n\r\n    let geomTypesCSV: { geometryType: string; features: any[] }[] = [];\r\n    let featuresCSV: any[] = [];\r\n    let filename: string = '';\r\n\r\n    for (const [layerIndex, layer] of data.layers.entries()) {\r\n      const lay = this.map.getLayerById(layer);\r\n      if (\r\n        !(\r\n          data.format === ExportFormat.CSVsemicolon ||\r\n          data.format === ExportFormat.CSVcomma\r\n        ) ||\r\n        !data.combineLayers ||\r\n        data.layers.length === 1\r\n      ) {\r\n        filename = lay.title;\r\n        if (data.name) {\r\n          filename = data.name;\r\n        }\r\n      } else {\r\n        filename = this.languageService.translate.instant(\r\n          'igo.geo.export.combinedLayers'\r\n        );\r\n      }\r\n      const dSOptions: DataSourceOptions = lay.dataSource.options;\r\n      if (\r\n        data.format === ExportFormat.URL &&\r\n        dSOptions.download &&\r\n        (dSOptions.download.url || dSOptions.download.dynamicUrl)\r\n      ) {\r\n        setTimeout(() => {\r\n          // better look an feel\r\n          const url = dSOptions.download.url || dSOptions.download.dynamicUrl;\r\n          url.match(/service=wfs/gi)\r\n            ? this.downloadService.open(lay)\r\n            : window.open(url, '_blank');\r\n          this.loading$.next(false);\r\n        }, 500);\r\n        return;\r\n      }\r\n      const wks = this.getWorkspaceByLayerId(layer);\r\n      let olFeatures;\r\n      if (wks && wks.entityStore && wks.entityStore.stateView.all().length) {\r\n        if (\r\n          data.layersWithSelection.indexOf(layer) !== -1 &&\r\n          data.featureInMapExtent\r\n        ) {\r\n          // Only export selected feature && into map extent\r\n          olFeatures = wks.entityStore.stateView\r\n            .all()\r\n            .filter(\r\n              (e: EntityRecord<object>) =>\r\n                e.state.inMapExtent && e.state.selected\r\n            )\r\n            .map((e) => (e.entity as Feature).ol);\r\n        } else if (\r\n          data.layersWithSelection.indexOf(layer) !== -1 &&\r\n          !data.featureInMapExtent\r\n        ) {\r\n          // Only export selected feature &&  (into map extent OR not)\r\n          olFeatures = wks.entityStore.stateView\r\n            .all()\r\n            .filter((e: EntityRecord<object>) => e.state.selected)\r\n            .map((e) => (e.entity as Feature).ol);\r\n        } else if (data.featureInMapExtent) {\r\n          // Only into map extent\r\n          olFeatures = wks.entityStore.stateView\r\n            .all()\r\n            .filter((e: EntityRecord<object>) => e.state.inMapExtent)\r\n            .map((e) => (e.entity as Feature).ol);\r\n        } else {\r\n          // All features\r\n          olFeatures = wks.entityStore.stateView\r\n            .all()\r\n            .map((e) => (e.entity as Feature).ol);\r\n        }\r\n      } else {\r\n        const ol = lay.dataSource.ol as\r\n          | olVectorSource<OlGeometry>\r\n          | olClusterSource;\r\n        if (data.featureInMapExtent) {\r\n          olFeatures = ol.getFeaturesInExtent(\r\n            lay.map.viewController.getExtent()\r\n          );\r\n        } else {\r\n          olFeatures = ol.getFeatures();\r\n        }\r\n        if (lay.dataSource instanceof ClusterDataSource) {\r\n          olFeatures = olFeatures.flatMap((cluster: any) =>\r\n            cluster.get('features')\r\n          );\r\n        }\r\n      }\r\n\r\n      let geomTypes: { geometryType: string; features: any[] }[] = [];\r\n      if (\r\n        data.format === ExportFormat.Shapefile ||\r\n        data.format === ExportFormat.GPX\r\n      ) {\r\n        olFeatures.forEach((olFeature) => {\r\n          const featureGeomType = olFeature.getGeometry().getType();\r\n          const currentGeomType = geomTypes.find(\r\n            (geomType) => geomType.geometryType === featureGeomType\r\n          );\r\n          if (currentGeomType) {\r\n            currentGeomType.features.push(olFeature);\r\n          } else {\r\n            geomTypes.push({\r\n              geometryType: featureGeomType,\r\n              features: [olFeature]\r\n            });\r\n          }\r\n        });\r\n      } else {\r\n        geomTypes = [{ geometryType: '', features: olFeatures }];\r\n      }\r\n\r\n      geomTypes.forEach((geomType) => {\r\n        geomType.features.forEach((feature) => {\r\n          const radius: number = feature.get('rad');\r\n          if (radius) {\r\n            const center4326: Array<number> = [\r\n              feature.get('longitude'),\r\n              feature.get('latitude')\r\n            ];\r\n            const circle = circular(center4326, radius, 500);\r\n            circle.transform('EPSG:4326', feature.get('_projection'));\r\n            feature.setGeometry(circle);\r\n          }\r\n        });\r\n      });\r\n\r\n      if (data.format === ExportFormat.GPX) {\r\n        const gpxFeatureCnt = geomTypes.length;\r\n        geomTypes = geomTypes.filter((geomType) =>\r\n          ['LineString', 'Point'].includes(geomType.geometryType)\r\n        );\r\n        const gpxFeatureCntPointOrPoly = geomTypes.length;\r\n        if (gpxFeatureCnt > gpxFeatureCntPointOrPoly) {\r\n          this.messageService.error(\r\n            'igo.geo.export.gpx.error.poly.text',\r\n            'igo.geo.export.gpx.error.poly.title',\r\n            { timeOut: 20000 }\r\n          );\r\n        }\r\n      } else if (\r\n        (data.format === ExportFormat.CSVsemicolon ||\r\n          data.format === ExportFormat.CSVcomma) &&\r\n        data.combineLayers\r\n      ) {\r\n        geomTypes.forEach((geomType) => geomTypesCSV.push(geomType));\r\n\r\n        if (layerIndex !== data.layers.length - 1) {\r\n          continue;\r\n        } else {\r\n          let previousFeature = undefined;\r\n          geomTypesCSV.forEach((geomType) => {\r\n            geomType.features.forEach((currentFeature) => {\r\n              if (data.separator) {\r\n                if (previousFeature) {\r\n                  if (\r\n                    currentFeature.get('_featureStore').layer.options.title !==\r\n                    previousFeature.get('_featureStore').layer.options.title\r\n                  ) {\r\n                    const titleEmptyRows = this.createTitleEmptyRows(\r\n                      previousFeature,\r\n                      currentFeature\r\n                    );\r\n                    featuresCSV.push(titleEmptyRows[2]);\r\n                    featuresCSV.push(titleEmptyRows[0]);\r\n                    featuresCSV.push(titleEmptyRows[1]);\r\n                  }\r\n                } else {\r\n                  const titleEmptyRows = this.createTitleEmptyRows(\r\n                    currentFeature,\r\n                    currentFeature\r\n                  );\r\n                  featuresCSV.push(titleEmptyRows[0]);\r\n                }\r\n              }\r\n              featuresCSV.push(currentFeature);\r\n              previousFeature = currentFeature;\r\n            });\r\n          });\r\n        }\r\n      }\r\n\r\n      if (geomTypes.length === 0) {\r\n        this.loading$.next(false);\r\n        this.messageService.error(\r\n          'igo.geo.export.nothing.text',\r\n          'igo.geo.export.nothing.title',\r\n          { timeOut: 20000 }\r\n        );\r\n      } else {\r\n        if (\r\n          !(\r\n            data.format === ExportFormat.CSVsemicolon ||\r\n            data.format === ExportFormat.CSVcomma\r\n          ) ||\r\n          !data.combineLayers\r\n        ) {\r\n          geomTypes.map((geomType) =>\r\n            this.exportService\r\n              .export(\r\n                geomType.features,\r\n                data.format,\r\n                filename + geomType.geometryType,\r\n                data.encoding,\r\n                this.map.projection\r\n              )\r\n              .subscribe(\r\n                () => {},\r\n                (error: Error) => this.onFileExportError(error),\r\n                () => {\r\n                  this.onFileExportSuccess();\r\n\r\n                  geomType.features.forEach((feature) => {\r\n                    this.circleToPoint(feature);\r\n                  });\r\n\r\n                  this.loading$.next(false);\r\n                }\r\n              )\r\n          );\r\n        }\r\n      }\r\n    }\r\n    if (\r\n      (data.format === ExportFormat.CSVsemicolon ||\r\n        data.format === ExportFormat.CSVcomma) &&\r\n      data.combineLayers\r\n    ) {\r\n      this.exportService\r\n        .export(\r\n          featuresCSV,\r\n          data.format,\r\n          filename,\r\n          data.encoding,\r\n          this.map.projection\r\n        )\r\n        .subscribe(\r\n          () => {},\r\n          (error: Error) => this.onFileExportError(error),\r\n          () => {\r\n            this.onFileExportSuccess();\r\n\r\n            featuresCSV.forEach((feature) => {\r\n              this.circleToPoint(feature);\r\n            });\r\n\r\n            this.loading$.next(false);\r\n          }\r\n        );\r\n    }\r\n  }\r\n\r\n  private createTitleEmptyRows(previousFeature, currentFeature) {\r\n    const titleRow = currentFeature.clone();\r\n    const headerRow = currentFeature.clone();\r\n    const emptyRow = currentFeature.clone();\r\n    const previousFeatureKeys: Array<string> = previousFeature.getKeys();\r\n    let firstKeyPrevious: string = '';\r\n    for (const key in previousFeatureKeys) {\r\n      if (previousFeatureKeys[key] !== 'geometry') {\r\n        firstKeyPrevious = previousFeatureKeys[key];\r\n        break;\r\n      }\r\n    }\r\n\r\n    const currentFeatureKeys: Array<string> = currentFeature.getKeys();\r\n    let firstKeyCurrent: string = '';\r\n    for (const key in currentFeatureKeys) {\r\n      if (currentFeatureKeys[key] !== 'geometry') {\r\n        firstKeyCurrent = currentFeatureKeys[key];\r\n        break;\r\n      }\r\n    }\r\n    const allKeys: Array<string> = currentFeature.getKeys();\r\n    previousFeatureKeys.forEach((previousKey) => {\r\n      if (allKeys.includes(previousKey) && previousKey !== firstKeyPrevious) {\r\n        allKeys.push(previousKey);\r\n      }\r\n    });\r\n    allKeys.unshift(firstKeyPrevious);\r\n\r\n    let firstKeyAll: string = '';\r\n    for (const key in allKeys) {\r\n      if (allKeys[key] !== 'geometry') {\r\n        firstKeyAll = allKeys[key];\r\n        break;\r\n      }\r\n    }\r\n    allKeys.forEach((key) => {\r\n      const sameKeys: boolean =\r\n        previousFeatureKeys.length === currentFeatureKeys.length &&\r\n        previousFeatureKeys.every(\r\n          (value, index) => value === currentFeatureKeys[index]\r\n        );\r\n      if (key === firstKeyAll && !sameKeys) {\r\n        titleRow.set(\r\n          key,\r\n          currentFeature.get('_featureStore').layer.options.title +\r\n            ' ===============>',\r\n          true\r\n        );\r\n        headerRow.set(key, key, true);\r\n        emptyRow.unset(key, true);\r\n      } else if (key === firstKeyAll && sameKeys) {\r\n        titleRow.set(\r\n          key,\r\n          currentFeature.get('_featureStore').layer.options.title,\r\n          true\r\n        );\r\n        headerRow.set(key, key, true);\r\n        emptyRow.unset(key, true);\r\n      } else if (key === firstKeyCurrent) {\r\n        titleRow.set(\r\n          key,\r\n          currentFeature.get('_featureStore').layer.options.title,\r\n          true\r\n        );\r\n        headerRow.set(key, key, true);\r\n        emptyRow.unset(key, true);\r\n      } else if (key !== 'geometry') {\r\n        titleRow.unset(key, true);\r\n        headerRow.set(key, key, true);\r\n        emptyRow.unset(key, true);\r\n      } else {\r\n        titleRow.unset(key, true);\r\n        emptyRow.unset(key, true);\r\n      }\r\n\r\n      if (!currentFeatureKeys.includes(key)) {\r\n        headerRow.unset(key, true);\r\n      }\r\n    });\r\n    const titleEmptyRows = [titleRow, headerRow, emptyRow];\r\n    return titleEmptyRows;\r\n  }\r\n\r\n  private circleToPoint(feature) {\r\n    const radius: number = feature.get('rad');\r\n\r\n    if (radius) {\r\n      const point = new olPoint([\r\n        feature.get('longitude'),\r\n        feature.get('latitude')\r\n      ]);\r\n      point.transform('EPSG:4326', feature.get('_projection'));\r\n      feature.setGeometry(point);\r\n    }\r\n  }\r\n\r\n  private buildForm() {\r\n    this.importForm = this.formBuilder.group({\r\n      inputProj: ['', [Validators.required]]\r\n    });\r\n\r\n    if (this.forceNaming) {\r\n      this.form = this.formBuilder.group({\r\n        format: ['', [Validators.required]],\r\n        layers: [[], [Validators.required]],\r\n        layersWithSelection: [[]],\r\n        encoding: [EncodingFormat.UTF8, [Validators.required]],\r\n        combineLayers: [true, [Validators.required]],\r\n        separator: [false, [Validators.required]],\r\n        featureInMapExtent: [false, [Validators.required]],\r\n        name: ['', [Validators.required]]\r\n      });\r\n    } else {\r\n      this.form = this.formBuilder.group({\r\n        format: ['', [Validators.required]],\r\n        layers: [[], [Validators.required]],\r\n        layersWithSelection: [[]],\r\n        encoding: [EncodingFormat.UTF8, [Validators.required]],\r\n        combineLayers: [true, [Validators.required]],\r\n        separator: [false, [Validators.required]],\r\n        featureInMapExtent: [false, [Validators.required]]\r\n      });\r\n    }\r\n  }\r\n\r\n  private onFileImportSuccess(file: File, features: Feature[]) {\r\n    const importExportOptions = this.config.getConfig(\r\n      'importExport'\r\n    ) as ImportExportServiceOptions;\r\n    const confirmDialogService = importExportOptions?.allowToStoreLayer\r\n      ? this.confirmDialogService\r\n      : undefined;\r\n    const importWithStyle =\r\n      importExportOptions?.importWithStyle ||\r\n      this.config.getConfig('importWithStyle');\r\n    if (this.config.getConfig('importWithStyle')) {\r\n      console.warn(`\r\n      The location of this config importWithStyle is deprecated.\r\n      Please move this property within importExport configuration.\r\n      Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }\r\n      Refer to environnement.ts OR config/config.json\r\n      This legacy conversion will be deleted in 2024.\r\n      `);\r\n    }\r\n    if (!importWithStyle) {\r\n      handleFileImportSuccess(\r\n        file,\r\n        features,\r\n        this.map,\r\n        this.contextUri,\r\n        this.messageService,\r\n        this.layerService,\r\n        confirmDialogService\r\n      );\r\n    } else {\r\n      handleFileImportSuccess(\r\n        file,\r\n        features,\r\n        this.map,\r\n        this.contextUri,\r\n        this.messageService,\r\n        this.layerService,\r\n        confirmDialogService,\r\n        this.styleListService,\r\n        this.styleService\r\n      );\r\n    }\r\n  }\r\n\r\n  private onFileImportError(file: File, error: Error) {\r\n    this.loading$.next(false);\r\n    handleFileImportError(file, error, this.messageService, this.fileSizeMb);\r\n  }\r\n\r\n  private onPopupBlockedError(preCheck: boolean = true) {\r\n    this.loading$.next(false);\r\n    const extraMessage = preCheck\r\n      ? 'igo.geo.export.popupBlocked.selectAgain'\r\n      : 'igo.geo.export.popupBlocked.retry';\r\n    this.messageService.error(\r\n      'igo.geo.export.popupBlocked.text',\r\n      'igo.geo.export.popupBlocked.title',\r\n      { timeOut: 20000 },\r\n      { extraMessage }\r\n    );\r\n  }\r\n\r\n  private onFileExportError(error: Error) {\r\n    this.loading$.next(false);\r\n    handleFileExportError(error, this.messageService);\r\n  }\r\n\r\n  private loadConfig() {\r\n    if (this.config.getConfig('importExport.forceNaming') !== undefined) {\r\n      this.forceNaming = this.config.getConfig('importExport.forceNaming');\r\n    }\r\n    this.computeFormats();\r\n    this.loadEncodings();\r\n  }\r\n\r\n  public encodingDefaultValue(format: ExportFormat) {\r\n    if (\r\n      format === ExportFormat.CSVcomma ||\r\n      format === ExportFormat.CSVsemicolon\r\n    ) {\r\n      this.form.patchValue({ encoding: EncodingFormat.LATIN1 });\r\n      return EncodingFormat.LATIN1;\r\n    } else {\r\n      this.form.patchValue({ encoding: EncodingFormat.UTF8 });\r\n      return EncodingFormat.UTF8;\r\n    }\r\n  }\r\n\r\n  private loadEncodings() {\r\n    this.encodings$.next(EncodingFormat);\r\n  }\r\n\r\n  private computeFormats(layers?: AnyLayer[]) {\r\n    let appliedformats: string[] = Object.keys(ExportFormat);\r\n    const formatsType = {\r\n      onlyUrl: false,\r\n      onlyVector: false,\r\n      vectorAndUrl: false,\r\n      customList: false\r\n    };\r\n    const customList = [];\r\n    if (layers && layers.length) {\r\n      layers.forEach((layer) => {\r\n        if (!layer) {\r\n          return;\r\n        }\r\n        if (layer.dataSource.options.download?.allowedFormats) {\r\n          formatsType.customList = true;\r\n          customList.push({\r\n            layer: layer.title,\r\n            formats: this.validateListFormat(\r\n              layer.dataSource.options.download.allowedFormats\r\n            )\r\n          });\r\n        } else if (\r\n          !(layer instanceof VectorLayer) &&\r\n          layer.dataSource.options.download &&\r\n          layer.dataSource.options.download.url\r\n        ) {\r\n          formatsType.onlyUrl = true;\r\n        } else if (\r\n          layer.dataSource.options.download &&\r\n          (layer.dataSource.options.download.url ||\r\n            layer.dataSource.options.download.dynamicUrl)\r\n        ) {\r\n          formatsType.vectorAndUrl = true;\r\n        } else if (layer instanceof VectorLayer) {\r\n          formatsType.onlyVector = true;\r\n        }\r\n      });\r\n\r\n      if (formatsType.onlyUrl === true && formatsType.onlyVector === false) {\r\n        appliedformats = ['URL'];\r\n      } else if (\r\n        formatsType.onlyVector === true &&\r\n        formatsType.onlyUrl === false\r\n      ) {\r\n        this.computeFormats(); // reset\r\n        if (ExportFormat.URL in this.formats$.value) {\r\n          const keys = Object.keys(this.formats$.value).filter(\r\n            (key) => key !== 'URL'\r\n          );\r\n          appliedformats = keys;\r\n        }\r\n      } else if (\r\n        formatsType.vectorAndUrl === true &&\r\n        formatsType.onlyUrl === false &&\r\n        formatsType.onlyVector === false\r\n      ) {\r\n        this.computeFormats(); // reset\r\n        if (!(ExportFormat.URL in this.formats$.value)) {\r\n          const keys = Object.keys(this.formats$.value);\r\n          keys.push('URL');\r\n          appliedformats = keys;\r\n        }\r\n      }\r\n    }\r\n    const configImportExportFormats = this.config.getConfig(\r\n      'importExport.formats'\r\n    );\r\n    if (configImportExportFormats) {\r\n      const validatedListFormat = this.validateListFormat(\r\n        configImportExportFormats\r\n      );\r\n      appliedformats = appliedformats.filter((af) =>\r\n        validatedListFormat.includes(af)\r\n      );\r\n    }\r\n    if (formatsType.customList) {\r\n      let commonFormats;\r\n      const layersWithCustomFormats = [];\r\n      let previousCustomListFormats = customList[0].formats;\r\n      customList.map((list) => {\r\n        layersWithCustomFormats.push(list.layer);\r\n        commonFormats = list.formats.filter((value) =>\r\n          previousCustomListFormats.includes(value)\r\n        );\r\n        previousCustomListFormats = list.formats;\r\n      });\r\n      const finalFormats = commonFormats.filter((value) =>\r\n        appliedformats.includes(value)\r\n      );\r\n      if (finalFormats.length > 0) {\r\n        this.formats$.next(strEnum(finalFormats));\r\n\r\n        if (layers && layers.length) {\r\n          if (layers.length > 1) {\r\n            this.messageService.alert(\r\n              'igo.geo.export.customList.text',\r\n              'igo.geo.export.customList.title',\r\n              undefined,\r\n              { value: layersWithCustomFormats.join() }\r\n            );\r\n          }\r\n        }\r\n      } else {\r\n        this.formats$.next([]);\r\n        this.messageService.alert(\r\n          'igo.geo.export.noFormat.text',\r\n          'igo.geo.export.noFormat.title'\r\n        );\r\n      }\r\n      return;\r\n    } else {\r\n      this.formats$.next(strEnum(appliedformats));\r\n    }\r\n  }\r\n\r\n  private validateListFormat(formats: string[]): string[] {\r\n    return formats\r\n      .filter((format) => {\r\n        if (\r\n          format.toUpperCase() === ExportFormat.CSVcomma.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.CSVsemicolon.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.GML.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.GPX.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.GeoJSON.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.KML.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.Shapefile.toUpperCase() ||\r\n          format.toUpperCase() === ExportFormat.URL.toUpperCase()\r\n        ) {\r\n          return format;\r\n        }\r\n      })\r\n      .map((format) => {\r\n        if (format.toUpperCase() === ExportFormat.CSVcomma.toUpperCase()) {\r\n          format = ExportFormat.CSVcomma;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.CSVsemicolon.toUpperCase()) {\r\n          format = ExportFormat.CSVsemicolon;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.GML.toUpperCase()) {\r\n          format = ExportFormat.GML;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.GPX.toUpperCase()) {\r\n          format = ExportFormat.GPX;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.GeoJSON.toUpperCase()) {\r\n          format = ExportFormat.GeoJSON;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.KML.toUpperCase()) {\r\n          format = ExportFormat.KML;\r\n          return format;\r\n        }\r\n        if (format.toUpperCase() === ExportFormat.Shapefile.toUpperCase()) {\r\n          format = ExportFormat.Shapefile;\r\n          return format;\r\n        }\r\n\r\n        if (format.toUpperCase() === ExportFormat.URL.toUpperCase()) {\r\n          format = ExportFormat.URL;\r\n          return format;\r\n        }\r\n      });\r\n  }\r\n\r\n  public modeChanged(mode) {\r\n    this.selectMode.emit(mode);\r\n  }\r\n\r\n  private onFileExportSuccess() {\r\n    handleFileExportSuccess(this.messageService);\r\n  }\r\n\r\n  onImportExportChange(event) {\r\n    this.selectedMode = event.value;\r\n  }\r\n}\r\n","<div class=\"import-export-toggle mat-typography\">\r\n  <mat-button-toggle-group\r\n    [value]=\"selectedMode\"\r\n    (change)=\"onImportExportChange($event)\"\r\n  >\r\n    <mat-button-toggle [value]=\"'import'\">\r\n      {{ 'igo.geo.importExportForm.importTabTitle' | translate }}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle [value]=\"'export'\">\r\n      {{ 'igo.geo.importExportForm.exportTabTitle' | translate }}\r\n    </mat-button-toggle>\r\n  </mat-button-toggle-group>\r\n</div>\r\n\r\n<form\r\n  class=\"igo-form\"\r\n  [formGroup]=\"importForm\"\r\n  *ngIf=\"selectedMode === 'import'\"\r\n>\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.importProjPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select [(value)]=\"inputProj\">\r\n        <mat-option\r\n          *ngFor=\"let projection of projections$ | async\"\r\n          [value]=\"projection\"\r\n          (click)=\"$event.stopPropagation()\"\r\n        >\r\n          <p matListItemTitle *ngIf=\"projection.translateKey\">\r\n            {{\r\n              'igo.geo.importExportForm.projections.' + projection.translateKey\r\n                | translate: projection\r\n            }}\r\n          </p>\r\n          <p matListItemTitle *ngIf=\"!projection.translateKey\">\r\n            {{ projection.alias }}\r\n          </p>\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    tooltip-position=\"below\"\r\n    matTooltipShowDelay=\"500\"\r\n    [matTooltip]=\"\r\n      importForm.invalid\r\n        ? ('igo.geo.importExportForm.projections.choose' | translate)\r\n        : ('igo.geo.importExportForm.importButton' | translate)\r\n    \"\r\n    class=\"igo-form-button-group\"\r\n  >\r\n    <button\r\n      [disabled]=\"importForm.invalid || (loading$ | async)\"\r\n      mat-raised-button\r\n      type=\"button\"\r\n      (click)=\"fileInput.click()\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.importButton' | translate }}\r\n    </button>\r\n    <igo-spinner [shown]=\"loading$ | async\"></igo-spinner>\r\n    <input\r\n      hidden\r\n      #fileInput\r\n      type=\"file\"\r\n      [style.display]=\"'none'\"\r\n      (click)=\"fileInput.value = null\"\r\n      (change)=\"importFiles($event.target.files)\"\r\n    />\r\n  </div>\r\n</form>\r\n<section class=\"mat-typography\" *ngIf=\"selectedMode === 'import'\">\r\n  <div *ngIf=\"importHtmlClarifications === ''\">\r\n    <h4>{{ 'igo.geo.importExportForm.importClarifications' | translate }}</h4>\r\n    <ul>\r\n      <li>\r\n        {{\r\n          'igo.geo.importExportForm.importSizeMax'\r\n            | translate: { size: fileSizeMb }\r\n        }}\r\n      </li>\r\n      <li>\r\n        {{ 'igo.geo.importExportForm.importFormatAuthorized' | translate }}\r\n      </li>\r\n      <li>{{ 'igo.geo.importExportForm.importShpZip' | translate }}</li>\r\n    </ul>\r\n  </div>\r\n  <igo-custom-html\r\n    *ngIf=\"importHtmlClarifications !== ''\"\r\n    class=\"mat-typography\"\r\n    [html]=\"importHtmlClarifications\"\r\n  >\r\n  </igo-custom-html>\r\n</section>\r\n\r\n<section\r\n  class=\"mat-typography\"\r\n  *ngIf=\"(exportableLayers$ | async).length === 0 && selectedMode === 'export'\"\r\n>\r\n  <h4>{{ 'igo.geo.importExportForm.exportNoLayersExportable' | translate }}</h4>\r\n</section>\r\n\r\n<form\r\n  class=\"igo-form\"\r\n  [formGroup]=\"form\"\r\n  *ngIf=\"(exportableLayers$ | async).length > 0 && selectedMode === 'export'\"\r\n>\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.exportLayerPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select [(value)]=\"layers\" multiple>\r\n        <mat-select-trigger>\r\n          {{ layers.length ? getLayerTitleById(layers[0]) : '' }}\r\n          <span *ngIf=\"layers.length > 1\" class=\"export-select-trigger\">\r\n            (+{{ layers.length - 1 }}\r\n            {{\r\n              (layers?.length === 2\r\n                ? 'igo.geo.importExportForm.other'\r\n                : 'igo.geo.importExportForm.others'\r\n              ) | translate\r\n            }})\r\n          </span>\r\n        </mat-select-trigger>\r\n        <mat-option\r\n          *ngFor=\"let layer of exportableLayers$ | async\"\r\n          [ngClass]=\"{\r\n            'igo-export-layer-mat-option': layerHasSelectedFeatures(layer)\r\n          }\"\r\n          [value]=\"layer.id\"\r\n          (click)=\"$event.stopPropagation()\"\r\n        >\r\n          <p matListItemTitle>{{ layer.title }}</p>\r\n          <p matListItemTitle>\r\n            <mat-slide-toggle\r\n              *ngIf=\"layerHasSelectedFeatures(layer)\"\r\n              (click)=\"onlySelectedClick($event, layer.id)\"\r\n              (checked)=\"inLayersIdToExportSelectionOnly(layer)\"\r\n              (change)=\"onlySelected($event, layer.id)\"\r\n            >\r\n              <small>{{\r\n                'igo.geo.importExportForm.exportSelectedFeature' | translate\r\n              }}</small>\r\n            </mat-slide-toggle>\r\n          </p>\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div class=\"igo-input-container\">\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.exportFormatPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select formControlName=\"format\">\r\n        <ng-container *ngIf=\"(formats$ | async).length !== 0\">\r\n          <mat-option\r\n            *ngFor=\"let format of formats$ | async | keyvalue\"\r\n            [value]=\"format.key\"\r\n          >\r\n            {{ 'igo.geo.export.format.' + format.value | translate }}\r\n          </mat-option>\r\n        </ng-container>\r\n        <mat-option *ngIf=\"(formats$ | async).length === 0\" disabled=\"true\">\r\n          {{ 'igo.geo.export.noFormat.title' | translate }}\r\n        </mat-option>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"igo-input-container\"\r\n    *ngIf=\"forceNaming && form.value.format !== 'URL'\"\r\n  >\r\n    <mat-form-field>\r\n      <input\r\n        matInput\r\n        formControlName=\"name\"\r\n        placeholder=\"{{\r\n          'igo.geo.importExportForm.exportFileNamePlaceholder' | translate\r\n        }}\"\r\n      />\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"igo-input-container\"\r\n    *ngIf=\"\r\n      form.value.format === 'CSVcomma' || form.value.format === 'CSVsemicolon'\r\n    \"\r\n  >\r\n    <mat-form-field>\r\n      <mat-label>{{\r\n        'igo.geo.importExportForm.encodingPlaceholder' | translate\r\n      }}</mat-label>\r\n      <mat-select formControlName=\"encoding\">\r\n        <ng-container *ngIf=\"(encodings$ | async).length !== 0\">\r\n          <mat-option\r\n            *ngFor=\"let encoding of encodings$ | async | keyvalue\"\r\n            [value]=\"encoding.key\"\r\n          >\r\n            {{ 'igo.geo.export.encoding.' + encoding.value | translate }}\r\n          </mat-option>\r\n        </ng-container>\r\n      </mat-select>\r\n    </mat-form-field>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-combine-layers mat-typography\"\r\n    *ngIf=\"\r\n      layers.length > 1 &&\r\n      (form.value.format === 'CSVcomma' || form.value.format === 'CSVsemicolon')\r\n    \"\r\n  >\r\n    <mat-slide-toggle\r\n      formControlName=\"combineLayers\"\r\n      [labelPosition]=\"'before'\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.exportCombineResults' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-separator mat-typography\"\r\n    *ngIf=\"\r\n      layers.length > 1 &&\r\n      (form.value.format === 'CSVcomma' ||\r\n        form.value.format === 'CSVsemicolon') &&\r\n      form.value.combineLayers\r\n    \"\r\n  >\r\n    <mat-slide-toggle formControlName=\"separator\" [labelPosition]=\"'before'\">\r\n      {{ 'igo.geo.importExportForm.exportSeparator' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div\r\n    class=\"export-options mat-typography\"\r\n    *ngIf=\"form.value.format !== 'URL'\"\r\n  >\r\n    <mat-slide-toggle\r\n      formControlName=\"featureInMapExtent\"\r\n      [labelPosition]=\"'before'\"\r\n    >\r\n      {{ 'igo.geo.importExportForm.exportFeatureInExtent' | translate }}\r\n    </mat-slide-toggle>\r\n  </div>\r\n\r\n  <div class=\"igo-form-button-group\">\r\n    <button\r\n      mat-raised-button\r\n      type=\"button\"\r\n      [disabled]=\"!form.valid || (loading$ | async)\"\r\n      (click)=\"handleExportFormSubmit(form.value)\"\r\n    >\r\n      {{\r\n        form.value.format !== 'URL'\r\n          ? ('igo.geo.importExportForm.exportButton' | translate)\r\n          : form.value.layers.length > 1\r\n          ? ('igo.geo.importExportForm.exportButtonLinks' | translate)\r\n          : ('igo.geo.importExportForm.exportButtonLink' | translate)\r\n      }}\r\n    </button>\r\n    <igo-spinner [shown]=\"loading$ | async\"></igo-spinner>\r\n  </div>\r\n\r\n  <igo-custom-html\r\n    *ngIf=\"exportHtmlClarifications !== ''\"\r\n    class=\"mat-typography\"\r\n    [html]=\"exportHtmlClarifications\"\r\n  >\r\n  </igo-custom-html>\r\n</form>\r\n"]}