@igo2/geo 1.12.1 → 1.13.0-alpha.0

package/esm2020/lib/geometry/geometry-form-field/geometry-form-field-input.component.mjs

@@ -0,0 +1,511 @@
+import { Component, Input, Optional, Self, ChangeDetectionStrategy } from '@angular/core';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import OlFeature from 'ol/Feature';
+import OlVectorSource from 'ol/source/Vector';
+import OlVectorLayer from 'ol/layer/Vector';
+import OlOverlay from 'ol/Overlay';
+import * as olproj from 'ol/proj';
+import Point from 'ol/geom/Point';
+import { MeasureLengthUnit, updateOlGeometryMidpoints, formatMeasure, measureOlGeometry } from '../../measure';
+import { DrawControl, ModifyControl } from '../shared/controls';
+import { createDrawInteractionStyle } from '../shared/geometry.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+function GeometryFormFieldInputComponent_ng_template_0_Template(rf, ctx) { }
+/**
+ * This input allows a user to draw a new geometry or to edit
+ * an existing one on a map. A text input is also displayed in the
+ * form with some instructions.
+ * This is still WIP.
+ */
+export class GeometryFormFieldInputComponent {
+    constructor(cdRef, ngControl) {
+        this.cdRef = cdRef;
+        this.ngControl = ngControl;
+        this.olGeoJSON = new OlGeoJSON();
+        this.ready = false;
+        this.olTooltip = this.createMeasureTooltip();
+        /**
+         * The drawGuide around the mouse pointer to help drawing
+         */
+        this.drawGuide = null;
+        /**
+         * Whether a measure tooltip should be displayed
+         */
+        this.measure = false;
+        this._drawControlIsActive = true;
+        /**
+         * Control options
+         */
+        this.controlOptions = {};
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        if (this.ngControl !== undefined) {
+            // Setting the value accessor directly (instead of using
+            // the providers) to avoid running into a circular import.
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    /**
+     * The geometry type
+     */
+    set geometryType(value) {
+        this._geometryType = value;
+        if (this.ready === false) {
+            return;
+        }
+        this.deactivateControl();
+        this.createDrawControl();
+        this.drawControl.freehand$.next(this.freehandDrawIsActive);
+        this.toggleControl();
+    }
+    get geometryType() { return this._geometryType; }
+    /**
+     * Whether draw control should be active or not
+     */
+    get drawControlIsActive() { return this._drawControlIsActive; }
+    set drawControlIsActive(value) {
+        this._drawControlIsActive = value;
+        if (this.ready === false) {
+            return;
+        }
+        this.deactivateControl();
+        if (!this._drawControlIsActive) {
+            return;
+        }
+        else {
+            this.toggleControl();
+        }
+    }
+    /**
+     * Whether freehand draw control should be active or not
+     */
+    get freehandDrawIsActive() { return this._freehandDrawIsActive; }
+    set freehandDrawIsActive(value) {
+        this._freehandDrawIsActive = value;
+        this.deactivateControl();
+        this.createDrawControl();
+        this.createModifyControl();
+        this.drawControl.freehand$.next(this.freehandDrawIsActive);
+        if (this.ready === false) {
+            return;
+        }
+        if (!this.drawControlIsActive) {
+            return;
+        }
+        this.toggleControl();
+    }
+    /**
+     * Style for the draw control (applies while the geometry is being drawn)
+     */
+    set drawStyle(value) {
+        if (value === undefined) {
+            value = createDrawInteractionStyle();
+        }
+        this._drawStyle = value;
+        const olGuideStyle = this.getGuideStyleFromDrawStyle(value);
+        if (olGuideStyle !== undefined) {
+            this.defaultDrawStyleRadius = olGuideStyle.getRadius();
+        }
+        else {
+            this.defaultDrawStyleRadius = null;
+        }
+        if (this.ready === false) {
+            return;
+        }
+        this.deactivateControl();
+        this.createDrawControl();
+        this.createModifyControl();
+        this.drawControl.freehand$.next(this.freehandDrawIsActive);
+        this.toggleControl();
+    }
+    get drawStyle() { return this._drawStyle; }
+    /**
+     * Style for the overlay layer (applies once the geometry is added to the map)
+     * If not specified, drawStyle applies
+     */
+    set overlayStyle(value) { this._overlayStyle = value; }
+    get overlayStyle() { return this._overlayStyle; }
+    /**
+     * The geometry value (GeoJSON)
+     * Implemented as part of ControlValueAccessor.
+     */
+    set value(value) {
+        this._value = value;
+        if (this.ready === false) {
+            return;
+        }
+        if (value) {
+            this.addGeoJSONToOverlay(value);
+        }
+        else {
+            this.olOverlaySource.clear(true);
+        }
+        this.onChange(value);
+        this.toggleControl();
+        this.cdRef.detectChanges();
+    }
+    get value() { return this._value; }
+    /**
+     * The vector source to add the geometry to
+     * @internal
+     */
+    get olOverlaySource() {
+        return this.olOverlayLayer.getSource();
+    }
+    set radius(value) {
+        if (this.ready === false) {
+            return;
+        }
+        if (this.modifyControl.getSource()) {
+            this.modifyControl.getSource().refresh();
+        }
+        if (this.freehandDrawIsActive) {
+            let olModify;
+            setTimeout(() => {
+                olModify = this.modifyControl.olModifyInteraction;
+                if (olModify) {
+                    if (olModify.features_) {
+                        olModify.features_.clear();
+                        this.addGeoJSONToOverlay(this.value);
+                    }
+                }
+            }, 0);
+        }
+    }
+    /**
+     * Create an overlay layer, add the initial geometry to it (if any)
+     * and toggle the right interaction.
+     * @internal
+     */
+    ngOnInit() {
+        if (this.drawStyle === undefined) {
+            this.drawStyle = createDrawInteractionStyle();
+        }
+        if (this.overlayStyle === undefined) {
+            this.overlayStyle = this.drawStyle;
+        }
+        this.addOlOverlayLayer();
+        this.createDrawControl();
+        this.createModifyControl();
+        if (this.value) {
+            this.addGeoJSONToOverlay(this.value);
+        }
+        this.toggleControl();
+        this.ready = true;
+    }
+    /**
+     * Clear the overlay layer and any interaction added by this component.
+     * @internal
+     */
+    ngOnDestroy() {
+        // This is mandatory when the form control is reused after
+        // this component has been destroyed. It seems like the control
+        // keeps a reference to this component even after it's destroyed
+        // and it attempts to set it's value
+        this.ready = false;
+        this.deactivateControl();
+        this.olOverlaySource.clear();
+        this.map.ol.removeLayer(this.olOverlayLayer);
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value) {
+        this.value = value;
+    }
+    /**
+     * Add an overlay layer to the map
+     */
+    addOlOverlayLayer() {
+        this.olOverlayLayer = new OlVectorLayer({
+            source: new OlVectorSource(),
+            zIndex: 500,
+            style: null
+        });
+        this.map.ol.addLayer(this.olOverlayLayer);
+    }
+    /**
+     * Create a draw control and subscribe to it's geometry
+     */
+    createDrawControl() {
+        const controlOptions = Object.assign({}, this.controlOptions, {
+            geometryType: this.geometryType || 'Point',
+            drawingLayer: this.olOverlayLayer,
+            interactionStyle: typeof this.drawStyle === 'function' ? this.drawStyle : (olFeature, resolution) => {
+                const style = this.drawStyle;
+                this.updateDrawStyleWithDrawGuide(style, resolution);
+                return style;
+            }
+        });
+        this.drawControl = new DrawControl(controlOptions);
+    }
+    /**
+     * Create a modify control and subscribe to it's geometry
+     */
+    createModifyControl() {
+        const controlOptions = Object.assign({}, this.controlOptions, {
+            layer: this.olOverlayLayer,
+            drawStyle: typeof this.drawStyle === 'function' ? this.drawStyle : (olFeature, resolution) => {
+                const style = this.drawStyle;
+                this.updateDrawStyleWithDrawGuide(style, resolution);
+                return style;
+            }
+        });
+        this.modifyControl = new ModifyControl(controlOptions);
+    }
+    /**
+     * Toggle the proper control (draw or modify)
+     */
+    toggleControl() {
+        let activate;
+        if (!this.value && this.geometryType) {
+            activate = this.drawControl;
+        }
+        else {
+            activate = this.modifyControl;
+        }
+        // If the control that should be activated
+        // is not the same as the current active control,
+        // deactivate the current control and activate the new one
+        // Otherwise, do nothing and keep the current control active
+        if (activate !== this.activeControl) {
+            this.deactivateControl();
+            this.activateControl(activate);
+        }
+    }
+    /**
+     * Activate a given control
+     * @param control Control
+     */
+    activateControl(control) {
+        this.activeControl = control;
+        this.olGeometryEnds$$ = control.end$
+            .subscribe((olGeometry) => this.onOlGeometryEnds(olGeometry));
+        if (this.measure === true && control === this.drawControl) {
+            this.olGeometryChanges$$ = control.changes$
+                .subscribe((olGeometry) => this.onOlGeometryChanges(olGeometry));
+        }
+        control.setOlMap(this.map.ol, false);
+    }
+    /**
+     * Deactivate the active control
+     */
+    deactivateControl() {
+        this.removeMeasureTooltip();
+        if (this.activeControl !== undefined) {
+            this.activeControl.setOlMap(undefined);
+        }
+        if (this.olGeometryEnds$$ !== undefined) {
+            this.olGeometryEnds$$.unsubscribe();
+        }
+        if (this.olGeometryChanges$$ !== undefined) {
+            this.olGeometryChanges$$.unsubscribe();
+        }
+        this.activeControl = undefined;
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onOlGeometryEnds(olGeometry) {
+        this.removeMeasureTooltip();
+        this.setOlGeometry(olGeometry);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onOlGeometryChanges(olGeometry) {
+        if (olGeometry.getType() !== 'Point') {
+            this.updateMeasureTooltip(olGeometry);
+        }
+    }
+    /**
+     * When drawing ends, convert the output value to GeoJSON and keep it.
+     * Restore the double click interaction.
+     * @param olGeometry OL geometry
+     */
+    setOlGeometry(olGeometry) {
+        let value;
+        if (olGeometry === undefined) {
+            return;
+        }
+        if (olGeometry.getType() === 'Circle') { // Because Circle doesn't exist as a GeoJSON object
+            olGeometry = this.circleToPoint(olGeometry);
+        }
+        value = this.olGeoJSON.writeGeometryObject(olGeometry, {
+            featureProjection: this.map.projection,
+            dataProjection: 'EPSG:4326'
+        });
+        if (olGeometry.get('radius')) {
+            value.radius = olGeometry.get('radius');
+            olGeometry.set('radius', value.radius);
+        }
+        this.writeValue(value);
+    }
+    circleToPoint(olGeometry) {
+        const center = olGeometry.getCenter();
+        const coordinates = olproj.transform(center, this.map.projection, 'EPSG:4326');
+        const radius = Math.round(olGeometry.getRadius() * (Math.cos((Math.PI / 180) * coordinates[1])));
+        // Convert it to a point object
+        olGeometry = new Point(center);
+        olGeometry.set('radius', radius, true);
+        return olGeometry;
+    }
+    /**
+     * Add a GeoJSON geometry to the overlay
+     * @param geometry GeoJSON geometry
+     */
+    addGeoJSONToOverlay(geometry) {
+        const olGeometry = this.olGeoJSON.readGeometry(geometry, {
+            dataProjection: 'EPSG:4326',
+            featureProjection: this.map.projection
+        });
+        const olFeature = new OlFeature({
+            geometry: olGeometry
+        });
+        olFeature.setStyle(this.overlayStyle);
+        this.olOverlaySource.clear();
+        this.olOverlaySource.addFeature(olFeature);
+    }
+    /**
+     * Create the measure tooltip
+     */
+    createMeasureTooltip() {
+        return new OlOverlay({
+            element: document.createElement('div'),
+            offset: [-30, -10],
+            className: [
+                'igo-map-tooltip',
+                'igo-map-tooltip-measure'
+            ].join(' '),
+            stopEvent: false
+        });
+    }
+    /**
+     * Update the measure tooltip of an OL geometry
+     * @param olGeometry OL Geometry
+     */
+    updateMeasureTooltip(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.map.projection);
+        const lengths = measure.lengths;
+        const lastIndex = olGeometry.getType() === 'Polygon' ? lengths.length - 2 : lengths.length - 1;
+        const lastLength = lengths[lastIndex];
+        const olMidpoints = updateOlGeometryMidpoints(olGeometry);
+        const olLastMidpoint = olMidpoints[lastIndex];
+        if (olMidpoints.length === 0 || olLastMidpoint === undefined) {
+            this.removeMeasureTooltip();
+            return;
+        }
+        this.olTooltip.setPosition(olLastMidpoint.getFlatCoordinates());
+        const innerHtml = formatMeasure(lastLength, {
+            decimal: 1,
+            unit: MeasureLengthUnit.Meters,
+            unitAbbr: true,
+            locale: 'fr'
+        });
+        this.olTooltip.getElement().innerHTML = innerHtml;
+        if (this.olTooltip.getMap() === undefined) {
+            this.map.ol.addOverlay(this.olTooltip);
+        }
+    }
+    /**
+     * Remove the measure tooltip from the map
+     */
+    removeMeasureTooltip() {
+        if (this.olTooltip.getMap && this.olTooltip.getMap() !== undefined) {
+            this.map.ol.removeOverlay(this.olTooltip);
+            this.olTooltip.setMap(undefined);
+        }
+    }
+    /**
+     * Adjust the draw style with the specified draw guide distance, if possible
+     * @param olStyle Draw style to update
+     * @param resolution Resolution (to make the screen size of symbol fit the drawGuide value)
+     */
+    updateDrawStyleWithDrawGuide(olStyle, resolution) {
+        const olGuideStyle = this.getGuideStyleFromDrawStyle(olStyle);
+        if (olGuideStyle === undefined) {
+            return;
+        }
+        const drawGuide = this.drawGuide;
+        let radius;
+        if (!drawGuide || drawGuide < 0) {
+            radius = this.defaultDrawStyleRadius;
+        }
+        else {
+            radius = drawGuide > 0 ? drawGuide / resolution : drawGuide;
+        }
+        olGuideStyle.setRadius(radius);
+    }
+    /**
+     * Returns wether a given Open Layers style has a radius property that can be set (used to set draw guide)
+     * @param olStyle The style on which to perform the check
+     */
+    isStyleWithRadius(olStyle) {
+        return typeof olStyle !== 'function' && olStyle.setRadius;
+    }
+    /**
+     * Returns wether a given Open Layers style has a radius property that can be set (used to set draw guide)
+     * @param olStyle The style on which to perform the check
+     */
+    getGuideStyleFromDrawStyle(olStyle) {
+        if (Array.isArray(olStyle)) {
+            olStyle = olStyle[0];
+        }
+        if (this.isStyleWithRadius(olStyle)) {
+            return olStyle;
+        }
+        return undefined;
+    }
+}
+GeometryFormFieldInputComponent.ɵfac = function GeometryFormFieldInputComponent_Factory(t) { return new (t || GeometryFormFieldInputComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.NgControl, 10)); };
+GeometryFormFieldInputComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: GeometryFormFieldInputComponent, selectors: [["igo-geometry-form-field-input"]], inputs: { map: "map", geometryType: "geometryType", drawGuide: "drawGuide", measure: "measure", drawControlIsActive: "drawControlIsActive", freehandDrawIsActive: "freehandDrawIsActive", controlOptions: "controlOptions", drawStyle: "drawStyle", overlayStyle: "overlayStyle", value: "value", radius: "radius" }, decls: 1, vars: 0, template: function GeometryFormFieldInputComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, GeometryFormFieldInputComponent_ng_template_0_Template, 0, 0, "ng-template");
+    } }, encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GeometryFormFieldInputComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-geometry-form-field-input', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template></ng-template>" }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.NgControl, decorators: [{
+                type: Optional
+            }, {
+                type: Self
+            }] }]; }, { map: [{
+            type: Input
+        }], geometryType: [{
+            type: Input
+        }], drawGuide: [{
+            type: Input
+        }], measure: [{
+            type: Input
+        }], drawControlIsActive: [{
+            type: Input
+        }], freehandDrawIsActive: [{
+            type: Input
+        }], controlOptions: [{
+            type: Input
+        }], drawStyle: [{
+            type: Input
+        }], overlayStyle: [{
+            type: Input
+        }], value: [{
+            type: Input
+        }], radius: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry-form-field-input.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/geometry/geometry-form-field/geometry-form-field-input.component.ts","../../../../../../packages/geo/src/lib/geometry/geometry-form-field/geometry-form-field-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DrawControlOptions } from './../shared/controls/draw';\r\nimport {\r\n  Component,\r\n  Input,\r\n  OnInit,\r\n  OnDestroy,\r\n  Optional,\r\n  Self,\r\n  ChangeDetectorRef,\r\n  ChangeDetectionStrategy\r\n} from '@angular/core';\r\nimport { NgControl, ControlValueAccessor } from '@angular/forms';\r\n\r\nimport { Subscription } from 'rxjs';\r\n\r\nimport * as OlStyle from 'ol/style';\r\nimport OlGeoJSON from 'ol/format/GeoJSON';\r\nimport OlGeometry from 'ol/geom/Geometry';\r\nimport type { default as OlGeometryType } from 'ol/geom/GeometryType';\r\nimport OlFeature from 'ol/Feature';\r\nimport OlVectorSource from 'ol/source/Vector';\r\nimport OlVectorLayer from 'ol/layer/Vector';\r\nimport OlOverlay from 'ol/Overlay';\r\nimport * as olproj from 'ol/proj';\r\nimport Point from 'ol/geom/Point';\r\n\r\nimport { IgoMap } from '../../map';\r\nimport {\r\n  MeasureLengthUnit,\r\n  updateOlGeometryMidpoints,\r\n  formatMeasure,\r\n  measureOlGeometry\r\n} from '../../measure';\r\nimport { DrawControl, ModifyControl, ModifyControlOptions } from '../shared/controls';\r\nimport { createDrawInteractionStyle } from '../shared/geometry.utils';\r\nimport { GeoJSONGeometry } from '../shared/geometry.interfaces';\r\nimport OlCircle from 'ol/geom/Circle';\r\nimport OlLineString from 'ol/geom/LineString';\r\nimport OlPoint from 'ol/geom/Point';\r\nimport OlPolygon from 'ol/geom/Polygon';\r\n\r\n/**\r\n * This input allows a user to draw a new geometry or to edit\r\n * an existing one on a map. A text input is also displayed in the\r\n * form with some instructions.\r\n * This is still WIP.\r\n */\r\n@Component({\r\n  selector: 'igo-geometry-form-field-input',\r\n  templateUrl: './geometry-form-field-input.component.html',\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class GeometryFormFieldInputComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n\r\n  private olOverlayLayer: OlVectorLayer<OlVectorSource<OlGeometry>>;\r\n  private olGeoJSON = new OlGeoJSON();\r\n  private ready = false;\r\n\r\n  private drawControl: DrawControl;\r\n  private modifyControl: ModifyControl;\r\n  private defaultDrawStyleRadius: number;\r\n  private olGeometryEnds$$: Subscription;\r\n  private olGeometryChanges$$: Subscription;\r\n  private olTooltip = this.createMeasureTooltip();\r\n\r\n  /**\r\n   * Active control\r\n   * @internal\r\n   */\r\n  public activeControl: DrawControl | ModifyControl;\r\n\r\n  /**\r\n   * The map to draw the geometry on\r\n   */\r\n  @Input() map: IgoMap;\r\n\r\n  /**\r\n   * The geometry type\r\n   */\r\n  @Input()\r\n  set geometryType(value: typeof OlGeometryType) {\r\n    this._geometryType = value;\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n\r\n    this.deactivateControl();\r\n    this.createDrawControl();\r\n    this.drawControl.freehand$.next(this.freehandDrawIsActive);\r\n    this.toggleControl();\r\n  }\r\n  get geometryType(): typeof OlGeometryType { return this._geometryType; }\r\n  private _geometryType: typeof OlGeometryType;\r\n\r\n  /**\r\n   * The drawGuide around the mouse pointer to help drawing\r\n   */\r\n  @Input() drawGuide: number = null;\r\n\r\n  /**\r\n   * Whether a measure tooltip should be displayed\r\n   */\r\n  @Input() measure: boolean = false;\r\n\r\n  /**\r\n   * Whether draw control should be active or not\r\n   */\r\n  @Input()\r\n  get drawControlIsActive(): boolean { return this._drawControlIsActive; }\r\n  set drawControlIsActive(value: boolean) {\r\n    this._drawControlIsActive = value;\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n    this.deactivateControl();\r\n    if (!this._drawControlIsActive) {\r\n      return;\r\n    } else {\r\n      this.toggleControl();\r\n    }\r\n  }\r\n  private _drawControlIsActive: boolean = true;\r\n\r\n  /**\r\n   * Whether freehand draw control should be active or not\r\n   */\r\n  @Input()\r\n  get freehandDrawIsActive(): boolean { return this._freehandDrawIsActive; }\r\n  set freehandDrawIsActive(value: boolean) {\r\n    this._freehandDrawIsActive = value;\r\n    this.deactivateControl();\r\n\r\n    this.createDrawControl();\r\n    this.createModifyControl();\r\n\r\n    this.drawControl.freehand$.next(this.freehandDrawIsActive);\r\n\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n\r\n    if (!this.drawControlIsActive) {\r\n      return;\r\n    }\r\n    this.toggleControl();\r\n  }\r\n  private _freehandDrawIsActive: boolean;\r\n\r\n  /**\r\n   * Control options\r\n   */\r\n  @Input() controlOptions: {[key: string]: any} = {};\r\n\r\n  /**\r\n   * Style for the draw control (applies while the geometry is being drawn)\r\n   */\r\n  @Input()\r\n  set drawStyle(value: OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle) {\r\n    if (value === undefined) {\r\n      value = createDrawInteractionStyle();\r\n    }\r\n    this._drawStyle = value;\r\n\r\n    const olGuideStyle = this.getGuideStyleFromDrawStyle(value) as OlStyle.Circle;\r\n    if (olGuideStyle !== undefined) {\r\n      this.defaultDrawStyleRadius = olGuideStyle.getRadius();\r\n    } else {\r\n      this.defaultDrawStyleRadius = null;\r\n    }\r\n\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n\r\n    this.deactivateControl();\r\n    this.createDrawControl();\r\n    this.createModifyControl();\r\n\r\n    this.drawControl.freehand$.next(this.freehandDrawIsActive);\r\n    this.toggleControl();\r\n  }\r\n  get drawStyle(): OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle { return this._drawStyle; }\r\n  private _drawStyle: OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle;\r\n\r\n  /**\r\n   * Style for the overlay layer (applies once the geometry is added to the map)\r\n   * If not specified, drawStyle applies\r\n   */\r\n  @Input()\r\n  set overlayStyle(value: OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle) { this._overlayStyle = value; }\r\n  get overlayStyle(): OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle { return this._overlayStyle; }\r\n  private _overlayStyle: OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle;\r\n\r\n  /**\r\n   * The geometry value (GeoJSON)\r\n   * Implemented as part of ControlValueAccessor.\r\n   */\r\n  @Input()\r\n  set value(value: GeoJSONGeometry) {\r\n    this._value = value;\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n\r\n    if (value) {\r\n      this.addGeoJSONToOverlay(value);\r\n    } else {\r\n      this.olOverlaySource.clear(true);\r\n    }\r\n    this.onChange(value);\r\n    this.toggleControl();\r\n    this.cdRef.detectChanges();\r\n  }\r\n  get value(): GeoJSONGeometry { return this._value; }\r\n  private _value: GeoJSONGeometry;\r\n\r\n  /**\r\n   * The vector source to add the geometry to\r\n   * @internal\r\n   */\r\n  get olOverlaySource(): OlVectorSource<OlGeometry> {\r\n    return this.olOverlayLayer.getSource();\r\n  }\r\n\r\n  @Input()\r\n  set radius(value: any) {\r\n    if (this.ready === false) {\r\n      return;\r\n    }\r\n    if (this.modifyControl.getSource()) {\r\n      this.modifyControl.getSource().refresh();\r\n    }\r\n    if (this.freehandDrawIsActive) {\r\n      let olModify;\r\n      setTimeout(() => {\r\n        olModify = this.modifyControl.olModifyInteraction;\r\n        if (olModify) {\r\n          if (olModify.features_) {\r\n            olModify.features_.clear();\r\n            this.addGeoJSONToOverlay(this.value);\r\n          }\r\n        }\r\n      }, 0);\r\n    }\r\n  }\r\n\r\n  constructor(\r\n    private cdRef: ChangeDetectorRef,\r\n    @Optional() @Self() public ngControl: NgControl\r\n  ) {\r\n    if (this.ngControl !== undefined) {\r\n      // Setting the value accessor directly (instead of using\r\n      // the providers) to avoid running into a circular import.\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create an overlay layer, add the initial geometry to it (if any)\r\n   * and toggle the right interaction.\r\n   * @internal\r\n   */\r\n  ngOnInit() {\r\n    if (this.drawStyle === undefined) {\r\n      this.drawStyle = createDrawInteractionStyle();\r\n    }\r\n\r\n    if (this.overlayStyle === undefined) {\r\n      this.overlayStyle = this.drawStyle;\r\n    }\r\n\r\n    this.addOlOverlayLayer();\r\n    this.createDrawControl();\r\n    this.createModifyControl();\r\n\r\n    if (this.value) {\r\n      this.addGeoJSONToOverlay(this.value);\r\n    }\r\n    this.toggleControl();\r\n\r\n    this.ready = true;\r\n  }\r\n\r\n  /**\r\n   * Clear the overlay layer and any interaction added by this component.\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    // This is mandatory when the form control is reused after\r\n    // this component has been destroyed. It seems like the control\r\n    // keeps a reference to this component even after it's destroyed\r\n    // and it attempts to set it's value\r\n    this.ready = false;\r\n\r\n    this.deactivateControl();\r\n    this.olOverlaySource.clear();\r\n    this.map.ol.removeLayer(this.olOverlayLayer);\r\n  }\r\n\r\n  /**\r\n   * Implemented as part of ControlValueAccessor.\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/ban-types\r\n  registerOnChange(fn: Function) {\r\n    this.onChange = fn;\r\n  }\r\n  private onChange: any = () => {};\r\n\r\n  /**\r\n   * Implemented as part of ControlValueAccessor.\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/ban-types\r\n  registerOnTouched(fn: Function) {\r\n    this.onTouched = fn;\r\n  }\r\n  private onTouched: any = () => {};\r\n\r\n  /**\r\n   * Implemented as part of ControlValueAccessor.\r\n   */\r\n  writeValue(value: GeoJSONGeometry) {\r\n    this.value = value;\r\n  }\r\n\r\n  /**\r\n   * Add an overlay layer to the map\r\n   */\r\n  private addOlOverlayLayer() {\r\n    this.olOverlayLayer = new OlVectorLayer({\r\n      source: new OlVectorSource(),\r\n      zIndex: 500,\r\n      style: null\r\n    });\r\n    this.map.ol.addLayer(this.olOverlayLayer);\r\n  }\r\n\r\n  /**\r\n   * Create a draw control and subscribe to it's geometry\r\n   */\r\n  private createDrawControl() {\r\n    const controlOptions = Object.assign({}, this.controlOptions, {\r\n      geometryType: this.geometryType || 'Point',\r\n      drawingLayer: this.olOverlayLayer,\r\n      interactionStyle: typeof this.drawStyle === 'function' ? this.drawStyle : (olFeature: OlFeature<OlGeometry>, resolution: number) => {\r\n        const style = this.drawStyle;\r\n        this.updateDrawStyleWithDrawGuide(style, resolution);\r\n        return style;\r\n      }\r\n    }) as DrawControlOptions;\r\n    this.drawControl = new DrawControl(controlOptions);\r\n  }\r\n\r\n  /**\r\n   * Create a modify control and subscribe to it's geometry\r\n   */\r\n  private createModifyControl() {\r\n    const controlOptions = Object.assign({}, this.controlOptions, {\r\n      layer: this.olOverlayLayer,\r\n      drawStyle: typeof this.drawStyle === 'function' ? this.drawStyle : (olFeature: OlFeature<OlGeometry>, resolution: number) => {\r\n        const style = this.drawStyle;\r\n        this.updateDrawStyleWithDrawGuide(style, resolution);\r\n        return style;\r\n      }\r\n    }) as ModifyControlOptions;\r\n    this.modifyControl = new ModifyControl(controlOptions);\r\n  }\r\n\r\n  /**\r\n   * Toggle the proper control (draw or modify)\r\n   */\r\n  private toggleControl() {\r\n    let activate;\r\n    if (!this.value && this.geometryType) {\r\n      activate = this.drawControl;\r\n    } else {\r\n      activate = this.modifyControl;\r\n    }\r\n\r\n    // If the control that should be activated\r\n    // is not the same as the current active control,\r\n    // deactivate the current control and activate the new one\r\n    // Otherwise, do nothing and keep the current control active\r\n    if (activate !== this.activeControl) {\r\n      this.deactivateControl();\r\n      this.activateControl(activate);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Activate a given control\r\n   * @param control Control\r\n   */\r\n  private activateControl(control: DrawControl | ModifyControl) {\r\n    this.activeControl = control;\r\n    this.olGeometryEnds$$ = control.end$\r\n      .subscribe((olGeometry: OlGeometry) => this.onOlGeometryEnds(olGeometry));\r\n    if (this.measure === true && control === this.drawControl) {\r\n      this.olGeometryChanges$$ = control.changes$\r\n        .subscribe((olGeometry: OlPolygon | OlPoint | OlLineString | OlCircle) => this.onOlGeometryChanges(olGeometry));\r\n    }\r\n    control.setOlMap(this.map.ol, false);\r\n  }\r\n\r\n  /**\r\n   * Deactivate the active control\r\n   */\r\n  private deactivateControl() {\r\n    this.removeMeasureTooltip();\r\n    if (this.activeControl !== undefined) {\r\n      this.activeControl.setOlMap(undefined);\r\n    }\r\n    if (this.olGeometryEnds$$ !== undefined) {\r\n      this.olGeometryEnds$$.unsubscribe();\r\n    }\r\n    if (this.olGeometryChanges$$ !== undefined) {\r\n      this.olGeometryChanges$$.unsubscribe();\r\n    }\r\n    this.activeControl = undefined;\r\n  }\r\n\r\n  /**\r\n   * Update measures observables and map tooltips\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onOlGeometryEnds(olGeometry: OlGeometry | undefined) {\r\n    this.removeMeasureTooltip();\r\n    this.setOlGeometry(olGeometry);\r\n  }\r\n\r\n  /**\r\n   * Update measures observables and map tooltips\r\n   * @param olGeometry Ol linestring or polygon\r\n   */\r\n  private onOlGeometryChanges(olGeometry: OlPolygon | OlPoint | OlLineString | OlCircle) {\r\n    if (olGeometry.getType() !== 'Point') {\r\n      this.updateMeasureTooltip(olGeometry);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * When drawing ends, convert the output value to GeoJSON and keep it.\r\n   * Restore the double click interaction.\r\n   * @param olGeometry OL geometry\r\n   */\r\n  private setOlGeometry(olGeometry: OlGeometry | undefined) {\r\n    let value;\r\n    if (olGeometry === undefined) {\r\n      return;\r\n    }\r\n\r\n    if (olGeometry.getType() === 'Circle') { // Because Circle doesn't exist as a GeoJSON object\r\n      olGeometry = this.circleToPoint(olGeometry);\r\n    }\r\n\r\n    value = this.olGeoJSON.writeGeometryObject(olGeometry, {\r\n      featureProjection: this.map.projection,\r\n      dataProjection: 'EPSG:4326'\r\n    });\r\n    if (olGeometry.get('radius')) {\r\n      value.radius = olGeometry.get('radius');\r\n      olGeometry.set('radius', value.radius);\r\n    }\r\n    this.writeValue(value);\r\n  }\r\n\r\n  private circleToPoint(olGeometry) {\r\n    const center = olGeometry.getCenter();\r\n    const coordinates = olproj.transform(center, this.map.projection, 'EPSG:4326');\r\n    const radius = Math.round(olGeometry.getRadius() * (Math.cos((Math.PI / 180) * coordinates[1])));\r\n\r\n    // Convert it to a point object\r\n    olGeometry = new Point(center);\r\n    olGeometry.set('radius', radius, true);\r\n    return olGeometry;\r\n  }\r\n\r\n  /**\r\n   * Add a GeoJSON geometry to the overlay\r\n   * @param geometry GeoJSON geometry\r\n   */\r\n  private addGeoJSONToOverlay(geometry: GeoJSONGeometry) {\r\n    const olGeometry = this.olGeoJSON.readGeometry(geometry, {\r\n      dataProjection: 'EPSG:4326',\r\n      featureProjection: this.map.projection\r\n    });\r\n    const olFeature = new OlFeature({\r\n      geometry: olGeometry\r\n    });\r\n    olFeature.setStyle(this.overlayStyle as OlStyle.Style);\r\n    this.olOverlaySource.clear();\r\n    this.olOverlaySource.addFeature(olFeature);\r\n  }\r\n\r\n  /**\r\n   * Create the measure tooltip\r\n   */\r\n  private createMeasureTooltip() {\r\n    return new OlOverlay({\r\n      element: document.createElement('div'),\r\n      offset: [-30, -10],\r\n      className: [\r\n        'igo-map-tooltip',\r\n        'igo-map-tooltip-measure'\r\n      ].join(' '),\r\n      stopEvent: false\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Update the measure tooltip of an OL geometry\r\n   * @param olGeometry OL Geometry\r\n   */\r\n  private updateMeasureTooltip(olGeometry: OlPolygon | OlPoint | OlLineString | OlCircle) {\r\n    const measure = measureOlGeometry(olGeometry, this.map.projection);\r\n    const lengths = measure.lengths;\r\n    const lastIndex = olGeometry.getType() === 'Polygon' ? lengths.length - 2 : lengths.length - 1;\r\n    const lastLength = lengths[lastIndex];\r\n\r\n    const olMidpoints = updateOlGeometryMidpoints(olGeometry);\r\n    const olLastMidpoint = olMidpoints[lastIndex];\r\n    if (olMidpoints.length === 0 || olLastMidpoint === undefined) {\r\n      this.removeMeasureTooltip();\r\n      return;\r\n    }\r\n\r\n    this.olTooltip.setPosition(olLastMidpoint.getFlatCoordinates());\r\n\r\n    const innerHtml = formatMeasure(lastLength, {\r\n      decimal: 1,\r\n      unit: MeasureLengthUnit.Meters,\r\n      unitAbbr: true,\r\n      locale: 'fr'\r\n    });\r\n    this.olTooltip.getElement().innerHTML = innerHtml;\r\n    if (this.olTooltip.getMap() === undefined) {\r\n      this.map.ol.addOverlay(this.olTooltip);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove the measure tooltip from the map\r\n   */\r\n  private removeMeasureTooltip() {\r\n    if (this.olTooltip.getMap && this.olTooltip.getMap() !== undefined) {\r\n      this.map.ol.removeOverlay(this.olTooltip);\r\n      this.olTooltip.setMap(undefined);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Adjust the draw style with the specified draw guide distance, if possible\r\n   * @param olStyle Draw style to update\r\n   * @param resolution Resolution (to make the screen size of symbol fit the drawGuide value)\r\n   */\r\n  private updateDrawStyleWithDrawGuide(\r\n    olStyle: OlStyle.Style |\r\n    ((feature, resolution) => OlStyle.Style) |\r\n    OlStyle.Circle,\r\n    resolution: number) {\r\n    const olGuideStyle = this.getGuideStyleFromDrawStyle(olStyle) as OlStyle.Circle;\r\n    if (olGuideStyle === undefined) {\r\n      return;\r\n    }\r\n\r\n    const drawGuide = this.drawGuide;\r\n    let radius;\r\n    if (!drawGuide || drawGuide < 0) {\r\n      radius = this.defaultDrawStyleRadius;\r\n    } else {\r\n      radius = drawGuide > 0 ? drawGuide / resolution : drawGuide;\r\n    }\r\n    olGuideStyle.setRadius(radius);\r\n  }\r\n\r\n  /**\r\n   * Returns wether a given Open Layers style has a radius property that can be set (used to set draw guide)\r\n   * @param olStyle The style on which to perform the check\r\n   */\r\n  private isStyleWithRadius(olStyle) {\r\n    return typeof olStyle !== 'function' && olStyle.setRadius;\r\n  }\r\n\r\n  /**\r\n   * Returns wether a given Open Layers style has a radius property that can be set (used to set draw guide)\r\n   * @param olStyle The style on which to perform the check\r\n   */\r\n  private getGuideStyleFromDrawStyle(\r\n    olStyle: OlStyle.Style | ((feature, resolution) => OlStyle.Style) | OlStyle.Circle |\r\n    OlStyle.Style[] | ((feature, resolution) => OlStyle.Style)[] | OlStyle.Circle[]\r\n  ) {\r\n    if (Array.isArray(olStyle)) {\r\n      olStyle = olStyle[0];\r\n    }\r\n    if (this.isStyleWithRadius(olStyle)) {\r\n      return olStyle;\r\n    }\r\n    return undefined;\r\n  }\r\n}\r\n","<ng-template></ng-template>"]}