@artstesh/maps 4.0.10 → 4.1.0

package/dist/fesm2020/maps-components.mjs

@@ -2,23 +2,24 @@ import * as i0 from '@angular/core';
 import { Component, Injectable, ChangeDetectionStrategy, Input, ViewChild, NgModule } from '@angular/core';
 import * as i4 from '@angular/common';
 import { CommonModule } from '@angular/common';
-import { Feature } from 'ol';
+import { Feature, Collection } from 'ol';
 import { Point, LineString } from 'ol/geom';
 import { GeoJSON, WKT } from 'ol/format';
 import { getCenter, createEmpty, extend } from 'ol/extent';
 import { get, useGeographic, transform } from 'ol/proj';
-import { PostboyGenericMessage, PostboyCallbackMessage, PostboyService, PostboyAbstractRegistrator } from '@artstesh/postboy';
-import { forkJoin, combineLatest } from 'rxjs';
-import { tap, first, filter, auditTime } from 'rxjs/operators';
-import { Vector, XYZ } from 'ol/source';
-import { Draw } from 'ol/interaction';
+import { PostboyGenericMessage, PostboyCallbackMessage, PostboyExecutor, PostboyService, PostboyAbstractRegistrator } from '@artstesh/postboy';
+import { Draw, Modify, Translate } from 'ol/interaction';
 import { createRegularPolygon } from 'ol/interaction/Draw';
+import { Zoom } from 'ol/control';
+import { first, filter, auditTime } from 'rxjs/operators';
+import { Vector, XYZ } from 'ol/source';
 import TileLayer from 'ol/layer/Tile';
 import OSM from 'ol/source/OSM';
 import { Vector as Vector$1 } from 'ol/layer';
 import { bbox } from 'ol/loadingstrategy';
 import Polygon, { fromExtent } from 'ol/geom/Polygon';
 import Cluster from 'ol/source/Cluster';
+import { combineLatest } from 'rxjs';
 import Map from 'ol/Map';
 import View from 'ol/View';
 import Overlay from 'ol/Overlay';
@@ -179,6 +180,7 @@ var DrawingType;
 (function (DrawingType) {
     DrawingType[DrawingType["Polygon"] = 1] = "Polygon";
     DrawingType[DrawingType["Circle"] = 2] = "Circle";
+    DrawingType[DrawingType["Square"] = 3] = "Square";
 })(DrawingType || (DrawingType = {}));
 
 var FeatureOutputFormat;
@@ -323,6 +325,26 @@ class DrawSelectionAreaCommand extends PostboyCallbackMessage {
 }
 DrawSelectionAreaCommand.ID = '573d8a0d-f25b-42b7-9ad7-0ac6d86ac362';
 
+class ModifyFeatureCommand extends PostboyCallbackMessage {
+    constructor(model, style, format = FeatureOutputFormat.GeoJson) {
+        super();
+        this.model = model;
+        this.style = style;
+        this.format = format;
+    }
+    get id() {
+        return ModifyFeatureCommand.ID;
+    }
+}
+ModifyFeatureCommand.ID = 'ead85caa-24c6-4844-a68c-2cea91774c8c';
+
+class CancelFeatureModificationCommand extends PostboyGenericMessage {
+    get id() {
+        return CancelFeatureModificationCommand.ID;
+    }
+}
+CancelFeatureModificationCommand.ID = '9c9fb40f-ea95-4704-8177-0e9ecabf36fa';
+
 class AddLayerCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
@@ -412,42 +434,101 @@ class DrawingFinishedEvent extends PostboyGenericMessage {
 }
 DrawingFinishedEvent.ID = 'c724b68e-b4eb-4783-90f1-a8e31973fd36';
 
-class GenerateDrawQuery extends PostboyCallbackMessage {
-    constructor(layer, style, type) {
+class DrawingGenerationService {
+    static getDraw(ev) {
+        return new Draw({
+            source: ev.layer.getSource(),
+            type: ev.type === DrawingType.Polygon ? 'Polygon' : 'Circle',
+            style: ev.style,
+            geometryFunction: DrawingGenerationService.geometryFunc(ev.type),
+        });
+    }
+    static geometryFunc(type) {
+        switch (type) {
+            case DrawingType.Circle:
+                return createRegularPolygon(32);
+            case DrawingType.Square:
+                return createRegularPolygon(4);
+        }
+        return undefined;
+    }
+}
+
+class FeatureService {
+    constructor() { }
+    static filterFeaturesInArea(query) {
+        return query.features.filter((f) => FeatureService.booleanIntersects(query.area, f.getGeometry()));
+    }
+    static booleanIntersects(g1, g2) {
+        if (g2.getType() === 'Point')
+            return g1.intersectsCoordinate(g2.getCoordinates());
+        if (g2.getType() === 'Circle')
+            return g1.intersectsCoordinate(g2.getCenter());
+        if (g2.getType() === 'Polygon')
+            return g1.intersectsCoordinate(g2.getInteriorPoint().getCoordinates());
+        return false;
+    }
+}
+
+class GetFeaturesInAreaQuery extends PostboyCallbackMessage {
+    constructor(area, ignore = new Set()) {
         super();
-        this.layer = layer;
-        this.style = style;
-        this.type = type;
+        this.area = area;
+        this.ignore = ignore;
     }
     get id() {
-        return GenerateDrawQuery.ID;
+        return GetFeaturesInAreaQuery.ID;
     }
 }
-GenerateDrawQuery.ID = 'f01c99ba-0953-4ab5-82f9-04e6fbb678c1';
+GetFeaturesInAreaQuery.ID = 'efcf4271-a07a-40e0-9f02-d4dade40b8ac';
 
-class FilterFeaturesInAreaQuery extends PostboyCallbackMessage {
+class FilterFeaturesInAreaExecutor extends PostboyExecutor {
     constructor(area, features) {
         super();
         this.area = area;
         this.features = features;
     }
     get id() {
-        return FilterFeaturesInAreaQuery.ID;
+        return FilterFeaturesInAreaExecutor.ID;
     }
 }
-FilterFeaturesInAreaQuery.ID = '36bb2d94-8028-4512-90dd-2386af3fc67c';
+FilterFeaturesInAreaExecutor.ID = '36bb2d94-8028-4512-90dd-2386af3fc67c';
 
-class GetFeaturesInAreaQuery extends PostboyCallbackMessage {
-    constructor(area, ignore = new Set()) {
+class GenerateDrawExecutor extends PostboyExecutor {
+    constructor(layer, style, type) {
         super();
-        this.area = area;
-        this.ignore = ignore;
+        this.layer = layer;
+        this.style = style;
+        this.type = type;
     }
     get id() {
-        return GetFeaturesInAreaQuery.ID;
+        return GenerateDrawExecutor.ID;
     }
 }
-GetFeaturesInAreaQuery.ID = 'efcf4271-a07a-40e0-9f02-d4dade40b8ac';
+GenerateDrawExecutor.ID = 'f01c99ba-0953-4ab5-82f9-04e6fbb678c1';
+
+class GenerateZoomControlExecutor extends PostboyExecutor {
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    get id() {
+        return GenerateZoomControlExecutor.ID;
+    }
+}
+GenerateZoomControlExecutor.ID = 'ff16a833-c68e-4b1a-bc23-c0d16b002810';
+
+class ZoomControlFactory {
+    static build(settings) {
+        return new Zoom({
+            zoomInTipLabel: settings.zoomInLabel,
+            zoomOutTipLabel: settings.zoomOutLabel,
+            zoomInClassName: settings.zoomInClass,
+            zoomOutClassName: settings.zoomOutClass,
+            className: settings.controlClass,
+        });
+    }
+}
 
 class MapPostboyService extends PostboyService {
     constructor() {
@@ -528,8 +609,6 @@ class MapManagementService {
     observeFeaturesInArea() {
         this.postboy.subscribe(GetFeaturesInAreaQuery.ID).subscribe((qr) => {
             let result = new Dictionary();
-            const queue = [];
-            const queries = [];
             this.layers.forEach((l) => {
                 let layerName = l.get('name');
                 if (qr.ignore.has(layerName) || layerName === MapConstants.DrawingLayerId)
@@ -537,14 +616,10 @@ class MapManagementService {
                 let source = l.getSource();
                 if (!!source['getSource'])
                     source = source?.getSource();
-                const query = new FilterFeaturesInAreaQuery(qr.area, source?.getFeatures() ?? []);
-                queue.push(query.result.pipe(tap((r) => {
-                    result.put(l.get('name'), r.map((e) => ({ id: e.getId(), ...e.get(MapConstants.FeatureInfo) })));
-                })));
-                queries.push(query);
+                let features = this.postboy.execute(new FilterFeaturesInAreaExecutor(qr.area, source?.getFeatures() ?? []));
+                result.put(layerName, features.map((e) => ({ id: e.getId(), ...e.get(MapConstants.FeatureInfo) })));
             });
-            forkJoin(queue).subscribe(() => qr.finish(result));
-            queries.forEach((q) => this.postboy.fire(q));
+            qr.finish(result);
         });
     }
 }
@@ -687,17 +762,13 @@ class DrawingService {
                     this.clearInteraction(l);
                     return;
                 }
-                const drawQuery = new GenerateDrawQuery(l, ev.style, ev.type);
-                drawQuery.result.subscribe((draw) => {
-                    const cancelSub = this.observeCancelation(ev, l);
-                    this.drawInteraction = draw;
-                    this.map?.addInteraction(this.drawInteraction);
-                    this.drawInteraction.on('drawend', (evt) => {
-                        cancelSub.unsubscribe();
-                        this.onEnd(evt, ev, l);
-                    });
+                const cancelSub = this.observeCancelation(ev, l);
+                this.drawInteraction = this.postboy.execute(new GenerateDrawExecutor(l, ev.style, ev.type));
+                this.map?.addInteraction(this.drawInteraction);
+                this.drawInteraction.on('drawend', (evt) => {
+                    cancelSub.unsubscribe();
+                    this.onEnd(evt, ev, l);
                 });
-                this.postboy.fire(drawQuery);
             });
         });
     }
@@ -740,56 +811,96 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
-class DrawingGenerationService {
+class FeatureModificationService {
     constructor(postboy) {
         this.postboy = postboy;
     }
     up() {
-        this.postboy.subscribe(GenerateDrawQuery.ID).subscribe((ev) => {
-            ev.finish(new Draw({
-                source: ev.layer.getSource(),
-                type: DrawingType[ev.type],
-                style: ev.style,
-                geometryFunction: ev.type !== DrawingType.Circle ? undefined : createRegularPolygon(32),
-            }));
+        this.observeModification();
+        this.observeMapRender();
+    }
+    observeModification() {
+        this.postboy.subscribe(ModifyFeatureCommand.ID).subscribe((ev) => {
+            this.defineLayer((l) => {
+                if (!l || !this.map) {
+                    this.clearInteraction(l);
+                    return;
+                }
+                this.observeCancelation(ev, l);
+                this.initFeature(l, ev.model.feature);
+                this.addModify(ev);
+                this.addDragging(ev);
+            });
         });
     }
-}
-DrawingGenerationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DrawingGenerationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
-DrawingGenerationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DrawingGenerationService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DrawingGenerationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
-
-class FeatureService {
-    constructor(postboy) {
-        this.postboy = postboy;
+    initFeature(layer, feature) {
+        layer.getSource()?.clear();
+        layer.getSource()?.addFeature(feature);
     }
-    up() {
-        this.postboy.subscribe(FilterFeaturesInAreaQuery.ID).subscribe((qr) => {
-            qr.finish(qr.features.filter((f) => FeatureService.booleanIntersects(qr.area, f.getGeometry())));
+    addModify(command) {
+        this.modify = new Modify({
+            features: new Collection([command.model.feature]),
+            style: command.style,
+        });
+        this.modify.on('modifyend', () => {
+            this.onModified(command);
+            command.model.feature.changed();
         });
+        this.map?.addInteraction(this.modify);
+    }
+    addDragging(command) {
+        this.translate = new Translate({
+            features: new Collection([command.model.feature]),
+            condition: (ev) => {
+                const clone = command.model.feature.clone();
+                clone.getGeometry()?.scale(0.999);
+                return clone.getGeometry().intersectsCoordinate(ev.coordinate);
+            },
+        });
+        this.translate.on('translateend', () => this.onModified(command));
+        this.map?.addInteraction(this.translate);
     }
-    static booleanIntersects(g1, g2) {
-        if (g2.getType() === 'Point')
-            return g1.intersectsCoordinate(g2.getCoordinates());
-        if (g2.getType() === 'Circle')
-            return g1.intersectsCoordinate(g2.getCenter());
-        if (g2.getType() === 'Polygon')
-            return g1.intersectsCoordinate(g2.getInteriorPoint().getCoordinates());
-        return false;
+    onModified(command) {
+        command.next(command.format === FeatureOutputFormat.GeoJson
+            ? new GeoJSON().writeFeature(command.model.feature)
+            : new WKT().writeFeature(command.model.feature));
+    }
+    observeMapRender() {
+        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+            this.map = m.map;
+        });
+    }
+    defineLayer(action) {
+        const query = new GetLayerQuery(MapConstants.DrawingLayerId);
+        query.result.subscribe((l) => action(l));
+        this.postboy.fire(query);
+    }
+    observeCancelation(ev, layer) {
+        return this.postboy
+            .subscribe(CancelFeatureModificationCommand.ID)
+            .pipe(first())
+            .subscribe(() => {
+            ev.finish(null);
+            this.clearInteraction(layer);
+        });
+    }
+    clearInteraction(layer) {
+        if (this.modify)
+            this.map?.removeInteraction(this.modify);
+        if (this.translate)
+            this.map?.removeInteraction(this.translate);
     }
 }
-FeatureService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
-FeatureService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureService, decorators: [{
+FeatureModificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureModificationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+FeatureModificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureModificationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FeatureModificationService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
 class MessageRegistratorService extends PostboyAbstractRegistrator {
-    constructor(service, management, state, mapFeature, interaction, drawing, drawGenerator, feature) {
+    constructor(service, management, state, mapFeature, interaction, drawing, featureModification) {
         super(service);
-        this.registerServices([management, state, interaction, mapFeature, drawing, drawGenerator, feature]);
+        this.registerServices([management, state, interaction, mapFeature, drawing, featureModification]);
     }
     _up() {
         this.registerReplay(MapRenderedEvent.ID);
@@ -806,17 +917,23 @@ class MessageRegistratorService extends PostboyAbstractRegistrator {
         this.registerSubject(StartDrawingCommand.ID);
         this.registerSubject(GetLayerQuery.ID);
         this.registerSubject(DrawingFinishedEvent.ID);
-        this.registerSubject(GenerateDrawQuery.ID);
-        this.registerSubject(FilterFeaturesInAreaQuery.ID);
         this.registerSubject(GetFeaturesInAreaQuery.ID);
         this.registerSubject(DrawSelectionAreaCommand.ID);
+        this.registerSubject(CancelFeatureModificationCommand.ID);
+        this.registerSubject(ModifyFeatureCommand.ID);
+        this.setExecutors();
+    }
+    setExecutors() {
+        this.registerExecutor(FilterFeaturesInAreaExecutor.ID, (e) => FeatureService.filterFeaturesInArea(e));
+        this.registerExecutor(GenerateDrawExecutor.ID, (e) => DrawingGenerationService.getDraw(e));
+        this.registerExecutor(GenerateZoomControlExecutor.ID, (e) => ZoomControlFactory.build(e.settings));
     }
 }
-MessageRegistratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapFeatureService }, { token: MapClickService }, { token: DrawingService }, { token: DrawingGenerationService }, { token: FeatureService }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageRegistratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapFeatureService }, { token: MapClickService }, { token: DrawingService }, { token: FeatureModificationService }], target: i0.ɵɵFactoryTarget.Injectable });
 MessageRegistratorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MessageRegistratorService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MessageRegistratorService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapFeatureService }, { type: MapClickService }, { type: DrawingService }, { type: DrawingGenerationService }, { type: FeatureService }]; } });
+        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapFeatureService }, { type: MapClickService }, { type: DrawingService }, { type: FeatureModificationService }]; } });
 
 class TileLayerSettings {
     constructor() {
@@ -1370,6 +1487,7 @@ MapPlateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", vers
         DrawingService,
         DrawingGenerationService,
         FeatureService,
+        FeatureModificationService,
     ], usesInheritance: true, ngImport: i0, template: "<ng-content></ng-content>\r\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\r\n<lib-feature-layer *ngIf=\"map\" [settings]=\"drawingLayerSettings\"></lib-feature-layer>\r\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: ["url", "map"] }, { kind: "component", type: FeatureLayerComponent, selector: "lib-feature-layer", inputs: ["settings"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapPlateComponent, decorators: [{
             type: Component,
@@ -1382,6 +1500,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         DrawingService,
                         DrawingGenerationService,
                         FeatureService,
+                        FeatureModificationService,
                     ], template: "<ng-content></ng-content>\r\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\r\n<lib-feature-layer *ngIf=\"map\" [settings]=\"drawingLayerSettings\"></lib-feature-layer>\r\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"] }]
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MapPostboyService }, { type: MapPlateFactory }, { type: MessageRegistratorService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { settings: [{
                 type: Input
@@ -1551,6 +1670,94 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                 type: Input
             }] } });
 
+class ZoomControlSettings {
+    constructor() {
+        this.controlClass = 'ol-zoom';
+        this.zoomInClass = 'ol-zoom-in';
+        this.zoomOutClass = 'ol-zoom-out';
+        this.zoomInLabel = 'Zoom In';
+        this.zoomOutLabel = 'Zoom Out';
+    }
+    static copy(model) {
+        const result = new ZoomControlSettings();
+        result.controlClass = model.controlClass;
+        result.zoomInClass = model.zoomInClass;
+        result.zoomOutClass = model.zoomOutClass;
+        result.zoomInLabel = model.zoomInLabel;
+        result.zoomOutLabel = model.zoomOutLabel;
+        return result;
+    }
+    isSame(model) {
+        if (this.zoomInClass !== model.zoomInClass)
+            return false;
+        if (this.zoomOutClass !== model.zoomOutClass)
+            return false;
+        if (this.zoomInLabel !== model.zoomInLabel)
+            return false;
+        if (this.controlClass !== model.controlClass)
+            return false;
+        if (this.zoomOutLabel !== model.zoomOutLabel)
+            return false;
+        return true;
+    }
+    setZoomInLabel(zoomInLabel) {
+        return ZoomControlSettings.copy({ ...this, zoomInLabel });
+    }
+    setZoomOutClass(zoomOutClass) {
+        return ZoomControlSettings.copy({ ...this, zoomOutClass });
+    }
+    setZoomInClass(zoomInClass) {
+        return ZoomControlSettings.copy({ ...this, zoomInClass });
+    }
+    setZoomOutLabel(zoomOutLabel) {
+        return ZoomControlSettings.copy({ ...this, zoomOutLabel });
+    }
+    setControlClass(controlClass) {
+        return ZoomControlSettings.copy({ ...this, controlClass });
+    }
+}
+
+class MapControlZoomComponent extends DestructibleComponent {
+    set settings(value) {
+        if (!value || this._settings.isSame(value))
+            return;
+        this._settings = value;
+        this.setControl();
+    }
+    constructor(postboy) {
+        super();
+        this.postboy = postboy;
+        this._settings = new ZoomControlSettings();
+        this.onDestroy = () => {
+            this.eliminate();
+        };
+        this.eliminate = () => !!this.map && !!this.control && this.map.removeControl(this.control);
+    }
+    ngOnInit() {
+        this.postboy
+            .subscribe(MapRenderedEvent.ID)
+            .pipe(filter((m) => !!m), first())
+            .subscribe((m) => {
+            this.map = m.map;
+            this.setControl();
+        });
+    }
+    setControl() {
+        if (!this.map)
+            return;
+        this.control = this.postboy.execute(new GenerateZoomControlExecutor(this._settings));
+        this.map.addControl(this.control);
+    }
+}
+MapControlZoomComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapControlZoomComponent, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Component });
+MapControlZoomComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: MapControlZoomComponent, selector: "lib-map-control-zoom", inputs: { settings: "settings" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapControlZoomComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-map-control-zoom', template: '', changeDetection: ChangeDetectionStrategy.OnPush }]
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; }, propDecorators: { settings: [{
+                type: Input
+            }] } });
+
 class MapModule {
 }
 MapModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -1562,13 +1769,15 @@ MapModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.
         MarkersComponent,
         TooltipComponent,
         PolygonsComponent,
-        ClusterLayerComponent], imports: [CommonModule], exports: [MapPlateComponent,
+        ClusterLayerComponent,
+        MapControlZoomComponent], imports: [CommonModule], exports: [MapPlateComponent,
         FeatureLayerComponent,
         MarkersComponent,
         TileLayerComponent,
         TooltipComponent,
         PolygonsComponent,
-        ClusterLayerComponent] });
+        ClusterLayerComponent,
+        MapControlZoomComponent] });
 MapModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapModule, imports: [CommonModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapModule, decorators: [{
             type: NgModule,
@@ -1584,6 +1793,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         TooltipComponent,
                         PolygonsComponent,
                         ClusterLayerComponent,
+                        MapControlZoomComponent,
                     ],
                     exports: [
                         MapPlateComponent,
@@ -1593,6 +1803,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         TooltipComponent,
                         PolygonsComponent,
                         ClusterLayerComponent,
+                        MapControlZoomComponent,
                     ],
                 }]
         }] });
@@ -1636,6 +1847,23 @@ class PolygonStyleHelper {
             }),
         });
     }
+    static edit(fill, stroke, strokeWidth = 1, pinRadius = 5) {
+        return new Style({
+            image: new Circle({
+                fill: new Fill({
+                    color: stroke,
+                }),
+                radius: pinRadius,
+            }),
+            fill: new Fill({
+                color: fill,
+            }),
+            stroke: new Stroke({
+                color: stroke,
+                width: strokeWidth,
+            }),
+        });
+    }
 }
 
 class TextStyleHelper {
@@ -1714,5 +1942,5 @@ class StringifyFeatureHelper {
  * Generated bundle index. Do not edit.
  */
 
-export { CancelDrawingCommand, CloseTooltipCommand, ClusterLayerComponent, ClusterLayerSettings, Dictionary, DrawSelectionAreaCommand, DrawingType, FeatureLayerComponent, FeatureLayerSettings, FeatureOutputFormat, MapClickEvent, MapLyrs, MapLyrsLabel, MapModule, MapMoveEndEvent, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, OsmTileLayerComponent, PolygonModel, PolygonStyleHelper, PolygonsComponent, StartDrawingCommand, StringifyFeatureHelper, TextStyleHelper, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings };
+export { CancelDrawingCommand, CancelFeatureModificationCommand, CloseTooltipCommand, ClusterLayerComponent, ClusterLayerSettings, Dictionary, DrawSelectionAreaCommand, DrawingType, FeatureLayerComponent, FeatureLayerSettings, FeatureOutputFormat, MapClickEvent, MapControlZoomComponent, MapLyrs, MapLyrsLabel, MapModule, MapMoveEndEvent, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, ModifyFeatureCommand, OsmTileLayerComponent, PolygonModel, PolygonStyleHelper, PolygonsComponent, StartDrawingCommand, StringifyFeatureHelper, TextStyleHelper, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings, ZoomControlSettings };
 //# sourceMappingURL=maps-components.mjs.map