@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/measure/measurer/measurer.component.mjs

@@ -0,0 +1,1121 @@
+import { Component, Input, ChangeDetectionStrategy, ViewChild } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { BehaviorSubject } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import OlStyle from 'ol/style/Style';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import OlVectorSource from 'ol/source/Vector';
+import { unByKey } from 'ol/Observable';
+import { LanguageService, StorageScope, StorageService } from '@igo2/core';
+import { uuid } from '@igo2/utils';
+import { FeatureDataSource } from '../../datasource';
+import { FEATURE, FeatureStore, FeatureStoreLoadingStrategy, FeatureStoreSelectionStrategy, tryBindStoreLayer, tryAddLoadingStrategy, tryAddSelectionStrategy } from '../../feature';
+import { DrawControl, ModifyControl } from '../../geometry/shared';
+import { VectorLayer } from '../../layer/shared';
+import { IgoMap } from '../../map/shared';
+import { MeasureType, MeasureAreaUnit, MeasureLengthUnit } from '../shared/measure.enum';
+import { measureOlGeometry, createMeasureInteractionStyle, createMeasureLayerStyle, updateOlTooltipsAtMidpoints, updateOlTooltipAtCenter, getTooltipsOfOlGeometry, squareMetersToUnit, metersToUnit, formatMeasure } from '../shared/measure.utils';
+import { MeasurerDialogComponent } from './measurer-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "@angular/material/dialog";
+const _c0 = ["table"];
+function MeasurerComponent_mat_divider_13_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_mat_slide_toggle_15_Template(rf, ctx) { if (rf & 1) {
+    const _r12 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_15_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r12); const ctx_r11 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r11.onToggleDisplayLines($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r1.displayLines)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayLines"), " ");
+} }
+function MeasurerComponent_mat_divider_17_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_mat_slide_toggle_20_Template(rf, ctx) { if (rf & 1) {
+    const _r14 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_20_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r14); const ctx_r13 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r13.onToggleDisplayDistance($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r3.displayDistance)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayDistance"), " ");
+} }
+function MeasurerComponent_mat_slide_toggle_22_Template(rf, ctx) { if (rf & 1) {
+    const _r16 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-slide-toggle", 7);
+    i0.ɵɵlistener("change", function MeasurerComponent_mat_slide_toggle_22_Template_mat_slide_toggle_change_0_listener($event) { i0.ɵɵrestoreView(_r16); const ctx_r15 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r15.onToggleDisplayAreas($event.checked)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("checked", ctx_r4.displayAreas)("labelPosition", "before");
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 3, "igo.geo.measure.toggleDisplayAreas"), " ");
+} }
+function MeasurerComponent_mat_divider_24_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_ng_container_29_igo_measurer_item_1_Template(rf, ctx) { if (rf & 1) {
+    const _r21 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "igo-measurer-item", 14);
+    i0.ɵɵlistener("measureUnitChange", function MeasurerComponent_ng_container_29_igo_measurer_item_1_Template_igo_measurer_item_measureUnitChange_0_listener($event) { i0.ɵɵrestoreView(_r21); const ctx_r20 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r20.onLengthUnitChange($event)); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measure_r17 = i0.ɵɵnextContext().ngIf;
+    const ctx_r18 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("measureType", ctx_r18.measureType.Length)("measureUnit", ctx_r18.measureLengthUnit.Meters)("measure", measure_r17.length)("auto", ctx_r18.measureUnitsAuto)("placeholder", i0.ɵɵpipeBind1(1, 5, ctx_r18.activeMeasureType === ctx_r18.measureType.Area ? "igo.geo.measure.perimeter" : "igo.geo.measure.length"));
+} }
+function MeasurerComponent_ng_container_29_igo_measurer_item_2_Template(rf, ctx) { if (rf & 1) {
+    const _r24 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "igo-measurer-item", 14);
+    i0.ɵɵlistener("measureUnitChange", function MeasurerComponent_ng_container_29_igo_measurer_item_2_Template_igo_measurer_item_measureUnitChange_0_listener($event) { i0.ɵɵrestoreView(_r24); const ctx_r23 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r23.onAreaUnitChange($event)); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const measure_r17 = i0.ɵɵnextContext().ngIf;
+    const ctx_r19 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("measureType", ctx_r19.measureType.Area)("measureUnit", ctx_r19.measureAreaUnit.SquareMeters)("measure", measure_r17.area)("auto", ctx_r19.measureUnitsAuto)("placeholder", i0.ɵɵpipeBind1(1, 5, "igo.geo.measure.area"));
+} }
+function MeasurerComponent_ng_container_29_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵtemplate(1, MeasurerComponent_ng_container_29_igo_measurer_item_1_Template, 2, 7, "igo-measurer-item", 13);
+    i0.ɵɵtemplate(2, MeasurerComponent_ng_container_29_igo_measurer_item_2_Template, 2, 7, "igo-measurer-item", 13);
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r6 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r6.activeMeasureType === ctx_r6.measureType.Length || ctx_r6.activeMeasureType === ctx_r6.measureType.Area);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r6.activeMeasureType === ctx_r6.measureType.Area);
+} }
+function MeasurerComponent_mat_divider_31_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "mat-divider");
+} }
+function MeasurerComponent_button_35_Template(rf, ctx) { if (rf & 1) {
+    const _r27 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 15);
+    i0.ɵɵlistener("click", function MeasurerComponent_button_35_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r27); const ctx_r26 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r26.onCalculateClick()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelement(3, "mat-icon", 16);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r8 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.measure.actionbar.calculate.tooltip"))("disabled", i0.ɵɵpipeBind1(2, 4, ctx_r8.selectedFeatures$).length === 0);
+} }
+function MeasurerComponent_button_38_Template(rf, ctx) { if (rf & 1) {
+    const _r29 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 17);
+    i0.ɵɵlistener("click", function MeasurerComponent_button_38_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r29); const ctx_r28 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r28.onDeleteClick()); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelement(3, "mat-icon", 18);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r9 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.measure.actionbar.delete.tooltip"))("disabled", i0.ɵɵpipeBind1(2, 4, ctx_r9.selectedFeatures$).length === 0);
+} }
+/**
+ * Tool to measure lengths and areas
+ */
+export class MeasurerComponent {
+    languageService;
+    dialog;
+    storageService;
+    /**
+     * Table template
+     * @internal
+     */
+    tableTemplate;
+    subscriptions$$ = [];
+    /**
+     * Reference to the MeasureType enum
+     * @internal
+     */
+    measureType = MeasureType;
+    /**
+     * Reference to the AreaMeasureUnit enum
+     * @internal
+     */
+    measureAreaUnit = MeasureAreaUnit;
+    /**
+     * Reference to the LengthMeasureUnit enum
+     * @internal
+     */
+    measureLengthUnit = MeasureLengthUnit;
+    /**
+     * Whether measure units should be automatically determined
+     * @internal
+     */
+    measureUnitsAuto = false;
+    /**
+     * Whether display of distances of areas
+     * @internal
+     */
+    displayDistance = true;
+    /**
+     * Whether display of distances of lines
+     * @internal
+     */
+    displayLines = true;
+    /**
+     * Whether display of areas
+     * @internal
+     */
+    displayAreas = true;
+    /**
+     * Observable of line boolean
+     * @internal
+     */
+    hasLine$ = new BehaviorSubject(false);
+    /**
+     * Observable of area boolean
+     * @internal
+     */
+    hasArea$ = new BehaviorSubject(false);
+    /**
+     * Observable of area
+     * @internal
+     */
+    measure$ = new BehaviorSubject({});
+    /**
+     * Observable of selected features
+     * @internal
+     */
+    selectedFeatures$ = new BehaviorSubject([]);
+    /**
+     * OL draw source
+     * @internal
+     */
+    showTooltips = true;
+    /**
+     * Whether draw control toggle is disabled or not
+     * @internal
+     */
+    drawControlIsDisabled = true;
+    /**
+     * Draw line control
+     */
+    drawLineControl;
+    /**
+     * Draw polygon control
+     */
+    drawPolygonControl;
+    /**
+     * Modify control
+     */
+    modifyControl;
+    /**
+     * Active OL geometry
+     */
+    activeOlGeometry;
+    /**
+     * Active mlength unit
+     */
+    activeLengthUnit = MeasureLengthUnit.Meters;
+    /**
+     * Active area unit
+     */
+    activeAreaUnit = MeasureAreaUnit.SquareMeters;
+    /**
+     * Feature added listener key
+     */
+    onFeatureAddedKey;
+    /**
+     * Feature removed listener key
+     */
+    onFeatureRemovedKey;
+    /**
+     * Active draw control
+     * @internal
+     */
+    activeDrawControl;
+    /**
+     * Subscription to draw start
+     */
+    drawStart$$;
+    /**
+     * Subscription to draw end
+     */
+    drawEnd$$;
+    /**
+     * Subscription to controls changes
+     */
+    drawChanges$$;
+    /**
+     * Subscription to modify start
+     */
+    modifyStart$$;
+    /**
+     * Subscription to modify end
+     */
+    modifyEnd$$;
+    /**
+     * Subscription to controls changes
+     */
+    modifyChanges$$;
+    /**
+     * Subscription to measures selection
+     */
+    selectedFeatures$$;
+    /**
+     * OL draw source
+     */
+    olDrawSource = new OlVectorSource();
+    /**
+     * The map to measure on
+     */
+    map;
+    /**
+     * The measures store
+     */
+    store;
+    /**
+     * Measure type
+     * @internal
+     */
+    set activeMeasureType(value) {
+        this.setActiveMeasureType(value);
+    }
+    get activeMeasureType() {
+        return this._activeMeasureType;
+    }
+    _activeMeasureType;
+    /**
+     * The minimum length a segment must have to display a tooltip.
+     * It also applies to area tooltips.
+     */
+    minSegmentLength = 10;
+    table;
+    /**
+     * Wheter one of the draw control is active
+     * @internal
+     */
+    get drawControlIsActive() {
+        return this.activeDrawControl !== undefined;
+    }
+    get projection() {
+        return this.map.ol.getView().getProjection().getCode();
+    }
+    constructor(languageService, dialog, storageService) {
+        this.languageService = languageService;
+        this.dialog = dialog;
+        this.storageService = storageService;
+        this.tableTemplate = {
+            selection: true,
+            selectMany: true,
+            selectionCheckbox: true,
+            sort: true,
+            columns: [
+                {
+                    name: 'length',
+                    title: this.languageService.translate.instant('igo.geo.measure.lengthHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeLengthUnit;
+                        const measure = metersToUnit(localFeature.properties.measure.length, unit);
+                        return formatMeasure(measure, {
+                            decimal: 1,
+                            unit,
+                            unitAbbr: false,
+                            locale: 'fr'
+                        });
+                    }
+                },
+                {
+                    name: 'area',
+                    title: this.languageService.translate.instant('igo.geo.measure.areaHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeAreaUnit;
+                        const measure = squareMetersToUnit(localFeature.properties.measure.area, unit);
+                        return measure
+                            ? formatMeasure(measure, {
+                                decimal: 1,
+                                unit,
+                                unitAbbr: false,
+                                locale: 'fr'
+                            })
+                            : '';
+                    }
+                }
+            ]
+        };
+    }
+    /**
+     * Add draw controls and activate one
+     * @internal
+     */
+    ngOnInit() {
+        this.initStore();
+        this.createDrawLineControl();
+        this.createDrawPolygonControl();
+        this.createModifyControl();
+        this.toggleDrawControl();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        this.checkDistanceAreaToggle();
+        this.setActiveMeasureType(MeasureType.Length);
+    }
+    /**
+     * Clear the overlay layer and any interaction added by this component.
+     * @internal
+     */
+    ngOnDestroy() {
+        this.setActiveMeasureType(undefined);
+        this.deactivateModifyControl();
+        this.freezeStore();
+        this.subscriptions$$.map((s) => s.unsubscribe());
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onMeasureTypeChange(measureType) {
+        this.activeMeasureType = measureType;
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleDrawControl(toggle) {
+        if (toggle === true) {
+            this.toggleDrawControl();
+        }
+        else {
+            this.deactivateDrawControl();
+        }
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleMeasureUnitsAuto(toggle) {
+        this.measureUnitsAuto = toggle;
+    }
+    /**
+     * Activate or deactivate the current display of distances of the areas
+     * @internal
+     */
+    onToggleDisplayDistance(toggle) {
+        this.displayDistance = toggle;
+        this.onDisplayDistance();
+        toggle
+            ? this.storageService.set('distanceToggle', true, StorageScope.SESSION)
+            : this.storageService.set('distanceToggle', false, StorageScope.SESSION);
+    }
+    /**
+     * Activate or deactivate the current display of distances of the lines
+     * @internal
+     */
+    onToggleDisplayLines(toggle) {
+        this.displayLines = toggle;
+        this.onDisplayLines();
+        toggle
+            ? this.storageService.set('linesToggle', true, StorageScope.SESSION)
+            : this.storageService.set('linesToggle', false, StorageScope.SESSION);
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onToggleDisplayAreas(toggle) {
+        this.displayAreas = toggle;
+        this.onDisplayAreas();
+        toggle
+            ? this.storageService.set('areasToggle', true, StorageScope.SESSION)
+            : this.storageService.set('areasToggle', false, StorageScope.SESSION);
+    }
+    /**
+     * Set display parametres in current values
+     * @internal
+     */
+    checkDistanceAreaToggle() {
+        if (this.storageService.get('distanceToggle') === false) {
+            this.displayDistance = false;
+        }
+        if (this.storageService.get('linesToggle') === false) {
+            this.displayLines = false;
+        }
+        if (this.storageService.get('areasToggle') === false) {
+            this.displayAreas = false;
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of areas
+     * @internal
+     */
+    onDisplayDistance() {
+        if (this.displayDistance) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of lines
+     * @internal
+     */
+    onDisplayLines() {
+        if (this.displayLines) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-line-segments')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onDisplayAreas() {
+        if (this.displayAreas) {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(document.getElementsByClassName('igo-map-tooltip-measure-area')).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onLengthUnitChange(unit) {
+        this.activeLengthUnit = unit;
+        this.table.refresh();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        if (this.activeOlGeometry !== undefined) {
+            this.updateTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onAreaUnitChange(unit) {
+        this.activeAreaUnit = unit;
+        this.table.refresh();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        if (this.activeOlGeometry !== undefined) {
+            this.updateTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+    }
+    onCalculateClick() {
+        const features = this.selectedFeatures$.value;
+        const area = features.reduce((sum, localFeature) => {
+            return sum + localFeature.properties.measure.area || 0;
+        }, 0);
+        const length = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'Polygon') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        const perimeter = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'LineString') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        this.openDialog({
+            area,
+            length,
+            perimeter
+        });
+    }
+    onDeleteClick() {
+        this.store.deleteMany(this.selectedFeatures$.value);
+        this.selectedFeatures$.value.forEach((selectedFeature) => {
+            this.olDrawSource.getFeatures().forEach((drawingLayerFeature) => {
+                const geometry = drawingLayerFeature.getGeometry();
+                if (selectedFeature.properties.id === geometry.ol_uid) {
+                    this.olDrawSource.removeFeature(drawingLayerFeature);
+                }
+            });
+        });
+    }
+    onModifyClick() {
+        if (this.selectedFeatures$.value.length !== 1) {
+            return;
+        }
+        if (this.modifyControl.active === true) {
+            this.deactivateModifyControl();
+            this.toggleDrawControl();
+        }
+        else {
+            const localFeature = this.selectedFeatures$.value[0];
+            const olFeatures = this.store.layer.ol.getSource().getFeatures();
+            const olFeature = olFeatures.find((_olFeature) => {
+                return _olFeature.get('id') === localFeature.properties.id;
+            });
+            if (olFeature !== undefined) {
+                this.deactivateDrawControl();
+                this.activateModifyControl();
+                const olGeometry = olFeature.getGeometry();
+                this.clearTooltipsOfOlGeometry(olGeometry);
+                this.modifyControl.setOlGeometry(olGeometry);
+            }
+        }
+    }
+    openDialog(data) {
+        this.dialog.open(MeasurerDialogComponent, { data });
+    }
+    /**
+     * Initialize the measure store and set up some listeners
+     * @internal
+     */
+    initStore() {
+        const store = this.store;
+        const layer = new VectorLayer({
+            title: this.languageService.translate.instant('igo.geo.measure.layerTitle'),
+            isIgoInternalLayer: true,
+            id: `igo-measures-${uuid()}`,
+            zIndex: 200,
+            source: new FeatureDataSource(),
+            style: createMeasureLayerStyle(),
+            showInLayerList: true,
+            exportable: true,
+            browsable: false,
+            workspace: { enabled: false }
+        });
+        tryBindStoreLayer(store, layer);
+        store.layer.visible = true;
+        layer.visible$.subscribe((visible) => {
+            if (visible) {
+                Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value) => value.classList.remove('igo-map-tooltip-measure-by-display'));
+            }
+            else {
+                Array.from(document.getElementsByClassName('igo-map-tooltip-measure')).map((value) => value.classList.add('igo-map-tooltip-measure-by-display'));
+            }
+        });
+        tryAddLoadingStrategy(store);
+        tryAddSelectionStrategy(store, new FeatureStoreSelectionStrategy({
+            map: this.map,
+            many: true
+        }));
+        this.onFeatureAddedKey = store.source.ol.on('addfeature', (event) => {
+            const localFeature = event.feature;
+            const olGeometry = localFeature.getGeometry();
+            this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));
+            this.onDisplayDistance();
+        });
+        this.onFeatureRemovedKey = store.source.ol.on('removefeature', (event) => {
+            const olGeometry = event.feature.getGeometry();
+            this.clearTooltipsOfOlGeometry(olGeometry);
+        });
+        this.selectedFeatures$$ = store.stateView
+            .manyBy$((record) => {
+            return record.state.selected === true;
+        })
+            .pipe(skip(1) // Skip initial emission
+        )
+            .subscribe((records) => {
+            if (this.modifyControl.active === true) {
+                this.deactivateModifyControl();
+            }
+            this.selectedFeatures$.next(records.map((record) => record.entity));
+        });
+        this.subscriptions$$.push(this.store.entities$.subscribe((objectsExists) => {
+            if (objectsExists.find((objectExist) => objectExist.geometry.type === 'Polygon')) {
+                this.hasArea$.next(true);
+            }
+            else {
+                this.hasArea$.next(false);
+            }
+            if (objectsExists.find((objectExist) => objectExist.geometry.type === 'LineString')) {
+                this.hasLine$.next(true);
+            }
+            else {
+                this.hasLine$.next(false);
+            }
+        }));
+        this.subscriptions$$.push(this.store.count$.subscribe((cnt) => {
+            cnt >= 1
+                ? (this.store.layer.options.showInLayerList = true)
+                : (this.store.layer.options.showInLayerList = false);
+        }));
+    }
+    /**
+     * Freeze any store, meaning the layer is removed, strategies are deactivated
+     * and some listener removed
+     * @internal
+     */
+    freezeStore() {
+        const store = this.store;
+        this.selectedFeatures$$.unsubscribe();
+        unByKey(this.onFeatureAddedKey);
+        unByKey(this.onFeatureRemovedKey);
+        store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+        store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);
+    }
+    /**
+     * Create a draw line control
+     */
+    createDrawLineControl() {
+        this.drawLineControl = new DrawControl({
+            geometryType: 'LineString',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createDrawPolygonControl() {
+        this.drawPolygonControl = new DrawControl({
+            geometryType: 'Polygon',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createModifyControl() {
+        this.modifyControl = new ModifyControl({
+            source: this.olDrawSource,
+            drawStyle: createMeasureInteractionStyle(),
+            layerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Activate the right control
+     */
+    toggleDrawControl() {
+        this.deactivateDrawControl();
+        // this.deactivateModifyControl();
+        if (this.activeMeasureType === MeasureType.Length) {
+            this.activateDrawControl(this.drawLineControl);
+        }
+        else if (this.activeMeasureType === MeasureType.Area) {
+            this.activateDrawControl(this.drawPolygonControl);
+        }
+    }
+    /**
+     * Activate a given control
+     * @param drawControl Draw control
+     */
+    activateDrawControl(drawControl) {
+        this.drawControlIsDisabled = false;
+        this.activeDrawControl = drawControl;
+        this.drawStart$$ = drawControl.start$.subscribe((olGeometry) => this.onDrawStart(olGeometry));
+        this.drawEnd$$ = drawControl.end$.subscribe((olGeometry) => this.onDrawEnd(olGeometry));
+        this.drawChanges$$ = drawControl.changes$.subscribe((olGeometry) => this.onDrawChanges(olGeometry));
+        this.drawChanges$$ = drawControl.abort$.subscribe((olGeometry) => {
+            this.clearTooltipsOfOlGeometry(olGeometry);
+            this.clearMeasures();
+        });
+        drawControl.setOlMap(this.map.ol, false);
+    }
+    /**
+     * Deactivate the active draw control
+     */
+    deactivateDrawControl() {
+        if (this.activeDrawControl === undefined) {
+            return;
+        }
+        this.olDrawSource.clear();
+        if (this.drawStart$$ !== undefined) {
+            this.drawStart$$.unsubscribe();
+        }
+        if (this.drawEnd$$ !== undefined) {
+            this.drawEnd$$.unsubscribe();
+        }
+        if (this.drawChanges$$ !== undefined) {
+            this.drawChanges$$.unsubscribe();
+        }
+        this.clearTooltipsOfOlSource(this.olDrawSource);
+        if (this.activeOlGeometry !== undefined) {
+            this.clearTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+        this.activeDrawControl.setOlMap(undefined);
+        this.activeDrawControl = undefined;
+        this.activeOlGeometry = undefined;
+    }
+    setActiveMeasureType(measureType) {
+        this._activeMeasureType = measureType;
+        this.clearMeasures();
+        this.toggleDrawControl();
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawStart(olGeometry) {
+        this.activeOlGeometry = olGeometry;
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawEnd(olGeometry) {
+        this.activeOlGeometry = undefined;
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+        this.addFeatureToStore(olGeometry);
+        this.clearTooltipsOfOlGeometry(olGeometry);
+        this.olDrawSource.clear(true);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawChanges(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, Object.assign({}, measure, {
+            area: undefined // We don't want to display an area tooltip while drawing.
+        }));
+        this.measure$.next(measure);
+    }
+    /**
+     * Activate a given control
+     * @param modifyControl Modify control
+     */
+    activateModifyControl() {
+        const selection = this.store.getStrategyOfType(FeatureStoreSelectionStrategy);
+        selection.deactivate();
+        selection.clear();
+        this.modifyStart$$ = this.modifyControl.start$.subscribe((olGeometry) => this.onModifyStart(olGeometry));
+        this.modifyEnd$$ = this.modifyControl.end$.subscribe((olGeometry) => this.onModifyEnd(olGeometry));
+        this.modifyChanges$$ = this.modifyControl.changes$.subscribe((olGeometry) => this.onModifyChanges(olGeometry));
+        this.modifyControl.setOlMap(this.map.ol);
+    }
+    /**
+     * Deactivate the active modify control
+     */
+    deactivateModifyControl() {
+        if (this.modifyStart$$ !== undefined) {
+            this.modifyStart$$.unsubscribe();
+        }
+        if (this.modifyEnd$$ !== undefined) {
+            this.modifyEnd$$.unsubscribe();
+        }
+        if (this.modifyChanges$$ !== undefined) {
+            this.modifyChanges$$.unsubscribe();
+        }
+        if (this.activeOlGeometry !== undefined) {
+            if (this.selectedFeatures$.value.length === 1) {
+                const localFeature = this.selectedFeatures$.value[0];
+                this.addFeatureToStore(this.activeOlGeometry, localFeature);
+            }
+            this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);
+        }
+        this.olDrawSource.clear();
+        this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);
+        this.activeOlGeometry = undefined;
+        this.modifyControl.setOlMap(undefined);
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyStart(olGeometry) {
+        this.onDrawStart(olGeometry);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyChanges(olGeometry) {
+        this.onDrawChanges(olGeometry);
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyEnd(olGeometry) {
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+    }
+    finalizeMeasureOfOlGeometry(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, measure);
+    }
+    /**
+     * Update measures observables
+     * @param olGeometry Ol linestring or polygon
+     * @param measure Measure
+     */
+    updateMeasureOfOlGeometry(olGeometry, measure) {
+        olGeometry.setProperties({ _measure: measure }, true);
+        this.updateTooltipsOfOlGeometry(olGeometry);
+    }
+    /**
+     * Clear the measures observables
+     */
+    clearMeasures() {
+        this.measure$.next({});
+    }
+    /**
+     * Add a feature with measures to the store. The loading stragegy of the store
+     * will trigger and add the feature to the map.
+     * @internal
+     */
+    addFeatureToStore(olGeometry, localFeature) {
+        const featureId = localFeature
+            ? localFeature.properties.id
+            : olGeometry.ol_uid;
+        const projection = this.map.ol.getView().getProjection();
+        const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {
+            featureProjection: projection,
+            dataProjection: projection
+        });
+        this.store.update({
+            type: FEATURE,
+            geometry,
+            projection: projection.getCode(),
+            properties: {
+                id: featureId,
+                measure: olGeometry.get('_measure')
+            },
+            meta: {
+                id: featureId
+            }
+        });
+    }
+    /**
+     * Update all the tooltips of an OL geometry
+     * @param olGeometry OL Geometry
+     * @param lengths Lengths of the OL geometry's segments
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateTooltipsOfOlGeometry(olGeometry) {
+        const measure = olGeometry.get('_measure');
+        const lengths = measure.lengths;
+        const area = measure.area;
+        const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);
+        if (lengths.length === olMidpointsTooltips.length) {
+            for (let i = 0; i < olMidpointsTooltips.length; i++) {
+                const length = lengths[i];
+                if (length !== undefined) {
+                    this.updateOlTooltip(olMidpointsTooltips[i], metersToUnit(length, this.activeLengthUnit), this.activeLengthUnit, MeasureType.Length);
+                }
+            }
+        }
+        if (area !== undefined) {
+            this.updateOlTooltip(updateOlTooltipAtCenter(olGeometry), squareMetersToUnit(area, this.activeAreaUnit), this.activeAreaUnit, MeasureType.Area);
+        }
+    }
+    /**
+     * Show the map tooltips of a geoemtry
+     */
+    showTooltipsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (this.shouldShowTooltip(olTooltip)) {
+                this.map.ol.addOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Clear the tooltips of an OL geometrys
+     * @param olGeometry OL geometry with tooltips
+     */
+    clearTooltipsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {
+                this.map.ol.removeOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Show the map tooltips of all the geometries of a source
+     */
+    updateTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            this.updateTooltipsOfOlGeometry(olFeature.getGeometry());
+        });
+    }
+    /**
+     * Show the map tooltips of all the geometries of a source
+     */
+    showTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            this.showTooltipsOfOlGeometry(olFeature.getGeometry());
+        });
+    }
+    /**
+     * Clear the map tooltips
+     * @param olDrawSource OL vector source
+     */
+    clearTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            const olGeometry = olFeature.getGeometry();
+            if (olGeometry !== undefined) {
+                this.clearTooltipsOfOlGeometry(olFeature.getGeometry());
+            }
+        });
+    }
+    /**
+     * Update an OL tooltip properties and inner HTML and add it to the map if possible
+     * @param olTooltip OL tooltip
+     * @param measure The measure valeu ti display
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateOlTooltip(olTooltip, measure, unit, type) {
+        olTooltip.setProperties({ _measure: measure, _unit: unit, _type: type }, true);
+        olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);
+        if (this.shouldShowTooltip(olTooltip)) {
+            this.map.ol.addOverlay(olTooltip);
+        }
+    }
+    /**
+     * Compute a tooltip's content
+     * @param olTooltip OL overlay
+     * @returns Inner HTML
+     */
+    computeTooltipInnerHTML(olTooltip) {
+        const properties = olTooltip.getProperties();
+        return formatMeasure(properties._measure, {
+            decimal: 1,
+            unit: properties._unit,
+            unitAbbr: true,
+            locale: 'fr'
+        }, this.languageService);
+    }
+    /**
+     * Whether a tooltip should be showned based on the length
+     * of the segment it is bound to.
+     * @param olTooltip OL overlay
+     * @returns True if the tooltip should be shown
+     */
+    shouldShowTooltip(olTooltip) {
+        if (this.showTooltips === false) {
+            return false;
+        }
+        const properties = olTooltip.getProperties();
+        const measure = properties._measure;
+        if (measure === undefined) {
+            return false;
+        }
+        if (properties._unit === MeasureType.Length) {
+            const minSegmentLength = metersToUnit(this.minSegmentLength, properties._unit) || 0;
+            return measure > Math.max(minSegmentLength, 0);
+        }
+        return true;
+    }
+    static ɵfac = function MeasurerComponent_Factory(t) { return new (t || MeasurerComponent)(i0.ɵɵdirectiveInject(i1.LanguageService), i0.ɵɵdirectiveInject(i2.MatDialog), i0.ɵɵdirectiveInject(i1.StorageService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MeasurerComponent, selectors: [["igo-measurer"]], viewQuery: function MeasurerComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.table = _t.first);
+        } }, inputs: { map: "map", store: "store", activeMeasureType: "activeMeasureType", minSegmentLength: "minSegmentLength" }, decls: 43, vars: 60, consts: [[1, "measure-type-toggle", "mat-typography"], [3, "value", "change"], [3, "value"], [1, "measure-options", "mat-typography"], [3, "disabled", "checked", "labelPosition", "change"], [4, "ngIf"], [3, "checked", "labelPosition", "change", 4, "ngIf"], [3, "checked", "labelPosition", "change"], [1, "measure-store-buttons"], ["mat-icon-button", "", "color", "accent", 3, "matTooltip", "disabled", "click", 4, "ngIf"], ["mat-icon-button", "", "color", "warn", 3, "matTooltip", "disabled", "click", 4, "ngIf"], [1, "table-compact", 3, "store", "template"], ["table", ""], [3, "measureType", "measureUnit", "measure", "auto", "placeholder", "measureUnitChange", 4, "ngIf"], [3, "measureType", "measureUnit", "measure", "auto", "placeholder", "measureUnitChange"], ["mat-icon-button", "", "color", "accent", 3, "matTooltip", "disabled", "click"], ["svgIcon", "calculator"], ["mat-icon-button", "", "color", "warn", 3, "matTooltip", "disabled", "click"], ["svgIcon", "delete"]], template: function MeasurerComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div")(1, "div", 0)(2, "mat-button-toggle-group", 1);
+            i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_button_toggle_group_change_2_listener($event) { return ctx.onMeasureTypeChange($event.value); });
+            i0.ɵɵelementStart(3, "mat-button-toggle", 2);
+            i0.ɵɵtext(4);
+            i0.ɵɵpipe(5, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelementStart(6, "mat-button-toggle", 2);
+            i0.ɵɵtext(7);
+            i0.ɵɵpipe(8, "translate");
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵelementStart(9, "div", 3)(10, "mat-slide-toggle", 4);
+            i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_slide_toggle_change_10_listener($event) { return ctx.onToggleDrawControl($event.checked); });
+            i0.ɵɵtext(11);
+            i0.ɵɵpipe(12, "translate");
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(13, MeasurerComponent_mat_divider_13_Template, 1, 0, "mat-divider", 5);
+            i0.ɵɵpipe(14, "async");
+            i0.ɵɵtemplate(15, MeasurerComponent_mat_slide_toggle_15_Template, 3, 5, "mat-slide-toggle", 6);
+            i0.ɵɵpipe(16, "async");
+            i0.ɵɵtemplate(17, MeasurerComponent_mat_divider_17_Template, 1, 0, "mat-divider", 5);
+            i0.ɵɵpipe(18, "async");
+            i0.ɵɵpipe(19, "async");
+            i0.ɵɵtemplate(20, MeasurerComponent_mat_slide_toggle_20_Template, 3, 5, "mat-slide-toggle", 6);
+            i0.ɵɵpipe(21, "async");
+            i0.ɵɵtemplate(22, MeasurerComponent_mat_slide_toggle_22_Template, 3, 5, "mat-slide-toggle", 6);
+            i0.ɵɵpipe(23, "async");
+            i0.ɵɵtemplate(24, MeasurerComponent_mat_divider_24_Template, 1, 0, "mat-divider", 5);
+            i0.ɵɵpipe(25, "async");
+            i0.ɵɵelementStart(26, "mat-slide-toggle", 7);
+            i0.ɵɵlistener("change", function MeasurerComponent_Template_mat_slide_toggle_change_26_listener($event) { return ctx.onToggleMeasureUnitsAuto($event.checked); });
+            i0.ɵɵtext(27);
+            i0.ɵɵpipe(28, "translate");
+            i0.ɵɵelementEnd()();
+            i0.ɵɵtemplate(29, MeasurerComponent_ng_container_29_Template, 3, 2, "ng-container", 5);
+            i0.ɵɵpipe(30, "async");
+            i0.ɵɵtemplate(31, MeasurerComponent_mat_divider_31_Template, 1, 0, "mat-divider", 5);
+            i0.ɵɵpipe(32, "async");
+            i0.ɵɵpipe(33, "async");
+            i0.ɵɵelementStart(34, "div", 8);
+            i0.ɵɵtemplate(35, MeasurerComponent_button_35_Template, 4, 6, "button", 9);
+            i0.ɵɵpipe(36, "async");
+            i0.ɵɵpipe(37, "async");
+            i0.ɵɵtemplate(38, MeasurerComponent_button_38_Template, 4, 6, "button", 10);
+            i0.ɵɵpipe(39, "async");
+            i0.ɵɵpipe(40, "async");
+            i0.ɵɵelementEnd();
+            i0.ɵɵelement(41, "igo-entity-table", 11, 12);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.activeMeasureType);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("value", ctx.measureType.Length);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 24, "igo.geo.measure." + ctx.measureType.Length), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("value", ctx.measureType.Area);
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(8, 26, "igo.geo.measure." + ctx.measureType.Area), " ");
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("disabled", ctx.drawControlIsDisabled)("checked", ctx.drawControlIsActive)("labelPosition", "before");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(12, 28, "igo.geo.measure.toggleActive"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(14, 30, ctx.hasLine$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(16, 32, ctx.hasLine$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(18, 34, ctx.hasLine$) || i0.ɵɵpipeBind1(19, 36, ctx.hasArea$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(21, 38, ctx.hasArea$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(23, 40, ctx.hasArea$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(25, 42, ctx.hasArea$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("checked", ctx.measureUnitsAuto)("labelPosition", "before");
+            i0.ɵɵadvance(1);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(28, 44, "igo.geo.measure.toggleAutoUnits"), " ");
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(30, 46, ctx.measure$));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(32, 48, ctx.hasLine$) || i0.ɵɵpipeBind1(33, 50, ctx.hasArea$));
+            i0.ɵɵadvance(4);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(36, 52, ctx.hasLine$) || i0.ɵɵpipeBind1(37, 54, ctx.hasArea$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(39, 56, ctx.hasLine$) || i0.ɵɵpipeBind1(40, 58, ctx.hasArea$));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("store", ctx.store)("template", ctx.tableTemplate);
+        } }, styles: ["[_nghost-%COMP%]   .measure-type-toggle[_ngcontent-%COMP%]{padding:10px;text-align:center}[_nghost-%COMP%]   .measure-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]{width:100%}[_nghost-%COMP%]   .measure-type-toggle[_ngcontent-%COMP%]   mat-button-toggle-group[_ngcontent-%COMP%]   mat-button-toggle[_ngcontent-%COMP%]{width:50%}[_nghost-%COMP%]   .measure-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]{width:100%;padding:10px}[_nghost-%COMP%]   .measure-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-form-field{width:100%}[_nghost-%COMP%]   .measure-options[_ngcontent-%COMP%]   mat-slide-toggle[_ngcontent-%COMP%]     .mdc-label{margin-left:0;width:calc(100% - 60px)}[_nghost-%COMP%]   .measure-store-buttons[_ngcontent-%COMP%]{margin-left:-2px}[_nghost-%COMP%]   .measure-store-buttons[_ngcontent-%COMP%]   button[_ngcontent-%COMP%]:first-of-type{margin-left:14px}[_nghost-%COMP%]   .table-compact[_ngcontent-%COMP%]     .mat-mdc-header-cell.mat-column-selectionCheckbox{width:52px}[_nghost-%COMP%]   .igo-map-tooltip[_ngcontent-%COMP%]{position:relative;border-radius:4px;padding:4px 8px;white-space:nowrap}[_nghost-%COMP%]   .igo-map-tooltip-hidden[_ngcontent-%COMP%]{display:none}[_nghost-%COMP%]   .igo-map-tooltip-measure-by-display[_ngcontent-%COMP%]{display:none}"], changeDetection: 0 });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MeasurerComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-measurer', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div>\n  <div class=\"measure-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      [value]=\"activeMeasureType\"\n      (change)=\"onMeasureTypeChange($event.value)\"\n    >\n      <mat-button-toggle [value]=\"measureType.Length\">\n        {{ 'igo.geo.measure.' + measureType.Length | translate }}\n      </mat-button-toggle>\n      <mat-button-toggle [value]=\"measureType.Area\">\n        {{ 'igo.geo.measure.' + measureType.Area | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"measure-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleActive' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasLine$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasLine$ | async\"\n      [checked]=\"displayLines\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayLines($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayLines' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayDistance\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayDistance($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayDistance' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayAreas\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayAreas($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayAreas' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasArea$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      [checked]=\"measureUnitsAuto\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleAutoUnits' | translate }}\n    </mat-slide-toggle>\n  </div>\n\n  <ng-container *ngIf=\"measure$ | async as measure\">\n    <igo-measurer-item\n      *ngIf=\"\n        activeMeasureType === measureType.Length ||\n        activeMeasureType === measureType.Area\n      \"\n      [measureType]=\"measureType.Length\"\n      [measureUnit]=\"measureLengthUnit.Meters\"\n      [measure]=\"measure.length\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"\n        (activeMeasureType === measureType.Area\n          ? 'igo.geo.measure.perimeter'\n          : 'igo.geo.measure.length'\n        ) | translate\n      \"\n      (measureUnitChange)=\"onLengthUnitChange($event)\"\n    >\n    </igo-measurer-item>\n\n    <igo-measurer-item\n      *ngIf=\"activeMeasureType === measureType.Area\"\n      [measureType]=\"measureType.Area\"\n      [measureUnit]=\"measureAreaUnit.SquareMeters\"\n      [measure]=\"measure.area\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\n      (measureUnitChange)=\"onAreaUnitChange($event)\"\n    >\n    </igo-measurer-item>\n  </ng-container>\n\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n  <div class=\"measure-store-buttons\">\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"accent\"\n      (click)=\"onCalculateClick()\"\n    >\n      <mat-icon svgIcon=\"calculator\"></mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"warn\"\n      (click)=\"onDeleteClick()\"\n    >\n      <mat-icon svgIcon=\"delete\"></mat-icon>\n    </button>\n\n    <!--button\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.modify.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length !== 1\"\n      (click)=\"onModifyClick()\">\n      <mat-icon svgIcon=\"edit\"></mat-icon>\n    </button-->\n  </div>\n\n  <igo-entity-table\n    #table\n    class=\"table-compact\"\n    [store]=\"store\"\n    [template]=\"tableTemplate\"\n  >\n  </igo-entity-table>\n</div>\n", styles: [":host .measure-type-toggle{padding:10px;text-align:center}:host .measure-type-toggle mat-button-toggle-group{width:100%}:host .measure-type-toggle mat-button-toggle-group mat-button-toggle{width:50%}:host .measure-options mat-slide-toggle{width:100%;padding:10px}:host .measure-options mat-slide-toggle ::ng-deep .mdc-form-field{width:100%}:host .measure-options mat-slide-toggle ::ng-deep .mdc-label{margin-left:0;width:calc(100% - 60px)}:host .measure-store-buttons{margin-left:-2px}:host .measure-store-buttons button:first-of-type{margin-left:14px}:host .table-compact ::ng-deep .mat-mdc-header-cell.mat-column-selectionCheckbox{width:52px}:host .igo-map-tooltip{position:relative;border-radius:4px;padding:4px 8px;white-space:nowrap}:host .igo-map-tooltip-hidden{display:none}:host .igo-map-tooltip-measure-by-display{display:none}\n"] }]
+    }], function () { return [{ type: i1.LanguageService }, { type: i2.MatDialog }, { type: i1.StorageService }]; }, { map: [{
+            type: Input
+        }], store: [{
+            type: Input
+        }], activeMeasureType: [{
+            type: Input
+        }], minSegmentLength: [{
+            type: Input
+        }], table: [{
+            type: ViewChild,
+            args: ['table', { static: true }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measurer.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.ts","../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  OnInit,\n  OnDestroy,\n  ChangeDetectionStrategy,\n  ViewChild\n} from '@angular/core';\nimport { MatDialog } from '@angular/material/dialog';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\n\nimport OlStyle from 'ol/style/Style';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport OlVectorSource from 'ol/source/Vector';\nimport { VectorSourceEvent as OlVectorSourceEvent } from 'ol/source/Vector';\nimport OlLineString from 'ol/geom/LineString';\nimport OlPolygon from 'ol/geom/Polygon';\nimport OlFeature from 'ol/Feature';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\nimport OlOverlay from 'ol/Overlay';\nimport { unByKey } from 'ol/Observable';\n\nimport { LanguageService, StorageScope, StorageService } from '@igo2/core';\nimport { EntityRecord, EntityTableTemplate } from '@igo2/common';\nimport type { EntityTableComponent } from '@igo2/common';\nimport { uuid } from '@igo2/utils';\n\nimport { FeatureDataSource } from '../../datasource';\nimport {\n  FEATURE,\n  FeatureStore,\n  FeatureStoreLoadingStrategy,\n  FeatureStoreSelectionStrategy,\n  tryBindStoreLayer,\n  tryAddLoadingStrategy,\n  tryAddSelectionStrategy\n} from '../../feature';\nimport { DrawControl, ModifyControl } from '../../geometry/shared';\nimport { VectorLayer } from '../../layer/shared';\nimport { IgoMap } from '../../map/shared';\n\nimport {\n  Measure,\n  MeasurerDialogData,\n  FeatureWithMeasure\n} from '../shared/measure.interfaces';\nimport {\n  MeasureType,\n  MeasureAreaUnit,\n  MeasureLengthUnit\n} from '../shared/measure.enum';\nimport {\n  measureOlGeometry,\n  createMeasureInteractionStyle,\n  createMeasureLayerStyle,\n  updateOlTooltipsAtMidpoints,\n  updateOlTooltipAtCenter,\n  getTooltipsOfOlGeometry,\n  squareMetersToUnit,\n  metersToUnit,\n  formatMeasure\n} from '../shared/measure.utils';\nimport { MeasurerDialogComponent } from './measurer-dialog.component';\n\n/**\n * Tool to measure lengths and areas\n */\n@Component({\n  selector: 'igo-measurer',\n  templateUrl: './measurer.component.html',\n  styleUrls: ['./measurer.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class MeasurerComponent implements OnInit, OnDestroy {\n  /**\n   * Table template\n   * @internal\n   */\n  public tableTemplate: EntityTableTemplate;\n\n  private subscriptions$$: Subscription[] = [];\n\n  /**\n   * Reference to the MeasureType enum\n   * @internal\n   */\n  public measureType = MeasureType;\n\n  /**\n   * Reference to the AreaMeasureUnit enum\n   * @internal\n   */\n  public measureAreaUnit = MeasureAreaUnit;\n\n  /**\n   * Reference to the LengthMeasureUnit enum\n   * @internal\n   */\n  public measureLengthUnit = MeasureLengthUnit;\n\n  /**\n   * Whether measure units should be automatically determined\n   * @internal\n   */\n  public measureUnitsAuto: boolean = false;\n\n  /**\n   * Whether display of distances of areas\n   * @internal\n   */\n  public displayDistance: boolean = true;\n\n  /**\n   * Whether display of distances of lines\n   * @internal\n   */\n  public displayLines: boolean = true;\n\n  /**\n   * Whether display of areas\n   * @internal\n   */\n  public displayAreas: boolean = true;\n\n  /**\n   * Observable of line boolean\n   * @internal\n   */\n  public hasLine$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n\n  /**\n   * Observable of area boolean\n   * @internal\n   */\n  public hasArea$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n\n  /**\n   * Observable of area\n   * @internal\n   */\n  public measure$: BehaviorSubject<Measure> = new BehaviorSubject({});\n\n  /**\n   * Observable of selected features\n   * @internal\n   */\n  public selectedFeatures$: BehaviorSubject<FeatureWithMeasure[]> =\n    new BehaviorSubject([]);\n\n  /**\n   * OL draw source\n   * @internal\n   */\n  public showTooltips: boolean = true;\n\n  /**\n   * Whether draw control toggle is disabled or not\n   * @internal\n   */\n  public drawControlIsDisabled: boolean = true;\n\n  /**\n   * Draw line control\n   */\n  private drawLineControl: DrawControl;\n\n  /**\n   * Draw polygon control\n   */\n  private drawPolygonControl: DrawControl;\n\n  /**\n   * Modify control\n   */\n  private modifyControl: ModifyControl;\n\n  /**\n   * Active OL geometry\n   */\n  private activeOlGeometry: OlLineString | OlPolygon;\n\n  /**\n   * Active mlength unit\n   */\n  private activeLengthUnit: MeasureLengthUnit = MeasureLengthUnit.Meters;\n\n  /**\n   * Active area unit\n   */\n  private activeAreaUnit: MeasureAreaUnit = MeasureAreaUnit.SquareMeters;\n\n  /**\n   * Feature added listener key\n   */\n  private onFeatureAddedKey;\n\n  /**\n   * Feature removed listener key\n   */\n  private onFeatureRemovedKey;\n\n  /**\n   * Active draw control\n   * @internal\n   */\n  private activeDrawControl: DrawControl;\n\n  /**\n   * Subscription to draw start\n   */\n  private drawStart$$: Subscription;\n\n  /**\n   * Subscription to draw end\n   */\n  private drawEnd$$: Subscription;\n\n  /**\n   * Subscription to controls changes\n   */\n  private drawChanges$$: Subscription;\n\n  /**\n   * Subscription to modify start\n   */\n  private modifyStart$$: Subscription;\n\n  /**\n   * Subscription to modify end\n   */\n  private modifyEnd$$: Subscription;\n\n  /**\n   * Subscription to controls changes\n   */\n  private modifyChanges$$: Subscription;\n\n  /**\n   * Subscription to measures selection\n   */\n  private selectedFeatures$$: Subscription;\n\n  /**\n   * OL draw source\n   */\n  private olDrawSource = new OlVectorSource();\n\n  /**\n   * The map to measure on\n   */\n  @Input() map: IgoMap;\n\n  /**\n   * The measures store\n   */\n  @Input() store: FeatureStore<FeatureWithMeasure>;\n\n  /**\n   * Measure type\n   * @internal\n   */\n  @Input()\n  set activeMeasureType(value: MeasureType) {\n    this.setActiveMeasureType(value);\n  }\n  get activeMeasureType(): MeasureType {\n    return this._activeMeasureType;\n  }\n  private _activeMeasureType: MeasureType;\n\n  /**\n   * The minimum length a segment must have to display a tooltip.\n   * It also applies to area tooltips.\n   */\n  @Input() minSegmentLength: number = 10;\n\n  @ViewChild('table', { static: true }) table: EntityTableComponent;\n\n  /**\n   * Wheter one of the draw control is active\n   * @internal\n   */\n  get drawControlIsActive(): boolean {\n    return this.activeDrawControl !== undefined;\n  }\n\n  get projection(): string {\n    return this.map.ol.getView().getProjection().getCode();\n  }\n\n  constructor(\n    private languageService: LanguageService,\n    private dialog: MatDialog,\n    private storageService: StorageService\n  ) {\n    this.tableTemplate = {\n      selection: true,\n      selectMany: true,\n      selectionCheckbox: true,\n      sort: true,\n      columns: [\n        {\n          name: 'length',\n          title: this.languageService.translate.instant(\n            'igo.geo.measure.lengthHeader'\n          ),\n          valueAccessor: (localFeature: FeatureWithMeasure) => {\n            const unit = this.activeLengthUnit;\n            const measure = metersToUnit(\n              localFeature.properties.measure.length,\n              unit\n            );\n            return formatMeasure(measure, {\n              decimal: 1,\n              unit,\n              unitAbbr: false,\n              locale: 'fr'\n            });\n          }\n        },\n        {\n          name: 'area',\n          title: this.languageService.translate.instant(\n            'igo.geo.measure.areaHeader'\n          ),\n          valueAccessor: (localFeature: FeatureWithMeasure) => {\n            const unit = this.activeAreaUnit;\n            const measure = squareMetersToUnit(\n              localFeature.properties.measure.area,\n              unit\n            );\n            return measure\n              ? formatMeasure(measure, {\n                  decimal: 1,\n                  unit,\n                  unitAbbr: false,\n                  locale: 'fr'\n                })\n              : '';\n          }\n        }\n      ]\n    };\n  }\n\n  /**\n   * Add draw controls and activate one\n   * @internal\n   */\n  ngOnInit() {\n    this.initStore();\n    this.createDrawLineControl();\n    this.createDrawPolygonControl();\n    this.createModifyControl();\n    this.toggleDrawControl();\n    this.updateTooltipsOfOlSource(this.store.source.ol);\n    this.checkDistanceAreaToggle();\n    this.setActiveMeasureType(MeasureType.Length);\n  }\n\n  /**\n   * Clear the overlay layer and any interaction added by this component.\n   * @internal\n   */\n  ngOnDestroy() {\n    this.setActiveMeasureType(undefined);\n    this.deactivateModifyControl();\n    this.freezeStore();\n    this.subscriptions$$.map((s) => s.unsubscribe());\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onMeasureTypeChange(measureType: MeasureType) {\n    this.activeMeasureType = measureType;\n  }\n\n  /**\n   * Activate or deactivate the current draw control\n   * @internal\n   */\n  onToggleDrawControl(toggle: boolean) {\n    if (toggle === true) {\n      this.toggleDrawControl();\n    } else {\n      this.deactivateDrawControl();\n    }\n  }\n\n  /**\n   * Activate or deactivate the current draw control\n   * @internal\n   */\n  onToggleMeasureUnitsAuto(toggle: boolean) {\n    this.measureUnitsAuto = toggle;\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of the areas\n   * @internal\n   */\n  onToggleDisplayDistance(toggle: boolean) {\n    this.displayDistance = toggle;\n    this.onDisplayDistance();\n    toggle\n      ? this.storageService.set('distanceToggle', true, StorageScope.SESSION)\n      : this.storageService.set('distanceToggle', false, StorageScope.SESSION);\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of the lines\n   * @internal\n   */\n  onToggleDisplayLines(toggle: boolean) {\n    this.displayLines = toggle;\n    this.onDisplayLines();\n    toggle\n      ? this.storageService.set('linesToggle', true, StorageScope.SESSION)\n      : this.storageService.set('linesToggle', false, StorageScope.SESSION);\n  }\n\n  /**\n   * Activate or deactivate the current display of areas\n   * @internal\n   */\n  onToggleDisplayAreas(toggle: boolean) {\n    this.displayAreas = toggle;\n    this.onDisplayAreas();\n    toggle\n      ? this.storageService.set('areasToggle', true, StorageScope.SESSION)\n      : this.storageService.set('areasToggle', false, StorageScope.SESSION);\n  }\n\n  /**\n   * Set display parametres in current values\n   * @internal\n   */\n  checkDistanceAreaToggle() {\n    if (this.storageService.get('distanceToggle') === false) {\n      this.displayDistance = false;\n    }\n    if (this.storageService.get('linesToggle') === false) {\n      this.displayLines = false;\n    }\n    if (this.storageService.get('areasToggle') === false) {\n      this.displayAreas = false;\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of areas\n   * @internal\n   */\n  onDisplayDistance() {\n    if (this.displayDistance) {\n      Array.from(\n        document.getElementsByClassName(\n          'igo-map-tooltip-measure-polygone-segments'\n        )\n      ).map((value: Element) =>\n        value.classList.remove('igo-map-tooltip-hidden')\n      );\n    } else {\n      Array.from(\n        document.getElementsByClassName(\n          'igo-map-tooltip-measure-polygone-segments'\n        )\n      ).map((value: Element) => value.classList.add('igo-map-tooltip-hidden'));\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of lines\n   * @internal\n   */\n  onDisplayLines() {\n    if (this.displayLines) {\n      Array.from(\n        document.getElementsByClassName('igo-map-tooltip-measure-line-segments')\n      ).map((value: Element) =>\n        value.classList.remove('igo-map-tooltip-hidden')\n      );\n    } else {\n      Array.from(\n        document.getElementsByClassName('igo-map-tooltip-measure-line-segments')\n      ).map((value: Element) => value.classList.add('igo-map-tooltip-hidden'));\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of areas\n   * @internal\n   */\n  onDisplayAreas() {\n    if (this.displayAreas) {\n      Array.from(\n        document.getElementsByClassName('igo-map-tooltip-measure-area')\n      ).map((value: Element) =>\n        value.classList.remove('igo-map-tooltip-hidden')\n      );\n    } else {\n      Array.from(\n        document.getElementsByClassName('igo-map-tooltip-measure-area')\n      ).map((value: Element) => value.classList.add('igo-map-tooltip-hidden'));\n    }\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onLengthUnitChange(unit: MeasureLengthUnit) {\n    this.activeLengthUnit = unit;\n    this.table.refresh();\n    this.updateTooltipsOfOlSource(this.store.source.ol);\n    if (this.activeOlGeometry !== undefined) {\n      this.updateTooltipsOfOlGeometry(this.activeOlGeometry);\n    }\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onAreaUnitChange(unit: MeasureAreaUnit) {\n    this.activeAreaUnit = unit;\n    this.table.refresh();\n    this.updateTooltipsOfOlSource(this.store.source.ol);\n    if (this.activeOlGeometry !== undefined) {\n      this.updateTooltipsOfOlGeometry(this.activeOlGeometry);\n    }\n  }\n\n  onCalculateClick() {\n    const features = this.selectedFeatures$.value;\n    const area = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        return sum + localFeature.properties.measure.area || 0;\n      },\n      0\n    );\n    const length = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        if (localFeature.geometry.type === 'Polygon') {\n          return sum;\n        }\n        return sum + localFeature.properties.measure.length || 0;\n      },\n      0\n    );\n    const perimeter = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        if (localFeature.geometry.type === 'LineString') {\n          return sum;\n        }\n        return sum + localFeature.properties.measure.length || 0;\n      },\n      0\n    );\n\n    this.openDialog({\n      area,\n      length,\n      perimeter\n    });\n  }\n\n  onDeleteClick() {\n    this.store.deleteMany(this.selectedFeatures$.value);\n    this.selectedFeatures$.value.forEach((selectedFeature) => {\n      this.olDrawSource.getFeatures().forEach((drawingLayerFeature) => {\n        const geometry = drawingLayerFeature.getGeometry() as any;\n        if (selectedFeature.properties.id === geometry.ol_uid) {\n          this.olDrawSource.removeFeature(drawingLayerFeature);\n        }\n      });\n    });\n  }\n\n  onModifyClick() {\n    if (this.selectedFeatures$.value.length !== 1) {\n      return;\n    }\n\n    if (this.modifyControl.active === true) {\n      this.deactivateModifyControl();\n      this.toggleDrawControl();\n    } else {\n      const localFeature = this.selectedFeatures$.value[0];\n      const olFeatures = this.store.layer.ol.getSource().getFeatures();\n      const olFeature = olFeatures.find((_olFeature: OlFeature<OlGeometry>) => {\n        return _olFeature.get('id') === localFeature.properties.id;\n      });\n\n      if (olFeature !== undefined) {\n        this.deactivateDrawControl();\n        this.activateModifyControl();\n\n        const olGeometry = olFeature.getGeometry();\n        this.clearTooltipsOfOlGeometry(olGeometry as OlLineString | OlPolygon);\n        this.modifyControl.setOlGeometry(olGeometry);\n      }\n    }\n  }\n\n  private openDialog(data: MeasurerDialogData): void {\n    this.dialog.open(MeasurerDialogComponent, { data });\n  }\n\n  /**\n   * Initialize the measure store and set up some listeners\n   * @internal\n   */\n  private initStore() {\n    const store = this.store;\n\n    const layer = new VectorLayer({\n      title: this.languageService.translate.instant(\n        'igo.geo.measure.layerTitle'\n      ),\n      isIgoInternalLayer: true,\n      id: `igo-measures-${uuid()}`,\n      zIndex: 200,\n      source: new FeatureDataSource(),\n      style: createMeasureLayerStyle(),\n      showInLayerList: true,\n      exportable: true,\n      browsable: false,\n      workspace: { enabled: false }\n    });\n    tryBindStoreLayer(store, layer);\n    store.layer.visible = true;\n    layer.visible$.subscribe((visible) => {\n      if (visible) {\n        Array.from(\n          document.getElementsByClassName('igo-map-tooltip-measure')\n        ).map((value: Element) =>\n          value.classList.remove('igo-map-tooltip-measure-by-display')\n        );\n      } else {\n        Array.from(\n          document.getElementsByClassName('igo-map-tooltip-measure')\n        ).map((value: Element) =>\n          value.classList.add('igo-map-tooltip-measure-by-display')\n        );\n      }\n    });\n\n    tryAddLoadingStrategy(store);\n\n    tryAddSelectionStrategy(\n      store,\n      new FeatureStoreSelectionStrategy({\n        map: this.map,\n        many: true\n      })\n    );\n\n    this.onFeatureAddedKey = store.source.ol.on(\n      'addfeature',\n      (event: OlVectorSourceEvent<OlGeometry>) => {\n        const localFeature = event.feature;\n        const olGeometry = localFeature.getGeometry() as any;\n        this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));\n        this.onDisplayDistance();\n      }\n    );\n\n    this.onFeatureRemovedKey = store.source.ol.on(\n      'removefeature',\n      (event: OlVectorSourceEvent<OlGeometry>) => {\n        const olGeometry = event.feature.getGeometry() as any;\n        this.clearTooltipsOfOlGeometry(olGeometry);\n      }\n    );\n\n    this.selectedFeatures$$ = store.stateView\n      .manyBy$((record: EntityRecord<FeatureWithMeasure>) => {\n        return record.state.selected === true;\n      })\n      .pipe(\n        skip(1) // Skip initial emission\n      )\n      .subscribe((records: EntityRecord<FeatureWithMeasure>[]) => {\n        if (this.modifyControl.active === true) {\n          this.deactivateModifyControl();\n        }\n        this.selectedFeatures$.next(records.map((record) => record.entity));\n      });\n\n    this.subscriptions$$.push(\n      this.store.entities$.subscribe((objectsExists) => {\n        if (\n          objectsExists.find(\n            (objectExist) => objectExist.geometry.type === 'Polygon'\n          )\n        ) {\n          this.hasArea$.next(true);\n        } else {\n          this.hasArea$.next(false);\n        }\n\n        if (\n          objectsExists.find(\n            (objectExist) => objectExist.geometry.type === 'LineString'\n          )\n        ) {\n          this.hasLine$.next(true);\n        } else {\n          this.hasLine$.next(false);\n        }\n      })\n    );\n\n    this.subscriptions$$.push(\n      this.store.count$.subscribe((cnt) => {\n        cnt >= 1\n          ? (this.store.layer.options.showInLayerList = true)\n          : (this.store.layer.options.showInLayerList = false);\n      })\n    );\n  }\n\n  /**\n   * Freeze any store, meaning the layer is removed, strategies are deactivated\n   * and some listener removed\n   * @internal\n   */\n  private freezeStore() {\n    const store = this.store;\n    this.selectedFeatures$$.unsubscribe();\n    unByKey(this.onFeatureAddedKey);\n    unByKey(this.onFeatureRemovedKey);\n    store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);\n    store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);\n  }\n\n  /**\n   * Create a draw line control\n   */\n  private createDrawLineControl() {\n    this.drawLineControl = new DrawControl({\n      geometryType: 'LineString',\n      drawingLayerSource: this.olDrawSource,\n      interactionStyle: createMeasureInteractionStyle(),\n      drawingLayerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Create a draw polygon control\n   */\n  private createDrawPolygonControl() {\n    this.drawPolygonControl = new DrawControl({\n      geometryType: 'Polygon',\n      drawingLayerSource: this.olDrawSource,\n      interactionStyle: createMeasureInteractionStyle(),\n      drawingLayerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Create a draw polygon control\n   */\n  private createModifyControl() {\n    this.modifyControl = new ModifyControl({\n      source: this.olDrawSource,\n      drawStyle: createMeasureInteractionStyle(),\n      layerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Activate the right control\n   */\n  private toggleDrawControl() {\n    this.deactivateDrawControl();\n    // this.deactivateModifyControl();\n    if (this.activeMeasureType === MeasureType.Length) {\n      this.activateDrawControl(this.drawLineControl);\n    } else if (this.activeMeasureType === MeasureType.Area) {\n      this.activateDrawControl(this.drawPolygonControl);\n    }\n  }\n\n  /**\n   * Activate a given control\n   * @param drawControl Draw control\n   */\n  private activateDrawControl(drawControl: DrawControl) {\n    this.drawControlIsDisabled = false;\n    this.activeDrawControl = drawControl;\n    this.drawStart$$ = drawControl.start$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawStart(olGeometry)\n    );\n    this.drawEnd$$ = drawControl.end$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawEnd(olGeometry)\n    );\n    this.drawChanges$$ = drawControl.changes$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawChanges(olGeometry)\n    );\n    this.drawChanges$$ = drawControl.abort$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => {\n        this.clearTooltipsOfOlGeometry(olGeometry);\n        this.clearMeasures();\n      }\n    );\n    drawControl.setOlMap(this.map.ol, false);\n  }\n\n  /**\n   * Deactivate the active draw control\n   */\n  private deactivateDrawControl() {\n    if (this.activeDrawControl === undefined) {\n      return;\n    }\n\n    this.olDrawSource.clear();\n    if (this.drawStart$$ !== undefined) {\n      this.drawStart$$.unsubscribe();\n    }\n    if (this.drawEnd$$ !== undefined) {\n      this.drawEnd$$.unsubscribe();\n    }\n    if (this.drawChanges$$ !== undefined) {\n      this.drawChanges$$.unsubscribe();\n    }\n\n    this.clearTooltipsOfOlSource(this.olDrawSource);\n    if (this.activeOlGeometry !== undefined) {\n      this.clearTooltipsOfOlGeometry(this.activeOlGeometry);\n    }\n    this.activeDrawControl.setOlMap(undefined);\n    this.activeDrawControl = undefined;\n    this.activeOlGeometry = undefined;\n  }\n\n  private setActiveMeasureType(measureType: MeasureType) {\n    this._activeMeasureType = measureType;\n    this.clearMeasures();\n    this.toggleDrawControl();\n  }\n\n  /**\n   * Clear the draw source and track the geometry being drawn\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawStart(olGeometry: OlLineString | OlPolygon) {\n    this.activeOlGeometry = olGeometry;\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawEnd(olGeometry: OlLineString | OlPolygon) {\n    this.activeOlGeometry = undefined;\n    this.finalizeMeasureOfOlGeometry(olGeometry);\n    this.addFeatureToStore(olGeometry);\n    this.clearTooltipsOfOlGeometry(olGeometry);\n    this.olDrawSource.clear(true);\n  }\n\n  /**\n   * Update measures observables and map tooltips\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawChanges(olGeometry: OlLineString | OlPolygon) {\n    const measure = measureOlGeometry(olGeometry, this.projection);\n    this.updateMeasureOfOlGeometry(\n      olGeometry,\n      Object.assign({}, measure, {\n        area: undefined // We don't want to display an area tooltip while drawing.\n      })\n    );\n    this.measure$.next(measure);\n  }\n\n  /**\n   * Activate a given control\n   * @param modifyControl Modify control\n   */\n  private activateModifyControl() {\n    const selection = this.store.getStrategyOfType(\n      FeatureStoreSelectionStrategy\n    ) as FeatureStoreSelectionStrategy;\n    selection.deactivate();\n    selection.clear();\n\n    this.modifyStart$$ = this.modifyControl.start$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyStart(olGeometry)\n    );\n    this.modifyEnd$$ = this.modifyControl.end$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyEnd(olGeometry)\n    );\n    this.modifyChanges$$ = this.modifyControl.changes$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyChanges(olGeometry)\n    );\n    this.modifyControl.setOlMap(this.map.ol);\n  }\n\n  /**\n   * Deactivate the active modify control\n   */\n  private deactivateModifyControl() {\n    if (this.modifyStart$$ !== undefined) {\n      this.modifyStart$$.unsubscribe();\n    }\n    if (this.modifyEnd$$ !== undefined) {\n      this.modifyEnd$$.unsubscribe();\n    }\n    if (this.modifyChanges$$ !== undefined) {\n      this.modifyChanges$$.unsubscribe();\n    }\n\n    if (this.activeOlGeometry !== undefined) {\n      if (this.selectedFeatures$.value.length === 1) {\n        const localFeature = this.selectedFeatures$.value[0];\n        this.addFeatureToStore(this.activeOlGeometry, localFeature);\n      }\n      this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);\n    }\n\n    this.olDrawSource.clear();\n\n    this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);\n\n    this.activeOlGeometry = undefined;\n    this.modifyControl.setOlMap(undefined);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being drawn\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyStart(olGeometry: OlLineString | OlPolygon) {\n    this.onDrawStart(olGeometry);\n  }\n\n  /**\n   * Update measures observables and map tooltips\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyChanges(olGeometry: OlLineString | OlPolygon) {\n    this.onDrawChanges(olGeometry);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyEnd(olGeometry: OlLineString | OlPolygon) {\n    this.finalizeMeasureOfOlGeometry(olGeometry);\n  }\n\n  private finalizeMeasureOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    const measure = measureOlGeometry(olGeometry, this.projection);\n    this.updateMeasureOfOlGeometry(olGeometry, measure);\n  }\n\n  /**\n   * Update measures observables\n   * @param olGeometry Ol linestring or polygon\n   * @param measure Measure\n   */\n  private updateMeasureOfOlGeometry(\n    olGeometry: OlLineString | OlPolygon,\n    measure: Measure\n  ) {\n    olGeometry.setProperties({ _measure: measure }, true);\n    this.updateTooltipsOfOlGeometry(olGeometry);\n  }\n\n  /**\n   * Clear the measures observables\n   */\n  private clearMeasures() {\n    this.measure$.next({});\n  }\n\n  /**\n   * Add a feature with measures to the store. The loading stragegy of the store\n   * will trigger and add the feature to the map.\n   * @internal\n   */\n  private addFeatureToStore(olGeometry, localFeature?: FeatureWithMeasure) {\n    const featureId = localFeature\n      ? localFeature.properties.id\n      : olGeometry.ol_uid;\n    const projection = this.map.ol.getView().getProjection();\n    const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {\n      featureProjection: projection,\n      dataProjection: projection\n    }) as any;\n    this.store.update({\n      type: FEATURE,\n      geometry,\n      projection: projection.getCode(),\n      properties: {\n        id: featureId,\n        measure: olGeometry.get('_measure')\n      },\n      meta: {\n        id: featureId\n      }\n    });\n  }\n\n  /**\n   * Update all the tooltips of an OL geometry\n   * @param olGeometry OL Geometry\n   * @param lengths Lengths of the OL geometry's segments\n   * @param measureUnit Display tooltip measure in those units\n   */\n  private updateTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    const measure = olGeometry.get('_measure');\n    const lengths = measure.lengths;\n    const area = measure.area;\n\n    const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);\n    if (lengths.length === olMidpointsTooltips.length) {\n      for (let i = 0; i < olMidpointsTooltips.length; i++) {\n        const length = lengths[i];\n        if (length !== undefined) {\n          this.updateOlTooltip(\n            olMidpointsTooltips[i],\n            metersToUnit(length, this.activeLengthUnit),\n            this.activeLengthUnit,\n            MeasureType.Length\n          );\n        }\n      }\n    }\n\n    if (area !== undefined) {\n      this.updateOlTooltip(\n        updateOlTooltipAtCenter(olGeometry),\n        squareMetersToUnit(area, this.activeAreaUnit),\n        this.activeAreaUnit,\n        MeasureType.Area\n      );\n    }\n  }\n\n  /**\n   * Show the map tooltips of a geoemtry\n   */\n  private showTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    getTooltipsOfOlGeometry(olGeometry).forEach(\n      (olTooltip: OlOverlay | undefined) => {\n        if (this.shouldShowTooltip(olTooltip)) {\n          this.map.ol.addOverlay(olTooltip);\n        }\n      }\n    );\n  }\n\n  /**\n   * Clear the tooltips of an OL geometrys\n   * @param olGeometry OL geometry with tooltips\n   */\n  private clearTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    getTooltipsOfOlGeometry(olGeometry).forEach(\n      (olTooltip: OlOverlay | undefined) => {\n        if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {\n          this.map.ol.removeOverlay(olTooltip);\n        }\n      }\n    );\n  }\n\n  /**\n   * Show the map tooltips of all the geometries of a source\n   */\n  private updateTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\n      this.updateTooltipsOfOlGeometry(olFeature.getGeometry() as any);\n    });\n  }\n\n  /**\n   * Show the map tooltips of all the geometries of a source\n   */\n  private showTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\n      this.showTooltipsOfOlGeometry(olFeature.getGeometry() as any);\n    });\n  }\n\n  /**\n   * Clear the map tooltips\n   * @param olDrawSource OL vector source\n   */\n  private clearTooltipsOfOlSource(olSource: OlVectorSource<OlGeometry>) {\n    olSource.forEachFeature((olFeature: OlFeature<OlGeometry>) => {\n      const olGeometry = olFeature.getGeometry();\n      if (olGeometry !== undefined) {\n        this.clearTooltipsOfOlGeometry(olFeature.getGeometry() as any);\n      }\n    });\n  }\n\n  /**\n   * Update an OL tooltip properties and inner HTML and add it to the map if possible\n   * @param olTooltip OL tooltip\n   * @param measure The measure valeu ti display\n   * @param measureUnit Display tooltip measure in those units\n   */\n  private updateOlTooltip(\n    olTooltip: OlOverlay,\n    measure: number,\n    unit: MeasureAreaUnit | MeasureLengthUnit,\n    type: MeasureType\n  ) {\n    olTooltip.setProperties(\n      { _measure: measure, _unit: unit, _type: type },\n      true\n    );\n    olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);\n    if (this.shouldShowTooltip(olTooltip)) {\n      this.map.ol.addOverlay(olTooltip);\n    }\n  }\n\n  /**\n   * Compute a tooltip's content\n   * @param olTooltip OL overlay\n   * @returns Inner HTML\n   */\n  private computeTooltipInnerHTML(olTooltip: OlOverlay): string {\n    const properties = olTooltip.getProperties() as any;\n    return formatMeasure(\n      properties._measure,\n      {\n        decimal: 1,\n        unit: properties._unit,\n        unitAbbr: true,\n        locale: 'fr'\n      },\n      this.languageService\n    );\n  }\n\n  /**\n   * Whether a tooltip should be showned based on the length\n   * of the segment it is bound to.\n   * @param olTooltip OL overlay\n   * @returns True if the tooltip should be shown\n   */\n  private shouldShowTooltip(olTooltip: OlOverlay): boolean {\n    if (this.showTooltips === false) {\n      return false;\n    }\n\n    const properties = olTooltip.getProperties() as any;\n    const measure = properties._measure;\n    if (measure === undefined) {\n      return false;\n    }\n\n    if (properties._unit === MeasureType.Length) {\n      const minSegmentLength =\n        metersToUnit(this.minSegmentLength, properties._unit) || 0;\n      return measure > Math.max(minSegmentLength, 0);\n    }\n\n    return true;\n  }\n}\n","<div>\n  <div class=\"measure-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      [value]=\"activeMeasureType\"\n      (change)=\"onMeasureTypeChange($event.value)\"\n    >\n      <mat-button-toggle [value]=\"measureType.Length\">\n        {{ 'igo.geo.measure.' + measureType.Length | translate }}\n      </mat-button-toggle>\n      <mat-button-toggle [value]=\"measureType.Area\">\n        {{ 'igo.geo.measure.' + measureType.Area | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"measure-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleActive' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasLine$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasLine$ | async\"\n      [checked]=\"displayLines\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayLines($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayLines' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayDistance\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayDistance($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayDistance' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayAreas\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayAreas($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayAreas' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasArea$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      [checked]=\"measureUnitsAuto\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleAutoUnits' | translate }}\n    </mat-slide-toggle>\n  </div>\n\n  <ng-container *ngIf=\"measure$ | async as measure\">\n    <igo-measurer-item\n      *ngIf=\"\n        activeMeasureType === measureType.Length ||\n        activeMeasureType === measureType.Area\n      \"\n      [measureType]=\"measureType.Length\"\n      [measureUnit]=\"measureLengthUnit.Meters\"\n      [measure]=\"measure.length\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"\n        (activeMeasureType === measureType.Area\n          ? 'igo.geo.measure.perimeter'\n          : 'igo.geo.measure.length'\n        ) | translate\n      \"\n      (measureUnitChange)=\"onLengthUnitChange($event)\"\n    >\n    </igo-measurer-item>\n\n    <igo-measurer-item\n      *ngIf=\"activeMeasureType === measureType.Area\"\n      [measureType]=\"measureType.Area\"\n      [measureUnit]=\"measureAreaUnit.SquareMeters\"\n      [measure]=\"measure.area\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\n      (measureUnitChange)=\"onAreaUnitChange($event)\"\n    >\n    </igo-measurer-item>\n  </ng-container>\n\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n  <div class=\"measure-store-buttons\">\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"accent\"\n      (click)=\"onCalculateClick()\"\n    >\n      <mat-icon svgIcon=\"calculator\"></mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"warn\"\n      (click)=\"onDeleteClick()\"\n    >\n      <mat-icon svgIcon=\"delete\"></mat-icon>\n    </button>\n\n    <!--button\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.modify.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length !== 1\"\n      (click)=\"onModifyClick()\">\n      <mat-icon svgIcon=\"edit\"></mat-icon>\n    </button-->\n  </div>\n\n  <igo-entity-table\n    #table\n    class=\"table-compact\"\n    [store]=\"store\"\n    [template]=\"tableTemplate\"\n  >\n  </igo-entity-table>\n</div>\n"]}