@artstesh/maps 4.1.14 → 4.1.15

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

@@ -65,6 +65,10 @@ MapLyrsLabel.lyrs = {
     [MapLyrs.Terrain]: 'p',
 };
 
+/**
+ * Represents the configurable settings for a map instance, providing
+ * options for center coordinates, zoom levels, map layers, and language.
+ */
 class MapSettings {
     constructor() {
         this.center = [0, 0];
@@ -84,24 +88,66 @@ class MapSettings {
         result.language = model.language;
         return result;
     }
+    /**
+     * Sets the center for the map settings.
+     *
+     * @param {number[]} center - A two-element array representing the latitude and longitude of the map's center.
+     * @return {MapSettings} A new MapSettings object with the updated center.
+     */
     setCenter(center) {
         return MapSettings.copy({ ...this, center });
     }
+    /**
+     * Sets the maximum zoom level for the map.
+     *
+     * @param {number} maxZoom - The maximum zoom level to be set.
+     * @return {MapSettings} A new instance of MapSettings with the updated maximum zoom level.
+     */
     setMaxZoom(maxZoom) {
         return MapSettings.copy({ ...this, maxZoom });
     }
+    /**
+     * Sets the minimum zoom level for the map settings.
+     *
+     * @param {number} minZoom The minimum zoom level to be set. Must be a valid numeric value.
+     * @return {MapSettings} A new MapSettings object with the updated minimum zoom level.
+     */
     setMinZoom(minZoom) {
         return MapSettings.copy({ ...this, minZoom });
     }
+    /**
+     * Adjusts the zoom level of the map by setting the specified value.
+     *
+     * @param {number} zoom - The desired zoom level to be set.
+     * @return {MapSettings} A new MapSettings instance with the updated zoom level.
+     */
     setZoom(zoom) {
         return MapSettings.copy({ ...this, zoom });
     }
+    /**
+     * Sets the layers in the map settings with the provided layers.
+     *
+     * @param {MapLyrs} lyrs - The layers to be set in the map settings.
+     * @return {MapSettings} A new instance of MapSettings with the updated layers.
+     */
     setLyrs(lyrs) {
         return MapSettings.copy({ ...this, lyrs });
     }
+    /**
+     * Updates the language setting for the map configuration and returns a new instance with the updated language.
+     *
+     * @param {string} language - The language to be set for the map configuration.
+     * @return {MapSettings} A new instance of MapSettings with the updated language.
+     */
     setLanguage(language) {
         return MapSettings.copy({ ...this, language });
     }
+    /**
+     * Compares the current MapSettings instance with another to determine if they are identical.
+     *
+     * @param {MapSettings} model - The MapSettings instance to compare with the current instance.
+     * @return {boolean} Returns true if both MapSettings instances have the same properties and values; otherwise, false.
+     */
     isSame(model) {
         if (this.maxZoom !== model.maxZoom)
             return false;
@@ -180,6 +226,19 @@ class PolygonModel {
     }
 }
 
+/**
+ * Enum representing various drawing types.
+ *
+ * This enumeration is used to define the types of drawable shapes
+ * within a specific drawing context. Each member corresponds to
+ * a specific type of drawing.
+ *
+ * Members:
+ * - `Polygon`: Represents a polygonal shape (e.g., triangle, pentagon, etc.).
+ * - `Circle`: Represents a circular shape.
+ * - `Square`: Represents a square shape.
+ * - `Box`: Represents a rectangular box shape.
+ */
 var DrawingType;
 (function (DrawingType) {
     DrawingType[DrawingType["Polygon"] = 1] = "Polygon";
@@ -188,6 +247,14 @@ var DrawingType;
     DrawingType[DrawingType["Box"] = 4] = "Box";
 })(DrawingType || (DrawingType = {}));
 
+/**
+ * An enumeration representing different formats for feature outputs.
+ * This can be used to specify the desired output format when dealing with geospatial data.
+ *
+ * Enumerators:
+ * - GeoJson: Represents the GeoJSON format for geospatial data.
+ * - WKT: Represents the Well-Known Text (WKT) format for geospatial data.
+ */
 var FeatureOutputFormat;
 (function (FeatureOutputFormat) {
     FeatureOutputFormat[FeatureOutputFormat["GeoJson"] = 1] = "GeoJson";
@@ -208,126 +275,129 @@ class MapControl extends Control {
     }
 }
 
-class MapRenderedEvent extends PostboyGenericMessage {
-    constructor(map) {
-        super();
-        this.map = map;
-    }
-    get id() {
-        return MapRenderedEvent.ID;
-    }
-}
-MapRenderedEvent.ID = 'b6121807-3b89-4cd3-82cf-089d2cefdc4f';
-
-class MapClickEvent extends PostboyGenericMessage {
-    constructor(coordinates, entities, features) {
-        super();
-        this.coordinates = coordinates;
-        this.entities = entities;
-        this.features = features;
-    }
-    get id() {
-        return MapClickEvent.ID;
-    }
-}
-MapClickEvent.ID = '323df526-8d9c-49c6-83e8-6e9a1e7762f7';
-
-class MapMoveEndEvent extends PostboyGenericMessage {
-    constructor(position) {
+/**
+ * Represents a command to add a custom control to a map.
+ */
+class AddControlCommand extends PostboyGenericMessage {
+    /**
+     * Creates an instance of the class with the specified MapControl object.
+     *
+     * @param {MapControl} item - The MapControl object to be associated with the instance.
+     */
+    constructor(item) {
         super();
-        this.position = position;
-    }
-    get id() {
-        return MapMoveEndEvent.ID;
+        this.item = item;
     }
-}
-MapMoveEndEvent.ID = 'f21f783e-b5af-4489-9fec-8027fd07a8ad';
+}
 
+/**
+ * A command class that represents the action to close a tooltip.
+ */
 class CloseTooltipCommand extends PostboyGenericMessage {
+    /**
+     * Creates an instance of the class with the specified tooltip ID.
+     *
+     * @param {string} tooltipId - The unique identifier for the tooltip.
+     */
     constructor(tooltipId) {
         super();
         this.tooltipId = tooltipId;
     }
-    get id() {
-        return CloseTooltipCommand.ID;
-    }
-}
-CloseTooltipCommand.ID = '4896d52c-e34f-4994-bcfd-32832d12dbe4';
+}
 
+/**
+ * Represents a command to start a drawing operation.
+ */
 class StartDrawingCommand extends PostboyCallbackMessage {
+    /**
+     * Constructor for creating an instance of the class that represents a drawing feature with specific type, style, and output format.
+     *
+     * @param {DrawingType} type - The type of the drawing to be created.
+     * @param {Style} style - The style defining visual appearance of the drawing.
+     * @param {FeatureOutputFormat} [format=FeatureOutputFormat.GeoJson] - The format of the feature output. Defaults to GeoJson.
+     */
     constructor(type, style, format = FeatureOutputFormat.GeoJson) {
         super();
         this.type = type;
         this.style = style;
         this.format = format;
     }
-    get id() {
-        return StartDrawingCommand.ID;
-    }
-}
-StartDrawingCommand.ID = 'da904f4b-a1c8-4db7-a6af-14d9ee18ec8c';
+}
 
+/**
+ * Represents a command to cancel a drawing action.
+ */
 class CancelDrawingCommand extends PostboyGenericMessage {
-    get id() {
-        return CancelDrawingCommand.ID;
-    }
-}
-CancelDrawingCommand.ID = '7d38d983-feba-4176-a66b-18175e5ecd6b';
+}
 
+/**
+ * Class representing a command to draw a selection area with a specific type and style.
+ *
+ * @return {Dictionary<IIdentified[]>} - a collection of features inside the selected area, grouped by a layer's name
+ */
 class DrawSelectionAreaCommand extends PostboyCallbackMessage {
+    /**
+     * Constructs a new instance with the specified type, style, and optional set of ignored items.
+     *
+     * @param {DrawingType} type - The type of drawing to be created.
+     * @param {Style} style - The style information for the drawing.
+     * @param {Set<string>} [ignore=new Set<string>()] - Optional set of items to be ignored.
+     */
     constructor(type, style, ignore = new Set()) {
         super();
         this.type = type;
         this.style = style;
         this.ignore = ignore;
     }
-    get id() {
-        return DrawSelectionAreaCommand.ID;
-    }
-}
-DrawSelectionAreaCommand.ID = '573d8a0d-f25b-42b7-9ad7-0ac6d86ac362';
+}
 
+/**
+ * Represents a command to modify a feature with a specific style and output format
+ * for a polygonal model.
+ *
+ * @return {string | null} a string representation of the modified feature in the appropriate format
+ */
 class ModifyFeatureCommand extends PostboyCallbackMessage {
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {PolygonModel} model - The polygon model to be used.
+     * @param {Style} style - The style configuration for the polygon.
+     * @param {FeatureOutputFormat} [format=FeatureOutputFormat.GeoJson] - The output format of the features. Default is GeoJson.
+     */
     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';
+}
 
+/**
+ * Represents a command to cancel a feature modification.
+ */
 class CancelFeatureModificationCommand extends PostboyGenericMessage {
-    get id() {
-        return CancelFeatureModificationCommand.ID;
-    }
-}
-CancelFeatureModificationCommand.ID = '9c9fb40f-ea95-4704-8177-0e9ecabf36fa';
-
-class AddControlCommand extends PostboyGenericMessage {
-    constructor(item) {
-        super();
-        this.item = item;
-    }
-    get id() {
-        return AddControlCommand.ID;
-    }
-}
-AddControlCommand.ID = '8e1c06eb-b395-4fe1-929c-ebf0805eeb49';
+}
 
+/**
+ * Represents a command to remove a map control from the map.
+ *
+ * The command is identified by a unique static ID, and it requires a MapControl item
+ * to specify the control to be removed.
+ *
+ * @extends PostboyGenericMessage
+ */
 class RemoveControlCommand extends PostboyGenericMessage {
+    /**
+     * Constructs an instance of the class.
+     *
+     * @param {MapControl} item - The map control instance to be removed.
+     */
     constructor(item) {
         super();
         this.item = item;
     }
-    get id() {
-        return RemoveControlCommand.ID;
-    }
-}
-RemoveControlCommand.ID = '361641e0-804a-4930-8c27-0cea6330dbfc';
+}
 
 /**
  * Forces map to move to a specific point
@@ -345,34 +415,128 @@ class SetMapCenterCommand extends PostboyGenericMessage {
         this.lng = lng;
         this.zoom = zoom;
     }
-    get id() {
-        return SetMapCenterCommand.ID;
+}
+
+/**
+ * FitToPolygonsCommand is a command used to fit a given set of polygon features
+ * to the viewable area, optionally applying a zoom transformation afterwards.
+ */
+class FitToPolygonsCommand extends PostboyGenericMessage {
+    /**
+     * Creates an instance of the class with specified polygon features and an optional zoom level.
+     *
+     * @param {PolygonModel[]} features - An array of polygon models to fit to.
+     * @param {number} [zoomAfter=0] - Optional zoom level change to apply after initialization. Defaults to 0.
+     */
+    constructor(features, zoomAfter = 0) {
+        super();
+        this.features = features;
+        this.zoomAfter = zoomAfter;
     }
-}
-SetMapCenterCommand.ID = 'd50e89c9-6707-4f8c-ab57-65fcef232182';
+}
 
-class CalculateAreaExecutor extends PostboyExecutor {
-    constructor(polygon) {
+/**
+ * Represents an event triggered when a map rendering process is completed.
+ */
+class MapRenderedEvent extends PostboyGenericMessage {
+    /**
+     * Constructor for creating an instance of the class.
+     *
+     * @param {Map} map - The map instance to be used by the class.
+     */
+    constructor(map) {
         super();
-        this.polygon = polygon;
+        this.map = map;
     }
-    get id() {
-        return CalculateAreaExecutor.ID;
+}
+
+/**
+ * Represents an event triggered by a click on a map, containing information about the
+ * click's location, relevant entities, and features present at the clicked position.
+ *
+ * @extends {PostboyGenericMessage}
+ */
+class MapClickEvent extends PostboyGenericMessage {
+    /**
+     * Creates an instance of this class with the provided coordinates, entities, and features.
+     *
+     * @param {number[]} coordinates - An array representing the coordinates.
+     * @param {{ [layer: string]: IIdentified[] }} entities - A mapping of layer names to arrays of IIdentified entities.
+     * @param {{ [layer: string]: Feature<Geometry>[] }} features - A mapping of layer names to arrays of features with geometry.
+     */
+    constructor(coordinates, entities, features) {
+        super();
+        this.coordinates = coordinates;
+        this.entities = entities;
+        this.features = features;
     }
-}
-CalculateAreaExecutor.ID = '172ecf46-86b5-4f46-a5f1-96ba2cbb1694';
+}
 
-class FitToPolygonsCommand extends PostboyGenericMessage {
-    constructor(features, zoomAfter = 0) {
+/**
+ * Represents an event that is triggered when the movement of a map ends.
+ * This class is used to capture the final position of a map after a movement operation.
+ *
+ * @property {MapPosition | null} position - The final position of the map after movement ends. Can be null.
+ */
+class MapMoveEndEvent extends PostboyGenericMessage {
+    constructor(position) {
         super();
+        this.position = position;
+    }
+}
+
+/**
+ * A class responsible for executing filtering of geographical features
+ * based on a specific geographical point (latitude and longitude).
+ *
+ * @template Feature - A geographical feature that is processed by the executor.
+ * @template Geometry - The type of geometry associated with the feature.
+ */
+class FilterFeaturesInPointExecutor extends PostboyExecutor {
+    /**
+     * Constructs a new instance with the specified latitude, longitude, and features.
+     *
+     * @param {number} lat - The latitude coordinate.
+     * @param {number} lng - The longitude coordinate.
+     * @param {Feature<Geometry>[]} features - The array of features associated with the location.
+     */
+    constructor(lat, lng, features) {
+        super();
+        this.lat = lat;
+        this.lng = lng;
         this.features = features;
-        this.zoomAfter = zoomAfter;
     }
-    get id() {
-        return FitToPolygonsCommand.ID;
+}
+
+/**
+ * A class that extends the PostboyExecutor to filter geographical features within a specified area.
+ * This class is designed to process a list of input features and determine which of them are located inside the provided area geometry.
+ *
+ * Parameters:
+ * - `area`: A Geometry object defining the area to filter geographical features.
+ * - `features`: An array of geographical features, represented as `Feature<Geometry>` objects, to be filtered by their presence within the specified area.
+ */
+class FilterFeaturesInAreaExecutor extends PostboyExecutor {
+    constructor(area, features) {
+        super();
+        this.area = area;
+        this.features = features;
     }
-}
-FitToPolygonsCommand.ID = 'a9e42b23-ffaf-4c46-8370-e0432cd14d60';
+}
+
+/**
+ * An executor responsible for calculating the area of a given polygon.
+ *
+ * Use this class to manage and execute area-calculation logic for a polygon.
+ *
+ * @return {number} - the spherical area (in square meters)
+ */
+class CalculateAreaExecutor extends PostboyExecutor {
+    constructor(polygon) {
+        super();
+        this.polygon = polygon;
+    }
+}
 
 /**
  * A message that allows to get the current state of the map.
@@ -380,82 +544,56 @@ FitToPolygonsCommand.ID = 'a9e42b23-ffaf-4c46-8370-e0432cd14d60';
  * @returns {MapPosition | null}
  */
 class GetMapPositionExecutor extends PostboyExecutor {
-    get id() {
-        return GetMapPositionExecutor.ID;
-    }
     constructor() {
         super();
     }
 }
 GetMapPositionExecutor.ID = '52c95689-d09b-4082-ba58-9183ea96a213';
 
+/**
+ * Class representing a query to get features within a specified geographical area.
+ * The query optionally takes a set of layer names to ignore during the operation.
+ */
 class GetFeaturesInAreaQuery extends PostboyCallbackMessage {
+    /**
+     * Constructor to initialize the object with a Geometry instance and an optional set of strings to ignore.
+     *
+     * @param {Geometry} area - The Geometry object used to define the area.
+     * @param {Set<string>} [ignore] - An optional set of layer names that will be ignored. Defaults to an empty set.
+     */
     constructor(area, ignore = new Set()) {
         super();
         this.area = area;
         this.ignore = ignore;
     }
-    get id() {
-        return GetFeaturesInAreaQuery.ID;
-    }
-}
-GetFeaturesInAreaQuery.ID = 'efcf4271-a07a-40e0-9f02-d4dade40b8ac';
-
-class FilterFeaturesInAreaExecutor extends PostboyExecutor {
-    constructor(area, features) {
-        super();
-        this.area = area;
-        this.features = features;
-    }
-    get id() {
-        return FilterFeaturesInAreaExecutor.ID;
-    }
-}
-FilterFeaturesInAreaExecutor.ID = '36bb2d94-8028-4512-90dd-2386af3fc67c';
+}
 
 /**
  * Represents a query to retrieve features located at a specific geographical point.
  * The query is defined by latitude, longitude, and an optional set of features to ignore.
  */
 class GetFeaturesInPointQuery extends PostboyCallbackMessage {
+    /**
+     * Constructor for initializing a geographic coordinate object.
+     *
+     * @param {number} lat - The latitude of the location.
+     * @param {number} lng - The longitude of the location.
+     * @param {Set<string>} [ignore=new Set<string>()] - An optional set of strings to ignore during processing.
+     */
     constructor(lat, lng, ignore = new Set()) {
         super();
         this.lat = lat;
         this.lng = lng;
         this.ignore = ignore;
     }
-    get id() {
-        return GetFeaturesInPointQuery.ID;
-    }
-}
-GetFeaturesInPointQuery.ID = '7c051c97-bbf1-47eb-baa3-4d1eef6f281f';
-
-/**
- * The FilterFeaturesInPointExecutor class is responsible for filtering features within a given point.
- */
-class FilterFeaturesInPointExecutor extends PostboyExecutor {
-    get id() {
-        return FilterFeaturesInPointExecutor.ID;
-    }
-    constructor(lat, lng, features) {
-        super();
-        this.lat = lat;
-        this.lng = lng;
-        this.features = features;
-    }
-}
-FilterFeaturesInPointExecutor.ID = '5b859282-5d5a-47ca-a6ad-863a66c8b82b';
+}
 
 class AddLayerCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddLayerCommand.ID;
-    }
-}
-AddLayerCommand.ID = 'd93e250f-92bc-43ac-9c6a-46c521a1aaa5';
+}
 
 class PlaceLayerFeaturesCommand extends PostboyGenericMessage {
     constructor(layer, features) {
@@ -463,44 +601,28 @@ class PlaceLayerFeaturesCommand extends PostboyGenericMessage {
         this.layer = layer;
         this.features = features;
     }
-    get id() {
-        return PlaceLayerFeaturesCommand.ID;
-    }
-}
-PlaceLayerFeaturesCommand.ID = '8caf86bc-869b-426f-b36d-4642f6b8aab0';
+}
 
 class RemoveLayerCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveLayerCommand.ID;
-    }
-}
-RemoveLayerCommand.ID = 'ab484e0e-e185-45cd-8434-12101f3c7eb1';
+}
 
 class AddTileCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddTileCommand.ID;
-    }
-}
-AddTileCommand.ID = '25b7df28-72ce-4453-9fe6-54285a2fdc57';
+}
 
 class RemoveTileCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveTileCommand.ID;
-    }
-}
-RemoveTileCommand.ID = 'c36ccc0b-5638-4819-b148-2de57a59a5b7';
+}
 
 class FitToFeaturesCommand extends PostboyGenericMessage {
     constructor(features, zoomAfter = 0) {
@@ -508,32 +630,17 @@ class FitToFeaturesCommand extends PostboyGenericMessage {
         this.features = features;
         this.zoomAfter = zoomAfter;
     }
-    get id() {
-        return FitToFeaturesCommand.ID;
-    }
-}
-FitToFeaturesCommand.ID = '76cdc091-3793-4b6c-82f7-1e0334cf08a8';
+}
 
 class GetLayerQuery extends PostboyCallbackMessage {
     constructor(name) {
         super();
         this.name = name;
     }
-    get id() {
-        return GetLayerQuery.ID;
-    }
-}
-GetLayerQuery.ID = '5c04c87b-8a93-4c2a-979e-d1e313d860ed';
+}
 
 class DrawingFinishedEvent extends PostboyGenericMessage {
-    constructor() {
-        super();
-    }
-    get id() {
-        return DrawingFinishedEvent.ID;
-    }
-}
-DrawingFinishedEvent.ID = 'c724b68e-b4eb-4783-90f1-a8e31973fd36';
+}
 
 class DrawingGenerationService {
     static getDraw(ev) {
@@ -588,22 +695,14 @@ class GenerateDrawExecutor extends PostboyExecutor {
         this.style = style;
         this.type = type;
     }
-    get id() {
-        return GenerateDrawExecutor.ID;
-    }
-}
-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) {
@@ -620,7 +719,11 @@ class ZoomControlFactory {
 class MapPostboyService extends PostboyService {
     constructor() {
         super();
-        this.addLocker({ locker: StartDrawingCommand.ID, unlocker: DrawingFinishedEvent.ID, locking: [MapClickEvent.ID] });
+        this.addLocker({
+            locker: StartDrawingCommand.name,
+            unlocker: DrawingFinishedEvent.name,
+            locking: [MapClickEvent.name],
+        });
     }
 }
 MapPostboyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MapPostboyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -646,29 +749,29 @@ class MapManagementService {
         this.observeFeaturesInPoint();
     }
     observeRemoveTile() {
-        this.postboy.subscribe(RemoveTileCommand.ID).subscribe((c) => {
+        this.postboy.sub(RemoveTileCommand).subscribe((c) => {
             if (!this.map)
                 return;
             this.map.removeLayer(c.layer);
         });
     }
     observeLayerQuery() {
-        this.postboy.subscribe(GetLayerQuery.ID).subscribe((ev) => ev.finish(this.layers.take(ev.name)));
+        this.postboy.sub(GetLayerQuery).subscribe((ev) => ev.finish(this.layers.take(ev.name)));
     }
     observeAddTile() {
-        this.postboy.subscribe(AddTileCommand.ID).subscribe((c) => {
+        this.postboy.sub(AddTileCommand).subscribe((c) => {
             if (!this.map)
                 return;
             this.map.addLayer(c.layer);
         });
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
         });
     }
     observeAddLayer() {
-        this.postboy.subscribe(AddLayerCommand.ID).subscribe((c) => {
+        this.postboy.sub(AddLayerCommand).subscribe((c) => {
             if (!this.map)
                 return;
             this.layers.put(c.layer.get('name'), c.layer);
@@ -676,7 +779,7 @@ class MapManagementService {
         });
     }
     observePlaceFeatures() {
-        this.postboy.subscribe(PlaceLayerFeaturesCommand.ID).subscribe((c) => {
+        this.postboy.sub(PlaceLayerFeaturesCommand).subscribe((c) => {
             if (!this.layers.has(c.layer))
                 return;
             let source = this.layers.take(c.layer).getSource();
@@ -687,7 +790,7 @@ class MapManagementService {
         });
     }
     observeRemoveLayer() {
-        this.postboy.subscribe(RemoveLayerCommand.ID).subscribe((c) => {
+        this.postboy.sub(RemoveLayerCommand).subscribe((c) => {
             if (!this.map)
                 return;
             this.layers.rmv(c.layer.get('name'));
@@ -695,20 +798,20 @@ class MapManagementService {
         });
     }
     observeFeaturesInArea() {
-        this.postboy.subscribe(GetFeaturesInAreaQuery.ID).subscribe((qr) => {
+        this.postboy.sub(GetFeaturesInAreaQuery).subscribe((qr) => {
             let result = new Dictionary();
             this.forEachLayer((l, s) => {
-                let features = this.postboy.execute(new FilterFeaturesInAreaExecutor(qr.area, s?.getFeatures() ?? []));
+                let features = this.postboy.exec(new FilterFeaturesInAreaExecutor(qr.area, s?.getFeatures() ?? []));
                 result.put(l.get('name'), features.map((e) => ({ id: e.getId(), ...e.get(MapConstants.FeatureInfo) })));
             }, qr.ignore);
             qr.finish(result);
         });
     }
     observeFeaturesInPoint() {
-        this.postboy.subscribe(GetFeaturesInPointQuery.ID).subscribe((qr) => {
+        this.postboy.sub(GetFeaturesInPointQuery).subscribe((qr) => {
             let result = new Dictionary();
             this.forEachLayer((l, s) => {
-                let features = this.postboy.execute(new FilterFeaturesInPointExecutor(qr.lat, qr.lng, s?.getFeatures() ?? []));
+                let features = this.postboy.exec(new FilterFeaturesInPointExecutor(qr.lat, qr.lng, s?.getFeatures() ?? []));
                 result.put(l.get('name'), features.map((e) => ({ id: e.getId(), ...e.get(MapConstants.FeatureInfo) })));
             }, qr.ignore);
             qr.finish(result);
@@ -750,7 +853,7 @@ class MapStateService {
     }
     observeMapRendering() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((ev) => {
             this.map = ev.map;
@@ -760,7 +863,7 @@ class MapStateService {
         });
     }
     observeCenter() {
-        this.postboy.subscribe(SetMapCenterCommand.ID).subscribe((c) => {
+        this.postboy.sub(SetMapCenterCommand).subscribe((c) => {
             this.map?.getView().setCenter([c.lng, c.lat]);
             if (c.zoom)
                 this.map?.getView().setZoom(c.zoom);
@@ -783,19 +886,19 @@ class MapFeatureService {
         this.observeFitToPolygons();
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
             if (this.fitPolygonsWaiting)
                 this.postboy.fire(this.fitPolygonsWaiting);
         });
     }
     observeFitToFeatures() {
-        this.postboy.subscribe(FitToFeaturesCommand.ID).subscribe((cmd) => {
+        this.postboy.sub(FitToFeaturesCommand).subscribe((cmd) => {
             this.fitToGeometries(cmd.features.map((f) => f.getGeometry()), cmd.zoomAfter);
         });
     }
     observeFitToPolygons() {
-        this.postboy.subscribe(FitToPolygonsCommand.ID).subscribe((cmd) => {
+        this.postboy.sub(FitToPolygonsCommand).subscribe((cmd) => {
             if (!this.map) {
                 this.fitPolygonsWaiting = cmd;
                 return;
@@ -844,7 +947,7 @@ class MapClickService {
         return model;
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
             this.map?.on('singleclick', (e) => {
                 this.postboy.fire(this.onClick(e));
@@ -876,30 +979,26 @@ class DrawingService {
         this.observeMapRender();
     }
     observeSelectArea() {
-        this.postboy.subscribe(DrawSelectionAreaCommand.ID).subscribe((ev) => {
-            const drawingCommand = new StartDrawingCommand(ev.type, ev.style);
-            drawingCommand.result.subscribe((r) => {
+        this.postboy.sub(DrawSelectionAreaCommand).subscribe((ev) => {
+            this.postboy.fireCallback(new StartDrawingCommand(ev.type, ev.style), (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.fireCallback(new GetFeaturesInAreaQuery(area, ev.ignore), (result) => ev.finish(result));
             });
-            this.postboy.fire(drawingCommand);
         });
     }
     observeDrawing() {
-        this.postboy.subscribe(StartDrawingCommand.ID).subscribe((ev) => {
+        this.postboy.sub(StartDrawingCommand).subscribe((ev) => {
             this.draw((l) => {
                 if (!l || !this.map) {
                     this.clearInteraction(l);
                     return;
                 }
                 const cancelSub = this.observeCancelation(ev, l);
-                this.drawInteraction = this.postboy.execute(new GenerateDrawExecutor(l, ev.style, ev.type));
+                this.drawInteraction = this.postboy.exec(new GenerateDrawExecutor(l, ev.style, ev.type));
                 this.map?.addInteraction(this.drawInteraction);
                 this.drawInteraction.on('drawend', (evt) => {
                     cancelSub.unsubscribe();
@@ -915,18 +1014,16 @@ class DrawingService {
         this.clearInteraction(layer);
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
         });
     }
     draw(action) {
-        const query = new GetLayerQuery(MapConstants.DrawingLayerId);
-        query.result.subscribe((l) => action(l));
-        this.postboy.fire(query);
+        this.postboy.fireCallback(new GetLayerQuery(MapConstants.DrawingLayerId), (l) => action(l));
     }
     observeCancelation(ev, layer) {
         return this.postboy
-            .subscribe(CancelDrawingCommand.ID)
+            .sub(CancelDrawingCommand)
             .pipe(first())
             .subscribe(() => {
             ev.finish(null);
@@ -956,7 +1053,7 @@ class FeatureModificationService {
         this.observeMapRender();
     }
     observeModification() {
-        this.postboy.subscribe(ModifyFeatureCommand.ID).subscribe((ev) => {
+        this.postboy.sub(ModifyFeatureCommand).subscribe((ev) => {
             this.defineLayer((l) => {
                 if (!l || !this.map) {
                     this.clearInteraction(l);
@@ -1002,18 +1099,16 @@ class FeatureModificationService {
             : new WKT().writeFeature(command.model.feature));
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
         });
     }
     defineLayer(action) {
-        const query = new GetLayerQuery(MapConstants.DrawingLayerId);
-        query.result.subscribe((l) => action(l));
-        this.postboy.fire(query);
+        this.postboy.fireCallback(new GetLayerQuery(MapConstants.DrawingLayerId), (l) => action(l));
     }
     observeCancelation(ev, layer) {
         return this.postboy
-            .subscribe(CancelFeatureModificationCommand.ID)
+            .sub(CancelFeatureModificationCommand)
             .pipe(first())
             .subscribe(() => {
             ev.finish(null);
@@ -1042,7 +1137,7 @@ class ControlsService {
     }
     observeMapRender() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((m) => {
             this.map = m.map;
@@ -1051,12 +1146,10 @@ class ControlsService {
         });
     }
     observeAdding() {
-        this.postboy.subscribe(AddControlCommand.ID).subscribe((c) => this.map?.addControl(c.item));
+        this.postboy.sub(AddControlCommand).subscribe((c) => this.map?.addControl(c.item));
     }
     observeRemoving() {
-        this.postboy
-            .subscribe(RemoveControlCommand.ID)
-            .subscribe((c) => this.map?.removeControl(c.item));
+        this.postboy.sub(RemoveControlCommand).subscribe((c) => this.map?.removeControl(c.item));
     }
 }
 ControlsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlsService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -1072,38 +1165,38 @@ class MessageRegistratorService extends PostboyAbstractRegistrator {
         this.registerServices([management, state, interaction, mapFeature, drawing, featureModification, controls]);
     }
     _up() {
-        this.registerReplay(MapRenderedEvent.ID);
-        this.registerReplay(PlaceLayerFeaturesCommand.ID);
-        this.registerReplay(RemoveControlCommand.ID);
-        this.registerReplay(AddControlCommand.ID);
-        this.registerReplay(SetMapCenterCommand.ID);
-        this.registerSubject(AddLayerCommand.ID);
-        this.registerSubject(RemoveLayerCommand.ID);
-        this.registerSubject(AddTileCommand.ID);
-        this.registerSubject(RemoveTileCommand.ID);
-        this.registerSubject(MapClickEvent.ID);
-        this.registerSubject(CloseTooltipCommand.ID);
-        this.registerSubject(FitToFeaturesCommand.ID);
-        this.registerSubject(FitToPolygonsCommand.ID);
-        this.registerSubject(MapMoveEndEvent.ID);
-        this.registerSubject(CancelDrawingCommand.ID);
-        this.registerSubject(StartDrawingCommand.ID);
-        this.registerSubject(GetLayerQuery.ID);
-        this.registerSubject(DrawingFinishedEvent.ID);
-        this.registerSubject(GetFeaturesInAreaQuery.ID);
-        this.registerSubject(DrawSelectionAreaCommand.ID);
-        this.registerSubject(CancelFeatureModificationCommand.ID);
-        this.registerSubject(ModifyFeatureCommand.ID);
-        this.registerSubject(GetFeaturesInPointQuery.ID);
+        this.recordReplay(MapRenderedEvent);
+        this.recordReplay(PlaceLayerFeaturesCommand);
+        this.recordReplay(RemoveControlCommand);
+        this.recordReplay(AddControlCommand);
+        this.recordReplay(SetMapCenterCommand);
+        this.recordSubject(AddLayerCommand);
+        this.recordSubject(RemoveLayerCommand);
+        this.recordSubject(AddTileCommand);
+        this.recordSubject(RemoveTileCommand);
+        this.recordSubject(MapClickEvent);
+        this.recordSubject(CloseTooltipCommand);
+        this.recordSubject(FitToFeaturesCommand);
+        this.recordSubject(FitToPolygonsCommand);
+        this.recordSubject(MapMoveEndEvent);
+        this.recordSubject(CancelDrawingCommand);
+        this.recordSubject(StartDrawingCommand);
+        this.recordSubject(GetLayerQuery);
+        this.recordSubject(DrawingFinishedEvent);
+        this.recordSubject(GetFeaturesInAreaQuery);
+        this.recordSubject(DrawSelectionAreaCommand);
+        this.recordSubject(CancelFeatureModificationCommand);
+        this.recordSubject(ModifyFeatureCommand);
+        this.recordSubject(GetFeaturesInPointQuery);
         this.setExecutors();
     }
     setExecutors() {
-        this.registerExecutor(FilterFeaturesInAreaExecutor.ID, (e) => FeatureService.filterFeaturesInArea(e));
-        this.registerExecutor(FilterFeaturesInPointExecutor.ID, (e) => FeatureService.filterFeaturesInPoint(e));
-        this.registerExecutor(CalculateAreaExecutor.ID, (e) => FeatureService.calculateArea(e.polygon?.feature?.getGeometry()));
-        this.registerExecutor(GenerateDrawExecutor.ID, (e) => DrawingGenerationService.getDraw(e));
-        this.registerExecutor(GenerateZoomControlExecutor.ID, (e) => ZoomControlFactory.build(e.settings));
-        this.registerExecutor(GetMapPositionExecutor.ID, () => this.state.getMapPosition());
+        this.recordExecutor(FilterFeaturesInAreaExecutor, (e) => FeatureService.filterFeaturesInArea(e));
+        this.recordExecutor(FilterFeaturesInPointExecutor, (e) => FeatureService.filterFeaturesInPoint(e));
+        this.recordExecutor(CalculateAreaExecutor, (e) => FeatureService.calculateArea(e.polygon?.feature?.getGeometry()));
+        this.recordExecutor(GenerateDrawExecutor, (e) => DrawingGenerationService.getDraw(e));
+        this.recordExecutor(GenerateZoomControlExecutor, (e) => ZoomControlFactory.build(e.settings));
+        this.recordExecutor(GetMapPositionExecutor, () => this.state.getMapPosition());
     }
 }
 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 }, { token: ControlsService }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -1332,7 +1425,7 @@ class TileLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1555,7 +1648,7 @@ class FeatureLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1733,14 +1826,14 @@ class ClusterLayerManager {
     }
     observeMapMovement() {
         combineLatest([
-            this.postboy.subscribe(MapMoveEndEvent.ID).pipe(auditTime(250)),
-            this.postboy.subscribe(MapRenderedEvent.ID),
+            this.postboy.sub(MapMoveEndEvent).pipe(auditTime(250)),
+            this.postboy.sub(MapRenderedEvent),
         ]).subscribe(([movement, renderEvent]) => {
             this.checkClusterNecessity(renderEvent.map);
         });
     }
     observeClick() {
-        this.postboy.subscribe(MapClickEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapClickEvent).subscribe((m) => {
             if ((m.features[this.settings.name]?.length ?? 0) > 1) {
                 this.postboy.fire(new FitToFeaturesCommand(m.features[this.settings.name], -1));
             }
@@ -1828,7 +1921,7 @@ class ClusterLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1969,7 +2062,7 @@ class MarkersComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putMarkers());
     }
@@ -2058,18 +2151,18 @@ class TooltipComponent extends DestructibleComponent {
         this.detector.detectChanges();
     }
     observeMapClick() {
-        return this.postboy.subscribe(MapClickEvent.ID).subscribe((ev) => {
+        return this.postboy.sub(MapClickEvent).subscribe((ev) => {
             this._settings.show(ev) ? this.addOverlay(ev.coordinates) : this.removeOverlay();
         });
     }
     observeClose() {
         return this.postboy
-            .subscribe(CloseTooltipCommand.ID)
+            .sub(CloseTooltipCommand)
             .pipe(filter((ev) => ev.tooltipId === this._settings.id))
             .subscribe(() => this.removeOverlay());
     }
     observeMapRender() {
-        return this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        return this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             this.map = m.map;
         });
     }
@@ -2109,7 +2202,7 @@ class PolygonsComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putPolygons());
     }
@@ -2283,7 +2376,7 @@ class MapControlZoomComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => {
             this.map = m.map;
@@ -2293,7 +2386,7 @@ class MapControlZoomComponent extends DestructibleComponent {
     setControl() {
         if (!this.map)
             return;
-        this.control = this.postboy.execute(new GenerateZoomControlExecutor(this._settings));
+        this.control = this.postboy.exec(new GenerateZoomControlExecutor(this._settings));
         this.map.addControl(this.control);
     }
 }