@artstesh/maps 5.0.9 → 5.0.11

package/dist/fesm2022/maps-components-src-map.mjs

@@ -2,16 +2,16 @@ 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 { PostboyGenericMessage, PostboyCallbackMessage, PostboyExecutor, PostboyService, PostboyAbstractRegistrator } from '@artstesh/postboy';
+import { Draw, Modify, Translate } from 'ol/interaction';
+import { createRegularPolygon } from 'ol/interaction/Draw';
 import { first, filter, auditTime } from 'rxjs/operators';
 import { Vector, XYZ } from 'ol/source';
-import { Draw } from 'ol/interaction';
-import { createRegularPolygon } from 'ol/interaction/Draw';
 import TileLayer from 'ol/layer/Tile';
 import OSM from 'ol/source/OSM';
 import { Vector as Vector$1 } from 'ol/layer';
@@ -186,6 +186,7 @@ var DrawingType;
 (function (DrawingType) {
     DrawingType[DrawingType["Polygon"] = 1] = "Polygon";
     DrawingType[DrawingType["Circle"] = 2] = "Circle";
+    DrawingType[DrawingType["Square"] = 3] = "Square";
 })(DrawingType || (DrawingType = {}));
 
 var FeatureOutputFormat;
@@ -194,6 +195,60 @@ var FeatureOutputFormat;
     FeatureOutputFormat[FeatureOutputFormat["WKT"] = 2] = "WKT";
 })(FeatureOutputFormat || (FeatureOutputFormat = {}));
 
+class Dictionary {
+    collection = {};
+    _keys = new Set();
+    get keys() {
+        return Array.from(this._keys);
+    }
+    get size() {
+        return this._keys.size;
+    }
+    static clone(dic, action) {
+        return Dictionary.create(dic.collection, action);
+    }
+    static create(dic, action) {
+        let keyList = Object.keys(dic);
+        const result = new Dictionary();
+        for (let i = 0; i < keyList.length; i++) {
+            let key = keyList[i];
+            result._keys.add(key);
+            result.collection[key] = action ? action(dic[key], key) : dic[key];
+        }
+        return result;
+    }
+    find(predicate) {
+        let result = null;
+        this.forEach((e) => {
+            if (result === null && predicate(e))
+                result = e;
+        });
+        return result;
+    }
+    has = (key) => this._keys.has(key);
+    take(key) {
+        return this._keys.has(key) ? this.collection[key] : null;
+    }
+    put(key, value) {
+        if (value == null)
+            return;
+        this.collection[key] = value;
+        this._keys.add(key);
+    }
+    rmv(key) {
+        if (!this._keys.has(key))
+            return;
+        delete this.collection[key];
+        this._keys.delete(key);
+    }
+    forEach(callback) {
+        let keys = Object.keys(this.collection);
+        for (let i = 0; i < keys.length; i++) {
+            callback(this.collection[keys[i]], i);
+        }
+    }
+}
+
 class MapRenderedEvent extends PostboyGenericMessage {
     map;
     static ID = 'b6121807-3b89-4cd3-82cf-089d2cefdc4f';
@@ -271,6 +326,45 @@ class CancelDrawingCommand extends PostboyGenericMessage {
     }
 }
 
+class DrawSelectionAreaCommand extends PostboyCallbackMessage {
+    type;
+    style;
+    ignore;
+    static ID = '573d8a0d-f25b-42b7-9ad7-0ac6d86ac362';
+    constructor(type, style, ignore = new Set()) {
+        super();
+        this.type = type;
+        this.style = style;
+        this.ignore = ignore;
+    }
+    get id() {
+        return DrawSelectionAreaCommand.ID;
+    }
+}
+
+class ModifyFeatureCommand extends PostboyCallbackMessage {
+    model;
+    style;
+    format;
+    static ID = 'ead85caa-24c6-4844-a68c-2cea91774c8c';
+    constructor(model, style, format = FeatureOutputFormat.GeoJson) {
+        super();
+        this.model = model;
+        this.style = style;
+        this.format = format;
+    }
+    get id() {
+        return ModifyFeatureCommand.ID;
+    }
+}
+
+class CancelFeatureModificationCommand extends PostboyGenericMessage {
+    static ID = '9c9fb40f-ea95-4704-8177-0e9ecabf36fa';
+    get id() {
+        return CancelFeatureModificationCommand.ID;
+    }
+}
+
 class AddLayerCommand extends PostboyGenericMessage {
     layer;
     static ID = 'd93e250f-92bc-43ac-9c6a-46c521a1aaa5';
@@ -369,7 +463,71 @@ class DrawingFinishedEvent extends PostboyGenericMessage {
     }
 }
 
-class GenerateDrawQuery extends PostboyCallbackMessage {
+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 {
+    area;
+    ignore;
+    static ID = 'efcf4271-a07a-40e0-9f02-d4dade40b8ac';
+    constructor(area, ignore = new Set()) {
+        super();
+        this.area = area;
+        this.ignore = ignore;
+    }
+    get id() {
+        return GetFeaturesInAreaQuery.ID;
+    }
+}
+
+class FilterFeaturesInAreaExecutor extends PostboyExecutor {
+    area;
+    features;
+    static ID = '36bb2d94-8028-4512-90dd-2386af3fc67c';
+    constructor(area, features) {
+        super();
+        this.area = area;
+        this.features = features;
+    }
+    get id() {
+        return FilterFeaturesInAreaExecutor.ID;
+    }
+}
+
+class GenerateDrawExecutor extends PostboyExecutor {
     layer;
     style;
     type;
@@ -381,7 +539,7 @@ class GenerateDrawQuery extends PostboyCallbackMessage {
         this.type = type;
     }
     get id() {
-        return GenerateDrawQuery.ID;
+        return GenerateDrawExecutor.ID;
     }
 }
 
@@ -400,7 +558,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
 class MapManagementService {
     postboy;
     map;
-    layers = {};
+    layers = new Dictionary();
     constructor(postboy) {
         this.postboy = postboy;
     }
@@ -412,6 +570,7 @@ class MapManagementService {
         this.observeAddTile();
         this.observeRemoveTile();
         this.observeLayerQuery();
+        this.observeFeaturesInArea();
     }
     observeRemoveTile() {
         this.postboy.subscribe(RemoveTileCommand.ID).subscribe((c) => {
@@ -421,7 +580,7 @@ class MapManagementService {
         });
     }
     observeLayerQuery() {
-        this.postboy.subscribe(GetLayerQuery.ID).subscribe((ev) => ev.finish(this.layers[ev.name] ?? null));
+        this.postboy.subscribe(GetLayerQuery.ID).subscribe((ev) => ev.finish(this.layers.take(ev.name)));
     }
     observeAddTile() {
         this.postboy.subscribe(AddTileCommand.ID).subscribe((c) => {
@@ -439,15 +598,15 @@ class MapManagementService {
         this.postboy.subscribe(AddLayerCommand.ID).subscribe((c) => {
             if (!this.map)
                 return;
-            this.layers[c.layer.get('name')] = c.layer;
+            this.layers.put(c.layer.get('name'), c.layer);
             this.map.addLayer(c.layer);
         });
     }
     observePlaceFeatures() {
         this.postboy.subscribe(PlaceLayerFeaturesCommand.ID).subscribe((c) => {
-            if (!this.layers[c.layer])
+            if (!this.layers.has(c.layer))
                 return;
-            let source = this.layers[c.layer]?.getSource();
+            let source = this.layers.take(c.layer).getSource();
             if (!!source['getSource'])
                 source = source?.getSource();
             source?.clear();
@@ -458,10 +617,26 @@ class MapManagementService {
         this.postboy.subscribe(RemoveLayerCommand.ID).subscribe((c) => {
             if (!this.map)
                 return;
-            delete this.layers[c.layer.get('name')];
+            this.layers.rmv(c.layer.get('name'));
             this.map.removeLayer(c.layer);
         });
     }
+    observeFeaturesInArea() {
+        this.postboy.subscribe(GetFeaturesInAreaQuery.ID).subscribe((qr) => {
+            let result = new Dictionary();
+            this.layers.forEach((l) => {
+                let layerName = l.get('name');
+                if (qr.ignore.has(layerName) || layerName === MapConstants.DrawingLayerId)
+                    return;
+                let source = l.getSource();
+                if (!!source['getSource'])
+                    source = source?.getSource();
+                let features = this.postboy.execute(new FilterFeaturesInAreaExecutor(qr.area, source?.getFeatures() ?? []));
+                result.put(layerName, features.map((e) => ({ id: e.getId(), ...e.get(MapConstants.FeatureInfo) })));
+            });
+            qr.finish(result);
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapManagementService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapManagementService });
 }
@@ -584,26 +759,42 @@ class DrawingService {
         this.postboy = postboy;
     }
     up() {
+        this.observeDrawing();
+        this.observeSelectArea();
+        this.observeMapRender();
+    }
+    observeSelectArea() {
+        this.postboy.subscribe(DrawSelectionAreaCommand.ID).subscribe((ev) => {
+            const drawingCommand = new StartDrawingCommand(ev.type, ev.style);
+            drawingCommand.result.subscribe((r) => {
+                if (!r) {
+                    ev.finish(new Dictionary());
+                    return;
+                }
+                const area = PolygonModel.fromGeoJson(1, r).feature.getGeometry();
+                const getFeaturesCommand = new GetFeaturesInAreaQuery(area, ev.ignore);
+                getFeaturesCommand.result.subscribe((result) => ev.finish(result));
+                this.postboy.fire(getFeaturesCommand);
+            });
+            this.postboy.fire(drawingCommand);
+        });
+    }
+    observeDrawing() {
         this.postboy.subscribe(StartDrawingCommand.ID).subscribe((ev) => {
             this.draw((l) => {
                 if (!l || !this.map) {
                     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);
             });
         });
-        this.observeMapRender();
     }
     onEnd(evt, command, layer) {
         command.finish(command.format === FeatureOutputFormat.GeoJson
@@ -644,32 +835,100 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
-class DrawingGenerationService {
+class FeatureModificationService {
     postboy;
+    modify;
+    translate;
+    map;
     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);
+            });
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawingGenerationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawingGenerationService });
+    initFeature(layer, feature) {
+        layer.getSource()?.clear();
+        layer.getSource()?.addFeature(feature);
+    }
+    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);
+    }
+    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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FeatureModificationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FeatureModificationService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawingGenerationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FeatureModificationService, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
 class MessageRegistratorService extends PostboyAbstractRegistrator {
-    constructor(service, management, state, feature, interaction, drawing, drawGenerator) {
+    constructor(service, management, state, mapFeature, interaction, drawing, featureModification) {
         super(service);
-        this.registerServices([management, state, interaction, feature, drawing, drawGenerator]);
+        this.registerServices([management, state, interaction, mapFeature, drawing, featureModification]);
     }
     _up() {
         this.registerReplay(MapRenderedEvent.ID);
@@ -686,14 +945,22 @@ class MessageRegistratorService extends PostboyAbstractRegistrator {
         this.registerSubject(StartDrawingCommand.ID);
         this.registerSubject(GetLayerQuery.ID);
         this.registerSubject(DrawingFinishedEvent.ID);
-        this.registerSubject(GenerateDrawQuery.ID);
+        this.registerSubject(GetFeaturesInAreaQuery.ID);
+        this.registerSubject(DrawSelectionAreaCommand.ID);
+        this.registerSubject(CancelFeatureModificationCommand.ID);
+        this.registerSubject(ModifyFeatureCommand.ID);
+        this.setExecutors();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapFeatureService }, { token: MapClickService }, { token: DrawingService }, { token: DrawingGenerationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    setExecutors() {
+        this.registerExecutor(FilterFeaturesInAreaExecutor.ID, (e) => FeatureService.filterFeaturesInArea(e));
+        this.registerExecutor(GenerateDrawExecutor.ID, (e) => DrawingGenerationService.getDraw(e));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapFeatureService }, { token: MapClickService }, { token: DrawingService }, { token: FeatureModificationService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapFeatureService }, { type: MapClickService }, { type: DrawingService }, { type: DrawingGenerationService }]; } });
+        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapFeatureService }, { type: MapClickService }, { type: DrawingService }, { type: FeatureModificationService }]; } });
 
 class TileLayerSettings {
     maxZoom = 19;
@@ -1259,6 +1526,8 @@ class MapPlateComponent extends DestructibleComponent {
             MapFeatureService,
             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: "16.2.12", ngImport: i0, type: MapPlateComponent, decorators: [{
@@ -1271,6 +1540,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                         MapFeatureService,
                         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
@@ -1533,6 +1804,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 {
@@ -1607,5 +1895,5 @@ class StringifyFeatureHelper {
  * Generated bundle index. Do not edit.
  */
 
-export { CancelDrawingCommand, CloseTooltipCommand, ClusterLayerComponent, ClusterLayerSettings, 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, MapLyrs, MapLyrsLabel, MapModule, MapMoveEndEvent, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, ModifyFeatureCommand, OsmTileLayerComponent, PolygonModel, PolygonStyleHelper, PolygonsComponent, StartDrawingCommand, StringifyFeatureHelper, TextStyleHelper, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings };
 //# sourceMappingURL=maps-components-src-map.mjs.map