@artstesh/maps 1.1.13 → 1.1.16

package/dist/fesm2015/maps-components.js

@@ -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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, 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;
@@ -181,6 +227,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";
@@ -189,6 +248,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";
@@ -209,126 +276,137 @@ 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';
+AddControlCommand.ID = '2921fb19-f1c4-4bf4-97be-001f98241f3b';
 
+/**
+ * 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';
+CloseTooltipCommand.ID = 'df687e26-7298-46d7-8911-d014801dafac';
 
+/**
+ * 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';
+StartDrawingCommand.ID = '4407e9ee-d6c3-4e77-8000-c1aae7433fb6';
 
+/**
+ * Represents a command to cancel a drawing action.
+ */
 class CancelDrawingCommand extends PostboyGenericMessage {
-    get id() {
-        return CancelDrawingCommand.ID;
-    }
 }
-CancelDrawingCommand.ID = '7d38d983-feba-4176-a66b-18175e5ecd6b';
+CancelDrawingCommand.ID = '192d70f8-9d12-4cb3-a8ad-0fc2dc5af1de';
 
+/**
+ * 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';
+DrawSelectionAreaCommand.ID = '06e43f59-c6ba-41bb-9c5b-f6534d914905';
 
+/**
+ * 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';
+ModifyFeatureCommand.ID = '8f76507e-f18d-4232-bab7-f3d4e3d707bb';
 
+/**
+ * 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';
+CancelFeatureModificationCommand.ID = 'e7886353-53b3-4bbe-93b5-6490e5f1305e';
 
+/**
+ * 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';
+RemoveControlCommand.ID = '73bcb4f5-ce7d-4c71-b70d-e772100136a1';
 
 /**
  * Forces map to move to a specific point
@@ -346,34 +424,136 @@ class SetMapCenterCommand extends PostboyGenericMessage {
         this.lng = lng;
         this.zoom = zoom;
     }
-    get id() {
-        return SetMapCenterCommand.ID;
+}
+SetMapCenterCommand.ID = 'd4e3cf4f-0be7-4c1a-8355-8607d02c3dea';
+
+/**
+ * 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';
+FitToPolygonsCommand.ID = '308394ce-48d3-45f5-8671-52207fba4be3';
 
-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;
+}
+MapRenderedEvent.ID = '4515dde8-1519-4e3f-a0e3-10d3c52deabe';
+
+/**
+ * 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';
+MapClickEvent.ID = 'ee31a86c-e838-4531-8399-983753a354df';
 
-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;
+    }
+}
+MapMoveEndEvent.ID = 'd210ec7e-032f-4ce8-8a39-7b816519eaae';
+
+/**
+ * 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;
+    }
+}
+FilterFeaturesInPointExecutor.ID = 'dcbb156d-def3-45b4-91af-84d1483d8941';
+
+/**
+ * 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;
-        this.zoomAfter = zoomAfter;
     }
-    get id() {
-        return FitToPolygonsCommand.ID;
+}
+FilterFeaturesInAreaExecutor.ID = '4d26e1e3-e60f-4e49-804b-5b3eadc2adce';
+
+/**
+ * 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;
     }
 }
-FitToPolygonsCommand.ID = 'a9e42b23-ffaf-4c46-8370-e0432cd14d60';
+CalculateAreaExecutor.ID = '82347b8c-7635-45ec-85ef-75aaf43bc34c';
 
 /**
  * A message that allows to get the current state of the map.
@@ -384,79 +564,56 @@ class GetMapPositionExecutor extends PostboyExecutor {
     constructor() {
         super();
     }
-    get id() {
-        return GetMapPositionExecutor.ID;
-    }
 }
 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';
+GetFeaturesInAreaQuery.ID = '317cf427-a029-4a43-97c4-cb6b8148ff65';
 
 /**
  * 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 {
-    constructor(lat, lng, features) {
-        super();
-        this.lat = lat;
-        this.lng = lng;
-        this.features = features;
-    }
-    get id() {
-        return FilterFeaturesInPointExecutor.ID;
-    }
-}
-FilterFeaturesInPointExecutor.ID = '5b859282-5d5a-47ca-a6ad-863a66c8b82b';
+GetFeaturesInPointQuery.ID = '99bbc56f-34a2-4064-8300-13bb3d0662c1';
 
 class AddLayerCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddLayerCommand.ID;
-    }
 }
-AddLayerCommand.ID = 'd93e250f-92bc-43ac-9c6a-46c521a1aaa5';
+AddLayerCommand.ID = '7fe68d71-350f-47e2-b1ae-62cc333e1572';
 
 class PlaceLayerFeaturesCommand extends PostboyGenericMessage {
     constructor(layer, features) {
@@ -464,44 +621,32 @@ class PlaceLayerFeaturesCommand extends PostboyGenericMessage {
         this.layer = layer;
         this.features = features;
     }
-    get id() {
-        return PlaceLayerFeaturesCommand.ID;
-    }
 }
-PlaceLayerFeaturesCommand.ID = '8caf86bc-869b-426f-b36d-4642f6b8aab0';
+PlaceLayerFeaturesCommand.ID = '5f27a2cd-8d8a-4929-b703-8aee6dcdc21c';
 
 class RemoveLayerCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveLayerCommand.ID;
-    }
 }
-RemoveLayerCommand.ID = 'ab484e0e-e185-45cd-8434-12101f3c7eb1';
+RemoveLayerCommand.ID = '1b60599c-599a-4fdb-bad2-23b12e435e1a';
 
 class AddTileCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddTileCommand.ID;
-    }
 }
-AddTileCommand.ID = '25b7df28-72ce-4453-9fe6-54285a2fdc57';
+AddTileCommand.ID = 'ae29b7af-21aa-4b0a-8586-92c23779e6cb';
 
 class RemoveTileCommand extends PostboyGenericMessage {
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveTileCommand.ID;
-    }
 }
-RemoveTileCommand.ID = 'c36ccc0b-5638-4819-b148-2de57a59a5b7';
+RemoveTileCommand.ID = 'dab0f861-bb25-46da-9388-717bfaae798f';
 
 class FitToFeaturesCommand extends PostboyGenericMessage {
     constructor(features, zoomAfter = 0) {
@@ -509,32 +654,20 @@ class FitToFeaturesCommand extends PostboyGenericMessage {
         this.features = features;
         this.zoomAfter = zoomAfter;
     }
-    get id() {
-        return FitToFeaturesCommand.ID;
-    }
 }
-FitToFeaturesCommand.ID = '76cdc091-3793-4b6c-82f7-1e0334cf08a8';
+FitToFeaturesCommand.ID = '04d67609-0b4c-4f52-aa53-ad0a3db967dc';
 
 class GetLayerQuery extends PostboyCallbackMessage {
     constructor(name) {
         super();
         this.name = name;
     }
-    get id() {
-        return GetLayerQuery.ID;
-    }
 }
-GetLayerQuery.ID = '5c04c87b-8a93-4c2a-979e-d1e313d860ed';
+GetLayerQuery.ID = 'd2683490-2aa2-4dee-855d-f752ce4d3be5';
 
 class DrawingFinishedEvent extends PostboyGenericMessage {
-    constructor() {
-        super();
-    }
-    get id() {
-        return DrawingFinishedEvent.ID;
-    }
 }
-DrawingFinishedEvent.ID = 'c724b68e-b4eb-4783-90f1-a8e31973fd36';
+DrawingFinishedEvent.ID = '9094e160-8df7-4868-883a-3436724106dd';
 
 class DrawingGenerationService {
     static getDraw(ev) {
@@ -589,22 +722,16 @@ class GenerateDrawExecutor extends PostboyExecutor {
         this.style = style;
         this.type = type;
     }
-    get id() {
-        return GenerateDrawExecutor.ID;
-    }
 }
-GenerateDrawExecutor.ID = 'f01c99ba-0953-4ab5-82f9-04e6fbb678c1';
+GenerateDrawExecutor.ID = '5d5f0737-ff70-461e-9a2e-bf6166c914cb';
 
 class GenerateZoomControlExecutor extends PostboyExecutor {
     constructor(settings) {
         super();
         this.settings = settings;
     }
-    get id() {
-        return GenerateZoomControlExecutor.ID;
-    }
 }
-GenerateZoomControlExecutor.ID = 'ff16a833-c68e-4b1a-bc23-c0d16b002810';
+GenerateZoomControlExecutor.ID = 'c59f4fc3-ccf6-4cb3-a38b-3a8c249114a2';
 
 class ZoomControlFactory {
     static build(settings) {
@@ -621,7 +748,11 @@ class ZoomControlFactory {
 class MapPostboyService extends PostboyService {
     constructor() {
         super();
-        this.addLocker({ locker: StartDrawingCommand.ID, unlocker: DrawingFinishedEvent.ID, locking: [MapClickEvent.ID] });
+        this.addLocker({
+            locker: StartDrawingCommand.ID,
+            unlocker: DrawingFinishedEvent.ID,
+            locking: [MapClickEvent.ID],
+        });
     }
 }
 MapPostboyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPostboyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -647,29 +778,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);
@@ -677,7 +808,7 @@ class MapManagementService {
         });
     }
     observePlaceFeatures() {
-        this.postboy.subscribe(PlaceLayerFeaturesCommand.ID).subscribe((c) => {
+        this.postboy.sub(PlaceLayerFeaturesCommand).subscribe((c) => {
             var _a, _b;
             if (!this.layers.has(c.layer))
                 return;
@@ -689,7 +820,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'));
@@ -697,22 +828,22 @@ class MapManagementService {
         });
     }
     observeFeaturesInArea() {
-        this.postboy.subscribe(GetFeaturesInAreaQuery.ID).subscribe((qr) => {
+        this.postboy.sub(GetFeaturesInAreaQuery).subscribe((qr) => {
             let result = new Dictionary();
             this.forEachLayer((l, s) => {
                 var _a;
-                let features = this.postboy.execute(new FilterFeaturesInAreaExecutor(qr.area, (_a = s === null || s === void 0 ? void 0 : s.getFeatures()) !== null && _a !== void 0 ? _a : []));
+                let features = this.postboy.exec(new FilterFeaturesInAreaExecutor(qr.area, (_a = s === null || s === void 0 ? void 0 : s.getFeatures()) !== null && _a !== void 0 ? _a : []));
                 result.put(l.get('name'), features.map((e) => (Object.assign({ 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) => {
                 var _a;
-                let features = this.postboy.execute(new FilterFeaturesInPointExecutor(qr.lat, qr.lng, (_a = s === null || s === void 0 ? void 0 : s.getFeatures()) !== null && _a !== void 0 ? _a : []));
+                let features = this.postboy.exec(new FilterFeaturesInPointExecutor(qr.lat, qr.lng, (_a = s === null || s === void 0 ? void 0 : s.getFeatures()) !== null && _a !== void 0 ? _a : []));
                 result.put(l.get('name'), features.map((e) => (Object.assign({ id: e.getId() }, e.get(MapConstants.FeatureInfo)))));
             }, qr.ignore);
             qr.finish(result);
@@ -755,7 +886,7 @@ class MapStateService {
     }
     observeMapRendering() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((ev) => {
             var _a;
@@ -766,7 +897,7 @@ class MapStateService {
         });
     }
     observeCenter() {
-        this.postboy.subscribe(SetMapCenterCommand.ID).subscribe((c) => {
+        this.postboy.sub(SetMapCenterCommand).subscribe((c) => {
             var _a, _b;
             (_a = this.map) === null || _a === void 0 ? void 0 : _a.getView().setCenter([c.lng, c.lat]);
             if (c.zoom)
@@ -790,19 +921,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;
@@ -852,7 +983,7 @@ class MapClickService {
         return model;
     }
     observeMapRender() {
-        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+        this.postboy.sub(MapRenderedEvent).subscribe((m) => {
             var _a;
             this.map = m.map;
             (_a = this.map) === null || _a === void 0 ? void 0 : _a.on('singleclick', (e) => {
@@ -885,23 +1016,19 @@ 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) => {
                 var _a;
                 if (!l || !this.map) {
@@ -909,7 +1036,7 @@ class DrawingService {
                     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));
                 (_a = this.map) === null || _a === void 0 ? void 0 : _a.addInteraction(this.drawInteraction);
                 this.drawInteraction.on('drawend', (evt) => {
                     cancelSub.unsubscribe();
@@ -925,18 +1052,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);
@@ -967,7 +1092,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);
@@ -1017,18 +1142,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);
@@ -1058,7 +1181,7 @@ class ControlsService {
     }
     observeMapRender() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((m) => {
             this.map = m.map;
@@ -1067,12 +1190,10 @@ class ControlsService {
         });
     }
     observeAdding() {
-        this.postboy.subscribe(AddControlCommand.ID).subscribe((c) => { var _a; return (_a = this.map) === null || _a === void 0 ? void 0 : _a.addControl(c.item); });
+        this.postboy.sub(AddControlCommand).subscribe((c) => { var _a; return (_a = this.map) === null || _a === void 0 ? void 0 : _a.addControl(c.item); });
     }
     observeRemoving() {
-        this.postboy
-            .subscribe(RemoveControlCommand.ID)
-            .subscribe((c) => { var _a; return (_a = this.map) === null || _a === void 0 ? void 0 : _a.removeControl(c.item); });
+        this.postboy.sub(RemoveControlCommand).subscribe((c) => { var _a; return (_a = this.map) === null || _a === void 0 ? void 0 : _a.removeControl(c.item); });
     }
 }
 ControlsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ControlsService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
@@ -1088,38 +1209,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) => { var _a, _b; return FeatureService.calculateArea((_b = (_a = e.polygon) === null || _a === void 0 ? void 0 : _a.feature) === null || _b === void 0 ? void 0 : _b.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) => { var _a, _b; return FeatureService.calculateArea((_b = (_a = e.polygon) === null || _a === void 0 ? void 0 : _a.feature) === null || _b === void 0 ? void 0 : _b.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: "12.2.17", 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 });
@@ -1348,7 +1469,7 @@ class TileLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1582,7 +1703,7 @@ class FeatureLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1765,14 +1886,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) => {
             var _a, _b;
             if (((_b = (_a = m.features[this.settings.name]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 1) {
                 this.postboy.fire(new FitToFeaturesCommand(m.features[this.settings.name], -1));
@@ -1863,7 +1984,7 @@ class ClusterLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -2016,7 +2137,7 @@ class MarkersComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putMarkers());
     }
@@ -2113,18 +2234,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;
         });
     }
@@ -2169,7 +2290,7 @@ class PolygonsComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putPolygons());
     }
@@ -2348,7 +2469,7 @@ class MapControlZoomComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => {
             this.map = m.map;
@@ -2358,7 +2479,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);
     }
 }