@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,189 @@
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { IgoFormFieldComponent } from '@igo2/common';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/input";
+import * as i6 from "@angular/material/button-toggle";
+import * as i7 from "./geometry-form-field-input.component";
+import * as i8 from "@ngx-translate/core";
+function GeometryFormFieldComponent_div_3_Template(rf, ctx) { if (rf & 1) {
+    const _r3 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 3)(1, "mat-button-toggle-group", 4);
+    i0.ɵɵlistener("ngModelChange", function GeometryFormFieldComponent_div_3_Template_mat_button_toggle_group_ngModelChange_1_listener($event) { i0.ɵɵrestoreView(_r3); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.geometryType = $event); });
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵelementStart(3, "mat-button-toggle", 5);
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(6, "mat-button-toggle", 6);
+    i0.ɵɵtext(7);
+    i0.ɵɵpipe(8, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementStart(9, "mat-button-toggle", 7);
+    i0.ɵɵtext(10);
+    i0.ɵɵpipe(11, "translate");
+    i0.ɵɵelementEnd()()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("disabled", i0.ɵɵpipeBind1(2, 8, ctx_r0.value$) !== undefined)("ngModel", ctx_r0.geometryType);
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("disabled", ctx_r0.geometryTypes.indexOf("Point") < 0);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 10, "igo.geo.geometry.point"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("disabled", ctx_r0.geometryTypes.indexOf("LineString") < 0);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(8, 12, "igo.geo.geometry.line"), " ");
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("disabled", ctx_r0.geometryTypes.indexOf("Polygon") < 0);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(11, 14, "igo.geo.geometry.polygon"), " ");
+} }
+function GeometryFormFieldComponent_mat_form_field_4_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-form-field", 8)(1, "input", 9);
+    i0.ɵɵlistener("ngModelChange", function GeometryFormFieldComponent_mat_form_field_4_Template_input_ngModelChange_1_listener($event) { i0.ɵɵrestoreView(_r5); const ctx_r4 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r4.drawGuide = $event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(2, "mat-icon", 10);
+    i0.ɵɵelementStart(3, "span", 11);
+    i0.ɵɵtext(4);
+    i0.ɵɵpipe(5, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("placeholder", ctx_r1.drawGuidePlaceholder)("ngModel", ctx_r1.drawGuide);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("color", "primary");
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(5, 4, "igo.geo.measure.meters"));
+} }
+/**
+ * This input allows a user to draw a new geometry or to edit
+ * an existing one on a map.
+ */
+let GeometryFormFieldComponent = class GeometryFormFieldComponent {
+    constructor(cdRef) {
+        this.cdRef = cdRef;
+        this.value$ = new BehaviorSubject(undefined);
+        this._drawControlIsActive = true;
+        this._freehandDrawIsActive = false;
+        this.geometryType$ = new BehaviorSubject(undefined);
+        /**
+         * Whether a geometry type toggle should be displayed
+         */
+        this.geometryTypeField = false;
+        /**
+         * Available geometry types
+         */
+        this.geometryTypes = ['Point', 'LineString', 'Polygon'];
+        /**
+         * Whether a draw guide field should be displayed
+         */
+        this.drawGuideField = false;
+        this.drawGuide$ = new BehaviorSubject(0);
+        /**
+         * Draw guide placeholder
+         */
+        this.drawGuidePlaceholder = '';
+        /**
+         * Whether a measure tooltip should be displayed
+         */
+        this.measure = false;
+        /**
+         * Control options
+         */
+        this.controlOptions = {};
+    }
+    set drawControlIsActive(value) {
+        this._drawControlIsActive = value;
+        this.cdRef.detectChanges();
+    }
+    get drawControlIsActive() {
+        return this._drawControlIsActive;
+    }
+    set freehandDrawIsActive(value) {
+        this._freehandDrawIsActive = value;
+        this.cdRef.detectChanges();
+    }
+    get freehandDrawIsActive() {
+        return this._freehandDrawIsActive;
+    }
+    set geometryType(value) { this.geometryType$.next(value); }
+    get geometryType() { return this.geometryType$.value; }
+    /**
+     * The drawGuide around the mouse pointer to help drawing
+     */
+    set drawGuide(value) { this.drawGuide$.next(value); }
+    get drawGuide() { return this.drawGuide$.value; }
+    /**
+     * Set up a value stream
+     * @internal
+     */
+    ngOnInit() {
+        this.value$.next(this.formControl.value ? this.formControl.value : undefined);
+        this.value$$ = this.formControl.valueChanges.subscribe((value) => {
+            this.value$.next(value ? value : undefined);
+        });
+    }
+    /**
+     * Unsubscribe to the value stream
+     * @internal
+     */
+    ngOnDestroy() {
+        this.value$$.unsubscribe();
+    }
+};
+GeometryFormFieldComponent.ɵfac = function GeometryFormFieldComponent_Factory(t) { return new (t || GeometryFormFieldComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+GeometryFormFieldComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: GeometryFormFieldComponent, selectors: [["igo-geometry-form-field"]], inputs: { formControl: "formControl", map: "map", geometryType: "geometryType", geometryTypeField: "geometryTypeField", geometryTypes: "geometryTypes", drawGuideField: "drawGuideField", drawGuide: "drawGuide", drawGuidePlaceholder: "drawGuidePlaceholder", measure: "measure", controlOptions: "controlOptions", drawStyle: "drawStyle", overlayStyle: "overlayStyle" }, decls: 5, vars: 16, consts: [[3, "formControl", "map", "geometryType", "drawGuide", "measure", "drawControlIsActive", "freehandDrawIsActive", "controlOptions", "drawStyle", "overlayStyle"], ["class", "geometry-type-toggle", 4, "ngIf"], ["class", "draw-guide-field", 4, "ngIf"], [1, "geometry-type-toggle"], [3, "disabled", "ngModel", "ngModelChange"], ["value", "Point", 3, "disabled"], ["value", "LineString", 3, "disabled"], ["value", "Polygon", 3, "disabled"], [1, "draw-guide-field"], ["matInput", "", "type", "number", 3, "placeholder", "ngModel", "ngModelChange"], ["matPrefix", "", "svgIcon", "adjust", 3, "color"], ["matSuffix", "", 1, "draw-guide-units"]], template: function GeometryFormFieldComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "igo-geometry-form-field-input", 0);
+        i0.ɵɵpipe(1, "async");
+        i0.ɵɵpipe(2, "async");
+        i0.ɵɵtemplate(3, GeometryFormFieldComponent_div_3_Template, 12, 16, "div", 1);
+        i0.ɵɵtemplate(4, GeometryFormFieldComponent_mat_form_field_4_Template, 6, 6, "mat-form-field", 2);
+    } if (rf & 2) {
+        i0.ɵɵproperty("formControl", ctx.formControl)("map", ctx.map)("geometryType", i0.ɵɵpipeBind1(1, 12, ctx.geometryType$))("drawGuide", i0.ɵɵpipeBind1(2, 14, ctx.drawGuide$))("measure", ctx.measure)("drawControlIsActive", ctx.drawControlIsActive)("freehandDrawIsActive", ctx.freehandDrawIsActive)("controlOptions", ctx.controlOptions)("drawStyle", ctx.drawStyle)("overlayStyle", ctx.overlayStyle);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", ctx.geometryTypeField);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.drawGuideField);
+    } }, dependencies: [i1.NgIf, i2.DefaultValueAccessor, i2.NumberValueAccessor, i2.NgControlStatus, i2.NgModel, i2.FormControlDirective, i3.MatIcon, i4.MatFormField, i4.MatPrefix, i4.MatSuffix, i5.MatInput, i6.MatButtonToggleGroup, i6.MatButtonToggle, i7.GeometryFormFieldInputComponent, i1.AsyncPipe, i8.TranslatePipe], styles: ["[_nghost-%COMP%]{display:block;width:100%}.geometry-type-toggle[_ngcontent-%COMP%], .draw-guide-field[_ngcontent-%COMP%]{width:100%}.geometry-type-toggle[_ngcontent-%COMP%]{padding:10px;text-align:center}.draw-guide-field[_ngcontent-%COMP%]   mat-icon[_ngcontent-%COMP%]{margin:0 10px}.draw-guide-units[_ngcontent-%COMP%]{padding:10px}"], changeDetection: 0 });
+GeometryFormFieldComponent = __decorate([
+    IgoFormFieldComponent('geometry')
+], GeometryFormFieldComponent);
+export { GeometryFormFieldComponent };
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GeometryFormFieldComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-geometry-form-field', changeDetection: ChangeDetectionStrategy.OnPush, template: "<igo-geometry-form-field-input\r\n  [formControl]=\"formControl\"\r\n  [map]=\"map\"\r\n  [geometryType]=\"geometryType$ | async\"\r\n  [drawGuide]=\"drawGuide$ | async\"\r\n  [measure]=\"measure\"\r\n  [drawControlIsActive]=\"drawControlIsActive\"\r\n  [freehandDrawIsActive]=\"freehandDrawIsActive\"\r\n  [controlOptions]=\"controlOptions\"\r\n  [drawStyle]=\"drawStyle\"\r\n  [overlayStyle]=\"overlayStyle\">\r\n</igo-geometry-form-field-input>\r\n\r\n<div *ngIf=\"geometryTypeField\" class=\"geometry-type-toggle\">\r\n  <mat-button-toggle-group\r\n    [disabled]=\"(value$ | async) !== undefined\"\r\n    [(ngModel)]=\"geometryType\">\r\n    <mat-button-toggle\r\n      value=\"Point\"\r\n      [disabled]=\"geometryTypes.indexOf('Point') < 0\">\r\n      {{'igo.geo.geometry.point' | translate}}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle\r\n      value=\"LineString\"\r\n      [disabled]=\"geometryTypes.indexOf('LineString') < 0\">\r\n      {{'igo.geo.geometry.line' | translate}}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle\r\n      value=\"Polygon\"\r\n      [disabled]=\"geometryTypes.indexOf('Polygon') < 0\">\r\n      {{'igo.geo.geometry.polygon' | translate}}\r\n    </mat-button-toggle>\r\n  </mat-button-toggle-group>\r\n</div>\r\n\r\n<mat-form-field *ngIf=\"drawGuideField\" class=\"draw-guide-field\">\r\n  <input\r\n    matInput\r\n    type=\"number\"\r\n    [placeholder]=\"drawGuidePlaceholder\"\r\n    [(ngModel)]=\"drawGuide\">\r\n  <mat-icon\r\n    matPrefix\r\n    [color]=\"'primary'\"\r\n    svgIcon=\"adjust\">    \r\n  </mat-icon>\r\n  <span matSuffix class=\"draw-guide-units\">{{'igo.geo.measure.meters' | translate}}</span>\r\n</mat-form-field>", styles: [":host{display:block;width:100%}.geometry-type-toggle,.draw-guide-field{width:100%}.geometry-type-toggle{padding:10px;text-align:center}.draw-guide-field mat-icon{margin:0 10px}.draw-guide-units{padding:10px}\n"] }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }]; }, { formControl: [{
+            type: Input
+        }], map: [{
+            type: Input
+        }], geometryType: [{
+            type: Input
+        }], geometryTypeField: [{
+            type: Input
+        }], geometryTypes: [{
+            type: Input
+        }], drawGuideField: [{
+            type: Input
+        }], drawGuide: [{
+            type: Input
+        }], drawGuidePlaceholder: [{
+            type: Input
+        }], measure: [{
+            type: Input
+        }], controlOptions: [{
+            type: Input
+        }], drawStyle: [{
+            type: Input
+        }], overlayStyle: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry-form-field.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/geometry/geometry-form-field/geometry-form-field.component.ts","../../../../../../packages/geo/src/lib/geometry/geometry-form-field/geometry-form-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef, Component,\r\n  Input, OnDestroy, OnInit\r\n} from '@angular/core';\r\nimport { UntypedFormControl } from '@angular/forms';\r\nimport { IgoFormFieldComponent } from '@igo2/common';\r\nimport type { default as OlGeometryType } from 'ol/geom/GeometryType';\r\nimport * as OlStyle from 'ol/style';\r\nimport { BehaviorSubject, Subscription } from 'rxjs';\r\nimport { IgoMap } from '../../map';\r\nimport { GeoJSONGeometry } from '../shared/geometry.interfaces';\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.\r\n */\r\n@IgoFormFieldComponent('geometry')\r\n@Component({\r\n  selector: 'igo-geometry-form-field',\r\n  templateUrl: './geometry-form-field.component.html',\r\n  styleUrls: ['./geometry-form-field.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class GeometryFormFieldComponent implements OnInit, OnDestroy {\r\n\r\n  readonly value$: BehaviorSubject<GeoJSONGeometry> = new BehaviorSubject(undefined);\r\n\r\n  private value$$: Subscription;\r\n\r\n  set drawControlIsActive(value: boolean) {\r\n    this._drawControlIsActive = value;\r\n    this.cdRef.detectChanges();\r\n  }\r\n\r\n  get drawControlIsActive(): boolean {\r\n    return this._drawControlIsActive;\r\n  }\r\n  private _drawControlIsActive = true;\r\n\r\n  set freehandDrawIsActive(value: boolean) {\r\n    this._freehandDrawIsActive = value;\r\n    this.cdRef.detectChanges();\r\n  }\r\n\r\n  get freehandDrawIsActive(): boolean {\r\n    return this._freehandDrawIsActive;\r\n  }\r\n  private _freehandDrawIsActive = false;\r\n\r\n  /**\r\n   * The field's form control\r\n   */\r\n  @Input() formControl: UntypedFormControl;\r\n\r\n  /**\r\n   * The map to draw the geometry on\r\n   */\r\n  @Input() map: IgoMap;\r\n\r\n  @Input()\r\n  set geometryType(value: typeof OlGeometryType) { this.geometryType$.next(value); }\r\n  get geometryType(): typeof OlGeometryType { return this.geometryType$.value; }\r\n  readonly geometryType$: BehaviorSubject<typeof OlGeometryType> = new BehaviorSubject(undefined);\r\n\r\n  /**\r\n   * Whether a geometry type toggle should be displayed\r\n   */\r\n  @Input() geometryTypeField: boolean = false;\r\n\r\n  /**\r\n   * Available geometry types\r\n   */\r\n  @Input() geometryTypes: string[] = ['Point', 'LineString', 'Polygon'];\r\n\r\n  /**\r\n   * Whether a draw guide field should be displayed\r\n   */\r\n  @Input() drawGuideField: boolean = false;\r\n\r\n  /**\r\n   * The drawGuide around the mouse pointer to help drawing\r\n   */\r\n  @Input()\r\n  set drawGuide(value: number) { this.drawGuide$.next(value); }\r\n  get drawGuide(): number { return this.drawGuide$.value; }\r\n  readonly drawGuide$: BehaviorSubject<number> = new BehaviorSubject(0);\r\n\r\n  /**\r\n   * Draw guide placeholder\r\n   */\r\n  @Input() drawGuidePlaceholder: string = '';\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   * 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() drawStyle: OlStyle.Style;\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() overlayStyle: OlStyle.Style;\r\n\r\n  constructor(private cdRef: ChangeDetectorRef) {}\r\n\r\n  /**\r\n   * Set up a value stream\r\n   * @internal\r\n   */\r\n  ngOnInit() {\r\n    this.value$.next(this.formControl.value ? this.formControl.value : undefined);\r\n    this.value$$ = this.formControl.valueChanges.subscribe((value: GeoJSONGeometry) => {\r\n      this.value$.next(value ? value : undefined);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to the value stream\r\n   * @internal\r\n   */\r\n  ngOnDestroy() {\r\n    this.value$$.unsubscribe();\r\n  }\r\n}\r\n","<igo-geometry-form-field-input\r\n  [formControl]=\"formControl\"\r\n  [map]=\"map\"\r\n  [geometryType]=\"geometryType$ | async\"\r\n  [drawGuide]=\"drawGuide$ | async\"\r\n  [measure]=\"measure\"\r\n  [drawControlIsActive]=\"drawControlIsActive\"\r\n  [freehandDrawIsActive]=\"freehandDrawIsActive\"\r\n  [controlOptions]=\"controlOptions\"\r\n  [drawStyle]=\"drawStyle\"\r\n  [overlayStyle]=\"overlayStyle\">\r\n</igo-geometry-form-field-input>\r\n\r\n<div *ngIf=\"geometryTypeField\" class=\"geometry-type-toggle\">\r\n  <mat-button-toggle-group\r\n    [disabled]=\"(value$ | async) !== undefined\"\r\n    [(ngModel)]=\"geometryType\">\r\n    <mat-button-toggle\r\n      value=\"Point\"\r\n      [disabled]=\"geometryTypes.indexOf('Point') < 0\">\r\n      {{'igo.geo.geometry.point' | translate}}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle\r\n      value=\"LineString\"\r\n      [disabled]=\"geometryTypes.indexOf('LineString') < 0\">\r\n      {{'igo.geo.geometry.line' | translate}}\r\n    </mat-button-toggle>\r\n    <mat-button-toggle\r\n      value=\"Polygon\"\r\n      [disabled]=\"geometryTypes.indexOf('Polygon') < 0\">\r\n      {{'igo.geo.geometry.polygon' | translate}}\r\n    </mat-button-toggle>\r\n  </mat-button-toggle-group>\r\n</div>\r\n\r\n<mat-form-field *ngIf=\"drawGuideField\" class=\"draw-guide-field\">\r\n  <input\r\n    matInput\r\n    type=\"number\"\r\n    [placeholder]=\"drawGuidePlaceholder\"\r\n    [(ngModel)]=\"drawGuide\">\r\n  <mat-icon\r\n    matPrefix\r\n    [color]=\"'primary'\"\r\n    svgIcon=\"adjust\">    \r\n  </mat-icon>\r\n  <span matSuffix class=\"draw-guide-units\">{{'igo.geo.measure.meters' | translate}}</span>\r\n</mat-form-field>"]}

package/esm2020/lib/geometry/geometry-form-field/geometry-form-field.module.mjs

@@ -0,0 +1,64 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { IgoLanguageModule } from '@igo2/core';
+import { GeometryFormFieldComponent } from './geometry-form-field.component';
+import { GeometryFormFieldInputComponent } from './geometry-form-field-input.component';
+import * as i0 from "@angular/core";
+/**
+ * @ignore
+ */
+export class IgoGeometryFormFieldModule {
+}
+IgoGeometryFormFieldModule.ɵfac = function IgoGeometryFormFieldModule_Factory(t) { return new (t || IgoGeometryFormFieldModule)(); };
+IgoGeometryFormFieldModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoGeometryFormFieldModule });
+IgoGeometryFormFieldModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatIconModule,
+        MatFormFieldModule,
+        MatInputModule,
+        MatButtonModule,
+        MatButtonToggleModule,
+        IgoLanguageModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGeometryFormFieldModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    MatIconModule,
+                    MatFormFieldModule,
+                    MatInputModule,
+                    MatButtonModule,
+                    MatButtonToggleModule,
+                    IgoLanguageModule
+                ],
+                exports: [
+                    GeometryFormFieldComponent,
+                    GeometryFormFieldInputComponent
+                ],
+                declarations: [
+                    GeometryFormFieldComponent,
+                    GeometryFormFieldInputComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoGeometryFormFieldModule, { declarations: [GeometryFormFieldComponent,
+        GeometryFormFieldInputComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatIconModule,
+        MatFormFieldModule,
+        MatInputModule,
+        MatButtonModule,
+        MatButtonToggleModule,
+        IgoLanguageModule], exports: [GeometryFormFieldComponent,
+        GeometryFormFieldInputComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/geometry/geometry.module.mjs

@@ -0,0 +1,27 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IgoGeometryFormFieldModule } from './geometry-form-field/geometry-form-field.module';
+import * as i0 from "@angular/core";
+export class IgoGeometryModule {
+}
+IgoGeometryModule.ɵfac = function IgoGeometryModule_Factory(t) { return new (t || IgoGeometryModule)(); };
+IgoGeometryModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoGeometryModule });
+IgoGeometryModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        IgoGeometryFormFieldModule, IgoGeometryFormFieldModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGeometryModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    IgoGeometryFormFieldModule
+                ],
+                exports: [
+                    IgoGeometryFormFieldModule
+                ],
+                declarations: [],
+                providers: []
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoGeometryModule, { imports: [CommonModule,
+        IgoGeometryFormFieldModule], exports: [IgoGeometryFormFieldModule] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvbWV0cnkubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvZ2VvbWV0cnkvZ2VvbWV0cnkubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRS9DLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGtEQUFrRCxDQUFDOztBQWE5RixNQUFNLE9BQU8saUJBQWlCOztrRkFBakIsaUJBQWlCO21FQUFqQixpQkFBaUI7dUVBVDFCLFlBQVk7UUFDWiwwQkFBMEIsRUFHMUIsMEJBQTBCO3VGQUtqQixpQkFBaUI7Y0FYN0IsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLDBCQUEwQjtpQkFDM0I7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLDBCQUEwQjtpQkFDM0I7Z0JBQ0QsWUFBWSxFQUFFLEVBQUU7Z0JBQ2hCLFNBQVMsRUFBRSxFQUFFO2FBQ2Q7O3dGQUNZLGlCQUFpQixjQVQxQixZQUFZO1FBQ1osMEJBQTBCLGFBRzFCLDBCQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcblxyXG5pbXBvcnQgeyBJZ29HZW9tZXRyeUZvcm1GaWVsZE1vZHVsZSB9IGZyb20gJy4vZ2VvbWV0cnktZm9ybS1maWVsZC9nZW9tZXRyeS1mb3JtLWZpZWxkLm1vZHVsZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtcclxuICAgIENvbW1vbk1vZHVsZSxcclxuICAgIElnb0dlb21ldHJ5Rm9ybUZpZWxkTW9kdWxlXHJcbiAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBJZ29HZW9tZXRyeUZvcm1GaWVsZE1vZHVsZVxyXG4gIF0sXHJcbiAgZGVjbGFyYXRpb25zOiBbXSxcclxuICBwcm92aWRlcnM6IFtdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBJZ29HZW9tZXRyeU1vZHVsZSB7fVxyXG4iXX0=

package/esm2020/lib/geometry/index.mjs

@@ -0,0 +1,4 @@
+export * from './shared';
+export * from './geometry-form-field/geometry-form-field.component';
+export * from './geometry-form-field/geometry-form-field-input.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9nZW9tZXRyeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLHFEQUFxRCxDQUFDO0FBQ3BFLGNBQWMsMkRBQTJELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NoYXJlZCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZ2VvbWV0cnktZm9ybS1maWVsZC9nZW9tZXRyeS1mb3JtLWZpZWxkLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZ2VvbWV0cnktZm9ybS1maWVsZC9nZW9tZXRyeS1mb3JtLWZpZWxkLWlucHV0LmNvbXBvbmVudCc7XHJcbiJdfQ==

package/esm2020/lib/geometry/shared/controls/draw.mjs

@@ -0,0 +1,271 @@
+import OlVectorSource from 'ol/source/Vector';
+import OlVectorLayer from 'ol/layer/Vector';
+import OlDraw from 'ol/interaction/Draw';
+import OlModify from 'ol/interaction/Modify';
+import OlSelect from 'ol/interaction/Select';
+import { unByKey } from 'ol/Observable';
+import { doubleClick } from 'ol/events/condition';
+import { Subject, fromEvent, BehaviorSubject } from 'rxjs';
+import { getMousePositionFromOlGeometryEvent } from '../geometry.utils';
+/**
+ * Control to draw entities
+ */
+export class DrawControl {
+    constructor(options) {
+        this.options = options;
+        /**
+         * Draw start observable
+         */
+        this.start$ = new Subject();
+        /**
+         * Draw end observable
+         */
+        this.end$ = new Subject();
+        /**
+         * Draw changes observable (while drawing)
+         */
+        this.changes$ = new Subject();
+        /**
+         * Draw modify observable (modify drawn features)
+         */
+        this.modify$ = new Subject();
+        /**
+         * Draw select observable (modify drawn features)
+         */
+        this.select$ = new Subject();
+        /**
+         * Draw abort observable (abort drawn features)
+         */
+        this.abort$ = new Subject();
+        /**
+         * Freehand mode observable (defaults to false)
+         */
+        this.freehand$ = new BehaviorSubject(false);
+        this.olDrawingLayer = options.drawingLayer ? options.drawingLayer : this.createOlInnerOverlayLayer();
+        this.olGeometryType = this.options.geometryType;
+    }
+    /**
+     * Wheter the control is active
+     */
+    get active() {
+        return this.olMap !== undefined;
+    }
+    /**
+     * OL overlay source
+     * @internal
+     */
+    get olDrawingLayerSource() {
+        return this.olDrawingLayer.getSource();
+    }
+    /**
+     * Add or remove this control to/from a map.
+     * @param map OL Map
+     */
+    setOlMap(olMap, activateModifyAndSelect) {
+        if (!olMap) {
+            this.clearOlInnerOverlaySource();
+            this.removeOlInnerOverlayLayer();
+            this.removeOlInteractions();
+            this.olMap = olMap;
+            return;
+        }
+        this.olMap = olMap;
+        this.addOlInnerOverlayLayer();
+        this.addOlInteractions(activateModifyAndSelect);
+    }
+    /**
+     * Return the drawing layer source
+     */
+    getSource() {
+        return this.olDrawingLayerSource;
+    }
+    /**
+     * Set the current geometry type
+     * @param geometryType the geometry type
+     */
+    setGeometryType(geometryType) {
+        this.olGeometryType = geometryType;
+    }
+    /**
+     * Create a drawing source if none is defined in the options
+     */
+    createOlInnerOverlayLayer() {
+        return new OlVectorLayer({
+            source: this.options.drawingLayerSource ? this.options.drawingLayerSource : new OlVectorSource(),
+            style: this.options.drawingLayerStyle,
+            zIndex: 500
+        });
+    }
+    /**
+     * Clear the drawing layer if it wasn't defined in the options
+     */
+    removeOlInnerOverlayLayer() {
+        if (!this.options.drawingLayer && this.olMap) {
+            this.olMap.removeLayer(this.olDrawingLayer);
+        }
+    }
+    /**
+     * Add the drawing layer if it wasn't defined in the options
+     */
+    addOlInnerOverlayLayer() {
+        if (!this.options.drawingLayer) {
+            this.olMap.addLayer(this.olDrawingLayer);
+        }
+    }
+    /**
+     * Clear the drawing layer source if it wasn't defined in the options
+     */
+    clearOlInnerOverlaySource() {
+        if (!this.options.drawingLayer && !this.options.drawingLayerSource) {
+            this.olDrawingLayerSource.clear(true);
+        }
+    }
+    /**
+     * Add interactions to the map an set up some listeners
+     */
+    addOlInteractions(activateModifyAndSelect) {
+        // Create Draw interaction
+        let olDrawInteraction;
+        if (!this.freehand$.getValue()) {
+            olDrawInteraction = new OlDraw({
+                type: this.olGeometryType,
+                source: this.getSource(),
+                stopClick: true,
+                style: this.options.interactionStyle,
+                maxPoints: this.options.maxPoints,
+                freehand: false,
+                freehandCondition: () => false
+            });
+        }
+        else {
+            if (this.olGeometryType === 'Point') {
+                olDrawInteraction = new OlDraw({
+                    type: 'Circle',
+                    source: this.getSource(),
+                    maxPoints: this.options.maxPoints,
+                    freehand: true
+                });
+            }
+            else {
+                olDrawInteraction = new OlDraw({
+                    type: this.olGeometryType,
+                    source: this.getSource(),
+                    maxPoints: this.options.maxPoints,
+                    freehand: true
+                });
+            }
+        }
+        // Add Draw interaction to map and create listeners
+        this.olMap.addInteraction(olDrawInteraction);
+        this.olDrawInteraction = olDrawInteraction;
+        this.onDrawStartKey = olDrawInteraction.on('drawstart', (event) => this.onDrawStart(event));
+        this.onDrawEndKey = olDrawInteraction.on('drawend', (event) => this.onDrawEnd(event));
+        this.onDrawAbortKey = olDrawInteraction.on('drawabort', (event) => this.abort$.next(event.feature.getGeometry()));
+        if (activateModifyAndSelect) {
+            // Create a Modify interaction, add it to map and create a listener
+            const olModifyInteraction = new OlModify({
+                source: this.getSource()
+            });
+            this.olMap.addInteraction(olModifyInteraction);
+            this.olModifyInteraction = olModifyInteraction;
+            // Create a select interaction and add it to map
+            if (!this.olSelectInteraction) {
+                const olSelectInteraction = new OlSelect({
+                    condition: doubleClick,
+                    style: undefined
+                });
+                this.olMap.addInteraction(olSelectInteraction);
+                this.olSelectInteraction = olSelectInteraction;
+                this.olSelectInteraction.on('select', (event) => this.onSelect(event));
+            }
+        }
+    }
+    /**
+     * Remove interactions
+     */
+    removeOlInteractions() {
+        this.unsubscribeKeyDown();
+        unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey, this.onDrawAbortKey]);
+        if (this.olMap) {
+            this.olMap.removeInteraction(this.olDrawInteraction);
+            this.olMap.removeInteraction(this.olModifyInteraction);
+        }
+        this.olDrawInteraction = undefined;
+        this.olModifyInteraction = undefined;
+    }
+    /**
+     * When drawing starts, clear the overlay and start watching for changes
+     * @param event Draw start event
+     */
+    onDrawStart(event) {
+        const olGeometry = event.feature.getGeometry();
+        this.start$.next(olGeometry);
+        this.clearOlInnerOverlaySource();
+        this.onDrawKey = olGeometry.on('change', (olGeometryEvent) => {
+            this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);
+            this.changes$.next(olGeometryEvent.target);
+        });
+        this.subscribeKeyDown();
+    }
+    /**
+     * When drawing ends, update the drawing (feature) geometry observable and add
+     * @param event Draw event (drawend)
+     */
+    onDrawEnd(event) {
+        this.unsubscribeKeyDown();
+        unByKey(this.onDrawKey);
+        const olGeometry = event.feature.getGeometry();
+        olGeometry.on('change', () => {
+            this.modify$.next(olGeometry);
+        });
+        this.end$.next(olGeometry);
+    }
+    /**
+     * When a feature is selected, update the selected feature observable
+     * @param event Modify event (modifyend)
+     */
+    onSelect(event) {
+        if (event.selected.length === 1) {
+            this.select$.next(event.selected[0]);
+        }
+    }
+    /**
+     * Subscribe to key downs used as drawing interaction shorcuts
+     */
+    subscribeKeyDown() {
+        this.unsubscribeKeyDown();
+        this.keyDown$$ = fromEvent(document, 'keydown').subscribe((event) => {
+            // On Escape or 'c' keydowns, abort the current drawing
+            if (event.key === 'Escape') {
+                this.olDrawInteraction.abortDrawing();
+                return;
+            }
+            // On Backspace or 'u' keydowns, remove last vertex of current drawing
+            if (event.key === 'Backspace') {
+                this.olDrawInteraction.removeLastPoint();
+            }
+            // On Enter or 'f' keydowns, finish current drawing
+            if (event.key === 'Enter') {
+                this.olDrawInteraction.finishDrawing();
+            }
+            // On space bar key down, pan to the current mouse position
+            if (event.key === ' ') {
+                this.olMap.getView().animate({
+                    center: this.mousePosition,
+                    duration: 100
+                });
+                return;
+            }
+        });
+    }
+    /**
+     * Unsubscribe to key down
+     */
+    unsubscribeKeyDown() {
+        if (this.keyDown$$) {
+            this.keyDown$$.unsubscribe();
+            this.keyDown$$ = undefined;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draw.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/geometry/shared/controls/draw.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventsKey } from 'ol/events';\r\nimport OlMap from 'ol/Map';\r\nimport { StyleLike as OlStyleLike } from 'ol/style/Style';\r\nimport type { default as OlGeometryType } from 'ol/geom/GeometryType';\r\nimport OlVectorSource from 'ol/source/Vector';\r\nimport OlVectorLayer from 'ol/layer/Vector';\r\nimport OlDraw from 'ol/interaction/Draw';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport OlModify from 'ol/interaction/Modify';\r\nimport OlSelect from 'ol/interaction/Select';\r\nimport BasicEvent from 'ol/events/Event';\r\nimport { DrawEvent as OlDrawEvent } from 'ol/interaction/Draw';\r\nimport { SelectEvent as OlSelectEvent } from 'ol/interaction/Select';\r\nimport { unByKey } from 'ol/Observable';\r\nimport { doubleClick } from 'ol/events/condition';\r\n\r\nimport { Subject, Subscription, fromEvent, BehaviorSubject } from 'rxjs';\r\n\r\nimport { getMousePositionFromOlGeometryEvent } from '../geometry.utils';\r\n\r\nexport interface DrawControlOptions {\r\n  geometryType: typeof OlGeometryType | string;\r\n  drawingLayerSource?: OlVectorSource<OlGeometry>;\r\n  drawingLayer?: OlVectorLayer<OlVectorSource<OlGeometry>>;\r\n  drawingLayerStyle?: OlStyleLike;\r\n  interactionStyle?: OlStyleLike;\r\n  maxPoints?: number;\r\n}\r\n\r\n/**\r\n * Control to draw entities\r\n */\r\nexport class DrawControl {\r\n  /**\r\n   * Draw start observable\r\n   */\r\n  public start$: Subject<OlGeometry> = new Subject();\r\n\r\n  /**\r\n   * Draw end observable\r\n   */\r\n  public end$: Subject<OlGeometry> = new Subject();\r\n\r\n  /**\r\n   * Draw changes observable (while drawing)\r\n   */\r\n  public changes$: Subject<any> = new Subject();\r\n\r\n  /**\r\n   * Draw modify observable (modify drawn features)\r\n   */\r\n  public modify$: Subject<OlGeometry> = new Subject();\r\n\r\n  /**\r\n   * Draw select observable (modify drawn features)\r\n   */\r\n  public select$: Subject<any> = new Subject();\r\n\r\n  /**\r\n   * Draw abort observable (abort drawn features)\r\n   */\r\n     public abort$: Subject<any> = new Subject();\r\n\r\n  /**\r\n   * Freehand mode observable (defaults to false)\r\n   */\r\n  freehand$: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n\r\n  private keyDown$$: Subscription;\r\n\r\n  private olGeometryType: typeof OlGeometryType | undefined | string;\r\n  private olMap: OlMap;\r\n  private olDrawingLayer: OlVectorLayer<OlVectorSource<OlGeometry>>;\r\n  private olDrawInteraction: OlDraw;\r\n  private olSelectInteraction: OlSelect;\r\n  private olModifyInteraction: OlModify;\r\n  private onDrawStartKey: EventsKey;\r\n  private onDrawEndKey: EventsKey;\r\n  private onDrawAbortKey: EventsKey;\r\n  private onDrawKey: EventsKey;\r\n\r\n  private mousePosition: [number, number];\r\n\r\n  /**\r\n   * Wheter the control is active\r\n   */\r\n  get active(): boolean {\r\n    return this.olMap !== undefined;\r\n  }\r\n\r\n  /**\r\n   * OL overlay source\r\n   * @internal\r\n   */\r\n  get olDrawingLayerSource(): OlVectorSource<OlGeometry> {\r\n    return this.olDrawingLayer.getSource();\r\n  }\r\n\r\n  constructor(private options: DrawControlOptions) {\r\n    this.olDrawingLayer = options.drawingLayer ? options.drawingLayer : this.createOlInnerOverlayLayer();\r\n    this.olGeometryType = this.options.geometryType;\r\n  }\r\n\r\n  /**\r\n   * Add or remove this control to/from a map.\r\n   * @param map OL Map\r\n   */\r\n  setOlMap(olMap: OlMap | undefined, activateModifyAndSelect?: boolean) {\r\n    if (!olMap) {\r\n      this.clearOlInnerOverlaySource();\r\n      this.removeOlInnerOverlayLayer();\r\n      this.removeOlInteractions();\r\n      this.olMap = olMap;\r\n      return;\r\n    }\r\n\r\n    this.olMap = olMap;\r\n    this.addOlInnerOverlayLayer();\r\n    this.addOlInteractions(activateModifyAndSelect);\r\n  }\r\n\r\n  /**\r\n   * Return the drawing layer source\r\n   */\r\n  getSource(): OlVectorSource<OlGeometry> {\r\n    return this.olDrawingLayerSource;\r\n  }\r\n\r\n  /**\r\n   * Set the current geometry type\r\n   * @param geometryType the geometry type\r\n   */\r\n  setGeometryType(geometryType: typeof OlGeometryType) {\r\n    this.olGeometryType = geometryType;\r\n  }\r\n\r\n  /**\r\n   * Create a drawing source if none is defined in the options\r\n   */\r\n  private createOlInnerOverlayLayer(): OlVectorLayer<OlVectorSource<OlGeometry>> {\r\n    return new OlVectorLayer({\r\n      source: this.options.drawingLayerSource ? this.options.drawingLayerSource : new OlVectorSource(),\r\n      style: this.options.drawingLayerStyle,\r\n      zIndex: 500\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Clear the drawing layer if it wasn't defined in the options\r\n   */\r\n  private removeOlInnerOverlayLayer() {\r\n    if (!this.options.drawingLayer && this.olMap) {\r\n      this.olMap.removeLayer(this.olDrawingLayer);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add the drawing layer if it wasn't defined in the options\r\n   */\r\n  private addOlInnerOverlayLayer() {\r\n    if (!this.options.drawingLayer) {\r\n      this.olMap.addLayer(this.olDrawingLayer);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear the drawing layer source if it wasn't defined in the options\r\n   */\r\n  private clearOlInnerOverlaySource() {\r\n    if (!this.options.drawingLayer && !this.options.drawingLayerSource) {\r\n      this.olDrawingLayerSource.clear(true);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Add interactions to the map an set up some listeners\r\n   */\r\n  addOlInteractions(activateModifyAndSelect?: boolean) {\r\n    // Create Draw interaction\r\n    let olDrawInteraction;\r\n    if (!this.freehand$.getValue()) {\r\n      olDrawInteraction = new OlDraw({\r\n        type: this.olGeometryType,\r\n        source: this.getSource(),\r\n        stopClick: true,\r\n        style: this.options.interactionStyle,\r\n        maxPoints: this.options.maxPoints,\r\n        freehand: false,\r\n        freehandCondition: () => false\r\n      });\r\n\r\n    } else {\r\n      if (this.olGeometryType === 'Point') {\r\n        olDrawInteraction = new OlDraw({\r\n          type: 'Circle',\r\n          source: this.getSource(),\r\n          maxPoints: this.options.maxPoints,\r\n          freehand: true\r\n        });\r\n\r\n      } else {\r\n        olDrawInteraction = new OlDraw({\r\n          type: this.olGeometryType,\r\n          source: this.getSource(),\r\n          maxPoints: this.options.maxPoints,\r\n          freehand: true\r\n        });\r\n      }\r\n    }\r\n\r\n    // Add Draw interaction to map and create listeners\r\n    this.olMap.addInteraction(olDrawInteraction);\r\n    this.olDrawInteraction = olDrawInteraction;\r\n\r\n    this.onDrawStartKey = olDrawInteraction.on('drawstart', (event: OlDrawEvent) => this.onDrawStart(event));\r\n    this.onDrawEndKey = olDrawInteraction.on('drawend', (event: OlDrawEvent) => this.onDrawEnd(event));\r\n    this.onDrawAbortKey = olDrawInteraction.on('drawabort', (event: OlDrawEvent) => this.abort$.next(event.feature.getGeometry()));\r\n\r\n    if (activateModifyAndSelect) {\r\n      // Create a Modify interaction, add it to map and create a listener\r\n      const olModifyInteraction = new OlModify({\r\n        source: this.getSource()\r\n      });\r\n\r\n      this.olMap.addInteraction(olModifyInteraction);\r\n      this.olModifyInteraction = olModifyInteraction;\r\n\r\n      // Create a select interaction and add it to map\r\n      if (!this.olSelectInteraction) {\r\n        const olSelectInteraction = new OlSelect({\r\n          condition: doubleClick,\r\n          style: undefined\r\n        });\r\n        this.olMap.addInteraction(olSelectInteraction);\r\n        this.olSelectInteraction = olSelectInteraction;\r\n\r\n        this.olSelectInteraction.on('select', (event: OlSelectEvent) => this.onSelect(event));\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove interactions\r\n   */\r\n  private removeOlInteractions() {\r\n    this.unsubscribeKeyDown();\r\n    unByKey([this.onDrawStartKey, this.onDrawEndKey, this.onDrawKey, this.onDrawAbortKey]);\r\n\r\n    if (this.olMap) {\r\n      this.olMap.removeInteraction(this.olDrawInteraction);\r\n      this.olMap.removeInteraction(this.olModifyInteraction);\r\n    }\r\n\r\n    this.olDrawInteraction = undefined;\r\n    this.olModifyInteraction = undefined;\r\n  }\r\n\r\n  /**\r\n   * When drawing starts, clear the overlay and start watching for changes\r\n   * @param event Draw start event\r\n   */\r\n  private onDrawStart(event: OlDrawEvent) {\r\n    const olGeometry = event.feature.getGeometry();\r\n    this.start$.next(olGeometry);\r\n    this.clearOlInnerOverlaySource();\r\n    this.onDrawKey = olGeometry.on('change', (olGeometryEvent: BasicEvent) => {\r\n      this.mousePosition = getMousePositionFromOlGeometryEvent(olGeometryEvent);\r\n      this.changes$.next(olGeometryEvent.target);\r\n    });\r\n    this.subscribeKeyDown();\r\n  }\r\n\r\n  /**\r\n   * When drawing ends, update the drawing (feature) geometry observable and add\r\n   * @param event Draw event (drawend)\r\n   */\r\n  private onDrawEnd(event: OlDrawEvent) {\r\n    this.unsubscribeKeyDown();\r\n    unByKey(this.onDrawKey);\r\n    const olGeometry = event.feature.getGeometry();\r\n    olGeometry.on('change', () => {\r\n      this.modify$.next(olGeometry);\r\n    });\r\n    this.end$.next(olGeometry);\r\n  }\r\n\r\n  /**\r\n   * When a feature is selected, update the selected feature observable\r\n   * @param event Modify event (modifyend)\r\n   */\r\n  private onSelect(event: OlSelectEvent) {\r\n    if (event.selected.length === 1) {\r\n      this.select$.next(event.selected[0]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Subscribe to key downs used as drawing interaction shorcuts\r\n   */\r\n  private subscribeKeyDown() {\r\n    this.unsubscribeKeyDown();\r\n    this.keyDown$$ = fromEvent(document, 'keydown').subscribe((event: KeyboardEvent) => {\r\n      // On Escape or 'c' keydowns, abort the current drawing\r\n      if (event.key === 'Escape') {\r\n        this.olDrawInteraction.abortDrawing();\r\n        return;\r\n      }\r\n\r\n      // On Backspace or 'u' keydowns, remove last vertex of current drawing\r\n      if (event.key === 'Backspace') {\r\n        this.olDrawInteraction.removeLastPoint();\r\n      }\r\n\r\n      // On Enter or 'f' keydowns, finish current drawing\r\n      if (event.key === 'Enter') {\r\n        this.olDrawInteraction.finishDrawing();\r\n      }\r\n\r\n      // On space bar key down, pan to the current mouse position\r\n      if (event.key === ' ') {\r\n        this.olMap.getView().animate({\r\n          center: this.mousePosition,\r\n          duration: 100\r\n        });\r\n        return;\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Unsubscribe to key down\r\n   */\r\n  private unsubscribeKeyDown() {\r\n    if (this.keyDown$$) {\r\n      this.keyDown$$.unsubscribe();\r\n      this.keyDown$$ = undefined;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/geometry/shared/controls/index.mjs

@@ -0,0 +1,4 @@
+export * from './draw';
+export * from './modify';
+export * from './slice';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9nZW9tZXRyeS9zaGFyZWQvY29udHJvbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYXcnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGlmeSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2xpY2UnO1xyXG4iXX0=