@artstesh/maps 6.0.7 → 6.0.9

package/dist/fesm2022/maps-components.mjs

@@ -64,6 +64,10 @@ class MapLyrsLabel {
     }
 }
 
+/**
+ * Represents the configurable settings for a map instance, providing
+ * options for center coordinates, zoom levels, map layers, and language.
+ */
 class MapSettings {
     center = [0, 0];
     maxZoom = 19;
@@ -81,24 +85,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;
@@ -187,6 +233,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";
@@ -195,6 +254,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";
@@ -215,142 +282,148 @@ class MapControl extends Control {
     }
 }
 
-class MapRenderedEvent extends PostboyGenericMessage {
-    map;
-    static ID = 'b6121807-3b89-4cd3-82cf-089d2cefdc4f';
-    constructor(map) {
-        super();
-        this.map = map;
-    }
-    get id() {
-        return MapRenderedEvent.ID;
-    }
-}
-
-class MapClickEvent extends PostboyGenericMessage {
-    coordinates;
-    entities;
-    features;
-    static ID = '323df526-8d9c-49c6-83e8-6e9a1e7762f7';
-    constructor(coordinates, entities, features) {
-        super();
-        this.coordinates = coordinates;
-        this.entities = entities;
-        this.features = features;
-    }
-    get id() {
-        return MapClickEvent.ID;
-    }
-}
-
-class MapMoveEndEvent extends PostboyGenericMessage {
-    position;
-    static ID = 'f21f783e-b5af-4489-9fec-8027fd07a8ad';
-    constructor(position) {
+/**
+ * Represents a command to add a custom control to a map.
+ */
+class AddControlCommand extends PostboyGenericMessage {
+    item;
+    static ID = '2921fb19-f1c4-4bf4-97be-001f98241f3b';
+    /**
+     * 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;
     }
 }
 
+/**
+ * A command class that represents the action to close a tooltip.
+ */
 class CloseTooltipCommand extends PostboyGenericMessage {
     tooltipId;
-    static ID = '4896d52c-e34f-4994-bcfd-32832d12dbe4';
+    static ID = 'df687e26-7298-46d7-8911-d014801dafac';
+    /**
+     * 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;
-    }
 }
 
+/**
+ * Represents a command to start a drawing operation.
+ */
 class StartDrawingCommand extends PostboyCallbackMessage {
     type;
     style;
     format;
-    static ID = 'da904f4b-a1c8-4db7-a6af-14d9ee18ec8c';
+    static ID = '4407e9ee-d6c3-4e77-8000-c1aae7433fb6';
+    /**
+     * 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;
-    }
 }
 
+/**
+ * Represents a command to cancel a drawing action.
+ */
 class CancelDrawingCommand extends PostboyGenericMessage {
-    static ID = '7d38d983-feba-4176-a66b-18175e5ecd6b';
-    get id() {
-        return CancelDrawingCommand.ID;
-    }
+    static 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 {
     type;
     style;
     ignore;
-    static ID = '573d8a0d-f25b-42b7-9ad7-0ac6d86ac362';
+    static ID = '06e43f59-c6ba-41bb-9c5b-f6534d914905';
+    /**
+     * 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;
-    }
 }
 
+/**
+ * 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 {
     model;
     style;
     format;
-    static ID = 'ead85caa-24c6-4844-a68c-2cea91774c8c';
+    static ID = '8f76507e-f18d-4232-bab7-f3d4e3d707bb';
+    /**
+     * 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;
-    }
 }
 
+/**
+ * Represents a command to cancel a feature modification.
+ */
 class CancelFeatureModificationCommand extends PostboyGenericMessage {
-    static ID = '9c9fb40f-ea95-4704-8177-0e9ecabf36fa';
-    get id() {
-        return CancelFeatureModificationCommand.ID;
-    }
-}
-
-class AddControlCommand extends PostboyGenericMessage {
-    item;
-    static ID = '8e1c06eb-b395-4fe1-929c-ebf0805eeb49';
-    constructor(item) {
-        super();
-        this.item = item;
-    }
-    get id() {
-        return AddControlCommand.ID;
-    }
+    static 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 {
     item;
-    static ID = '361641e0-804a-4930-8c27-0cea6330dbfc';
+    static ID = '73bcb4f5-ce7d-4c71-b70d-e772100136a1';
+    /**
+     * 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;
-    }
 }
 
 /**
@@ -360,7 +433,7 @@ class SetMapCenterCommand extends PostboyGenericMessage {
     lat;
     lng;
     zoom;
-    static ID = 'd50e89c9-6707-4f8c-ab57-65fcef232182';
+    static ID = 'd4e3cf4f-0be7-4c1a-8355-8607d02c3dea';
     /**
      *
      * @param lat - the desired latitude
@@ -373,215 +446,275 @@ class SetMapCenterCommand extends PostboyGenericMessage {
         this.lng = lng;
         this.zoom = zoom;
     }
-    get id() {
-        return SetMapCenterCommand.ID;
-    }
-}
-
-class CalculateAreaExecutor extends PostboyExecutor {
-    polygon;
-    static ID = '172ecf46-86b5-4f46-a5f1-96ba2cbb1694';
-    constructor(polygon) {
-        super();
-        this.polygon = polygon;
-    }
-    get id() {
-        return CalculateAreaExecutor.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 {
     features;
     zoomAfter;
-    static ID = 'a9e42b23-ffaf-4c46-8370-e0432cd14d60';
+    static ID = '308394ce-48d3-45f5-8671-52207fba4be3';
+    /**
+     * 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;
     }
-    get id() {
-        return FitToPolygonsCommand.ID;
-    }
 }
 
 /**
- * A message that allows to get the current state of the map.
- * If the map's state is not defined yet, the executor would return null
- * @returns {MapPosition | null}
+ * Represents an event triggered when a map rendering process is completed.
  */
-class GetMapPositionExecutor extends PostboyExecutor {
-    static ID = '52c95689-d09b-4082-ba58-9183ea96a213';
-    get id() {
-        return GetMapPositionExecutor.ID;
+class MapRenderedEvent extends PostboyGenericMessage {
+    map;
+    static ID = '4515dde8-1519-4e3f-a0e3-10d3c52deabe';
+    /**
+     * Constructor for creating an instance of the class.
+     *
+     * @param {Map} map - The map instance to be used by the class.
+     */
+    constructor(map) {
+        super();
+        this.map = map;
     }
-    constructor() {
+}
+
+/**
+ * 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 {
+    coordinates;
+    entities;
+    features;
+    static ID = 'ee31a86c-e838-4531-8399-983753a354df';
+    /**
+     * 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;
     }
 }
 
-class GetFeaturesInAreaQuery extends PostboyCallbackMessage {
-    area;
-    ignore;
-    static ID = 'efcf4271-a07a-40e0-9f02-d4dade40b8ac';
-    constructor(area, ignore = new Set()) {
+/**
+ * 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 {
+    position;
+    static ID = 'd210ec7e-032f-4ce8-8a39-7b816519eaae';
+    constructor(position) {
         super();
-        this.area = area;
-        this.ignore = ignore;
+        this.position = position;
     }
-    get id() {
-        return GetFeaturesInAreaQuery.ID;
+}
+
+/**
+ * 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 {
+    lat;
+    lng;
+    features;
+    static ID = 'dcbb156d-def3-45b4-91af-84d1483d8941';
+    /**
+     * 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;
     }
 }
 
+/**
+ * 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 {
     area;
     features;
-    static ID = '36bb2d94-8028-4512-90dd-2386af3fc67c';
+    static ID = '4d26e1e3-e60f-4e49-804b-5b3eadc2adce';
     constructor(area, features) {
         super();
         this.area = area;
         this.features = features;
     }
-    get id() {
-        return FilterFeaturesInAreaExecutor.ID;
+}
+
+/**
+ * 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 {
+    polygon;
+    static ID = '82347b8c-7635-45ec-85ef-75aaf43bc34c';
+    constructor(polygon) {
+        super();
+        this.polygon = polygon;
     }
 }
 
 /**
- * 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.
+ * A message that allows to get the current state of the map.
+ * If the map's state is not defined yet, the executor would return null
+ * @returns {MapPosition | null}
  */
-class GetFeaturesInPointQuery extends PostboyCallbackMessage {
-    lat;
-    lng;
+class GetMapPositionExecutor extends PostboyExecutor {
+    static ID = '52c95689-d09b-4082-ba58-9183ea96a213';
+    constructor() {
+        super();
+    }
+}
+
+/**
+ * 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 {
+    area;
     ignore;
-    static ID = '7c051c97-bbf1-47eb-baa3-4d1eef6f281f';
-    constructor(lat, lng, ignore = new Set()) {
+    static ID = '317cf427-a029-4a43-97c4-cb6b8148ff65';
+    /**
+     * 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.lat = lat;
-        this.lng = lng;
+        this.area = area;
         this.ignore = ignore;
     }
-    get id() {
-        return GetFeaturesInPointQuery.ID;
-    }
 }
 
 /**
- * The FilterFeaturesInPointExecutor class is responsible for filtering features within a given point.
+ * 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 FilterFeaturesInPointExecutor extends PostboyExecutor {
+class GetFeaturesInPointQuery extends PostboyCallbackMessage {
     lat;
     lng;
-    features;
-    static ID = '5b859282-5d5a-47ca-a6ad-863a66c8b82b';
-    get id() {
-        return FilterFeaturesInPointExecutor.ID;
-    }
-    constructor(lat, lng, features) {
+    ignore;
+    static ID = '99bbc56f-34a2-4064-8300-13bb3d0662c1';
+    /**
+     * 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.features = features;
+        this.ignore = ignore;
     }
 }
 
 class AddLayerCommand extends PostboyGenericMessage {
     layer;
-    static ID = 'd93e250f-92bc-43ac-9c6a-46c521a1aaa5';
+    static ID = '7fe68d71-350f-47e2-b1ae-62cc333e1572';
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddLayerCommand.ID;
-    }
 }
 
 class PlaceLayerFeaturesCommand extends PostboyGenericMessage {
     layer;
     features;
-    static ID = '8caf86bc-869b-426f-b36d-4642f6b8aab0';
+    static ID = '5f27a2cd-8d8a-4929-b703-8aee6dcdc21c';
     constructor(layer, features) {
         super();
         this.layer = layer;
         this.features = features;
     }
-    get id() {
-        return PlaceLayerFeaturesCommand.ID;
-    }
 }
 
 class RemoveLayerCommand extends PostboyGenericMessage {
     layer;
-    static ID = 'ab484e0e-e185-45cd-8434-12101f3c7eb1';
+    static ID = '1b60599c-599a-4fdb-bad2-23b12e435e1a';
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveLayerCommand.ID;
-    }
 }
 
 class AddTileCommand extends PostboyGenericMessage {
     layer;
-    static ID = '25b7df28-72ce-4453-9fe6-54285a2fdc57';
+    static ID = 'ae29b7af-21aa-4b0a-8586-92c23779e6cb';
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return AddTileCommand.ID;
-    }
 }
 
 class RemoveTileCommand extends PostboyGenericMessage {
     layer;
-    static ID = 'c36ccc0b-5638-4819-b148-2de57a59a5b7';
+    static ID = 'dab0f861-bb25-46da-9388-717bfaae798f';
     constructor(layer) {
         super();
         this.layer = layer;
     }
-    get id() {
-        return RemoveTileCommand.ID;
-    }
 }
 
 class FitToFeaturesCommand extends PostboyGenericMessage {
     features;
     zoomAfter;
-    static ID = '76cdc091-3793-4b6c-82f7-1e0334cf08a8';
+    static ID = '04d67609-0b4c-4f52-aa53-ad0a3db967dc';
     constructor(features, zoomAfter = 0) {
         super();
         this.features = features;
         this.zoomAfter = zoomAfter;
     }
-    get id() {
-        return FitToFeaturesCommand.ID;
-    }
 }
 
 class GetLayerQuery extends PostboyCallbackMessage {
     name;
-    static ID = '5c04c87b-8a93-4c2a-979e-d1e313d860ed';
+    static ID = 'd2683490-2aa2-4dee-855d-f752ce4d3be5';
     constructor(name) {
         super();
         this.name = name;
     }
-    get id() {
-        return GetLayerQuery.ID;
-    }
 }
 
 class DrawingFinishedEvent extends PostboyGenericMessage {
-    static ID = 'c724b68e-b4eb-4783-90f1-a8e31973fd36';
-    constructor() {
-        super();
-    }
-    get id() {
-        return DrawingFinishedEvent.ID;
-    }
+    static ID = '9094e160-8df7-4868-883a-3436724106dd';
 }
 
 class DrawingGenerationService {
@@ -634,28 +767,22 @@ class GenerateDrawExecutor extends PostboyExecutor {
     layer;
     style;
     type;
-    static ID = 'f01c99ba-0953-4ab5-82f9-04e6fbb678c1';
+    static ID = '5d5f0737-ff70-461e-9a2e-bf6166c914cb';
     constructor(layer, style, type) {
         super();
         this.layer = layer;
         this.style = style;
         this.type = type;
     }
-    get id() {
-        return GenerateDrawExecutor.ID;
-    }
 }
 
 class GenerateZoomControlExecutor extends PostboyExecutor {
     settings;
-    static ID = 'ff16a833-c68e-4b1a-bc23-c0d16b002810';
+    static ID = 'c59f4fc3-ccf6-4cb3-a38b-3a8c249114a2';
     constructor(settings) {
         super();
         this.settings = settings;
     }
-    get id() {
-        return GenerateZoomControlExecutor.ID;
-    }
 }
 
 class ZoomControlFactory {
@@ -673,7 +800,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],
+        });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.7", ngImport: i0, type: MapPostboyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.7", ngImport: i0, type: MapPostboyService });
@@ -701,29 +832,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);
@@ -731,7 +862,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();
@@ -742,7 +873,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'));
@@ -750,20 +881,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);
@@ -807,7 +938,7 @@ class MapStateService {
     }
     observeMapRendering() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((ev) => {
             this.map = ev.map;
@@ -817,7 +948,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);
@@ -843,19 +974,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;
@@ -906,7 +1037,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));
@@ -941,30 +1072,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();
@@ -980,18 +1107,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);
@@ -1025,7 +1150,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);
@@ -1071,18 +1196,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);
@@ -1113,7 +1236,7 @@ class ControlsService {
     }
     observeMapRender() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(first())
             .subscribe((m) => {
             this.map = m.map;
@@ -1122,12 +1245,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));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.7", ngImport: i0, type: ControlsService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.7", ngImport: i0, type: ControlsService });
@@ -1144,38 +1265,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());
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.7", 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 });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.7", ngImport: i0, type: MessageRegistratorService });
@@ -1404,7 +1525,7 @@ class TileLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1633,7 +1754,7 @@ class FeatureLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -1814,14 +1935,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));
             }
@@ -1910,7 +2031,7 @@ class ClusterLayerComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => this.initLayer());
     }
@@ -2059,7 +2180,7 @@ class MarkersComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putMarkers());
     }
@@ -2150,18 +2271,18 @@ class TooltipComponent extends DestructibleComponent {
         };
     };
     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;
         });
     }
@@ -2206,7 +2327,7 @@ class PolygonsComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe(() => this.putPolygons());
     }
@@ -2377,7 +2498,7 @@ class MapControlZoomComponent extends DestructibleComponent {
     }
     ngOnInit() {
         this.postboy
-            .subscribe(MapRenderedEvent.ID)
+            .sub(MapRenderedEvent)
             .pipe(filter((m) => !!m), first())
             .subscribe((m) => {
             this.map = m.map;
@@ -2390,7 +2511,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);
     }
     eliminate = () => !!this.map && !!this.control && this.map.removeControl(this.control);