@artstesh/maps 1.0.10 → 1.0.11

package/dist/fesm2015/maps-components.js

@@ -2,23 +2,23 @@ import * as i0 from '@angular/core';
 import { Component, Injectable, ChangeDetectionStrategy, Input, ViewChild, NgModule } from '@angular/core';
 import * as i6 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 { 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';
@@ -180,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;
@@ -324,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();
@@ -413,42 +434,78 @@ 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 MapPostboyService extends PostboyService {
     constructor() {
@@ -530,8 +587,6 @@ class MapManagementService {
     observeFeaturesInArea() {
         this.postboy.subscribe(GetFeaturesInAreaQuery.ID).subscribe((qr) => {
             let result = new Dictionary();
-            const queue = [];
-            const queries = [];
             this.layers.forEach((l) => {
                 var _a, _b;
                 let layerName = l.get('name');
@@ -540,14 +595,10 @@ class MapManagementService {
                 let source = l.getSource();
                 if (!!source['getSource'])
                     source = (_a = source) === null || _a === void 0 ? void 0 : _a.getSource();
-                const query = new FilterFeaturesInAreaQuery(qr.area, (_b = source === null || source === void 0 ? void 0 : source.getFeatures()) !== null && _b !== void 0 ? _b : []);
-                queue.push(query.result.pipe(tap((r) => {
-                    result.put(l.get('name'), r.map((e) => (Object.assign({ id: e.getId() }, e.get(MapConstants.FeatureInfo)))));
-                })));
-                queries.push(query);
+                let features = this.postboy.execute(new FilterFeaturesInAreaExecutor(qr.area, (_b = source === null || source === void 0 ? void 0 : source.getFeatures()) !== null && _b !== void 0 ? _b : []));
+                result.put(layerName, features.map((e) => (Object.assign({ id: e.getId() }, e.get(MapConstants.FeatureInfo)))));
             });
-            forkJoin(queue).subscribe(() => qr.finish(result));
-            queries.forEach((q) => this.postboy.fire(q));
+            qr.finish(result);
         });
     }
 }
@@ -690,22 +741,18 @@ class DrawingService {
     observeDrawing() {
         this.postboy.subscribe(StartDrawingCommand.ID).subscribe((ev) => {
             this.draw((l) => {
+                var _a;
                 if (!l || !this.map) {
                     this.clearInteraction(l);
                     return;
                 }
-                const drawQuery = new GenerateDrawQuery(l, ev.style, ev.type);
-                drawQuery.result.subscribe((draw) => {
-                    var _a;
-                    const cancelSub = this.observeCancelation(ev, l);
-                    this.drawInteraction = draw;
-                    (_a = this.map) === null || _a === void 0 ? void 0 : _a.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));
+                (_a = this.map) === null || _a === void 0 ? void 0 : _a.addInteraction(this.drawInteraction);
+                this.drawInteraction.on('drawend', (evt) => {
+                    cancelSub.unsubscribe();
+                    this.onEnd(evt, ev, l);
                 });
-                this.postboy.fire(drawQuery);
             });
         });
     }
@@ -749,56 +796,101 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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: "12.2.17", ngImport: i0, type: DrawingGenerationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
-DrawingGenerationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DrawingGenerationService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DrawingGenerationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
-
-class FeatureService {
-    constructor(postboy) {
-        this.postboy = postboy;
+    initFeature(layer, feature) {
+        var _a, _b;
+        (_a = layer.getSource()) === null || _a === void 0 ? void 0 : _a.clear();
+        (_b = layer.getSource()) === null || _b === void 0 ? void 0 : _b.addFeature(feature);
     }
-    up() {
-        this.postboy.subscribe(FilterFeaturesInAreaQuery.ID).subscribe((qr) => {
-            qr.finish(qr.features.filter((f) => FeatureService.booleanIntersects(qr.area, f.getGeometry())));
+    addModify(command) {
+        var _a;
+        this.modify = new Modify({
+            features: new Collection([command.model.feature]),
+            style: command.style,
+        });
+        this.modify.on('modifyend', () => {
+            this.onModified(command);
+            command.model.feature.changed();
         });
+        (_a = this.map) === null || _a === void 0 ? void 0 : _a.addInteraction(this.modify);
     }
-    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;
+    addDragging(command) {
+        var _a;
+        this.translate = new Translate({
+            features: new Collection([command.model.feature]),
+            condition: (ev) => {
+                var _a;
+                const clone = command.model.feature.clone();
+                (_a = clone.getGeometry()) === null || _a === void 0 ? void 0 : _a.scale(0.999);
+                return clone.getGeometry().intersectsCoordinate(ev.coordinate);
+            },
+        });
+        this.translate.on('translateend', () => this.onModified(command));
+        (_a = this.map) === null || _a === void 0 ? void 0 : _a.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) {
+        var _a, _b;
+        if (this.modify)
+            (_a = this.map) === null || _a === void 0 ? void 0 : _a.removeInteraction(this.modify);
+        if (this.translate)
+            (_b = this.map) === null || _b === void 0 ? void 0 : _b.removeInteraction(this.translate);
     }
 }
-FeatureService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
-FeatureService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureService, decorators: [{
+FeatureModificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureModificationService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+FeatureModificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureModificationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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);
@@ -815,17 +907,22 @@ 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));
     }
 }
-MessageRegistratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", 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: "12.2.17", 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: "12.2.17", ngImport: i0, type: MessageRegistratorService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", 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() {
@@ -1404,6 +1501,7 @@ MapPlateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.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"], components: [{ type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: ["url", "map"] }, { type: FeatureLayerComponent, selector: "lib-feature-layer", inputs: ["settings"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateComponent, decorators: [{
             type: Component,
@@ -1421,6 +1519,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                         DrawingService,
                         DrawingGenerationService,
                         FeatureService,
+                        FeatureModificationService,
                     ],
                 }]
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MapPostboyService }, { type: MapPlateFactory }, { type: MessageRegistratorService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { settings: [{
@@ -1695,6 +1794,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 {
@@ -1773,5 +1889,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, 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.js.map