@artstesh/maps 5.0.5 → 5.0.7

package/dist/fesm2022/maps-components.mjs

@@ -4,6 +4,8 @@ import * as i4 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { Feature } from 'ol';
 import { Point } from 'ol/geom';
+import { GeoJSON, WKT } from 'ol/format';
+import { getCenter, createEmpty, extend } from 'ol/extent';
 import { useGeographic, get } from 'ol/proj';
 import { Subject } from 'rxjs';
 import { PostboyService, PostboyAbstractRegistrator } from '@artstesh/postboy';
@@ -15,8 +17,11 @@ import { filter, first } from 'rxjs/operators';
 import { XYZ, Vector } from 'ol/source';
 import { Vector as Vector$1 } from 'ol/layer';
 import Overlay from 'ol/Overlay';
+import { bbox } from 'ol/loadingstrategy';
+import { fromExtent } from 'ol/geom/Polygon';
+import Cluster from 'ol/source/Cluster';
 import Style from 'ol/style/Style';
-import { Icon, Circle, Fill, Stroke } from 'ol/style';
+import { Icon, Circle, Fill, Stroke, Text } from 'ol/style';
 
 class DestructibleComponent {
     subs = [];
@@ -117,6 +122,10 @@ class IdGenerator {
     }
 }
 
+class MapConstants {
+    static FeatureInfo = 'f-info';
+}
+
 class MarkerModel {
     lat;
     lng;
@@ -137,11 +146,38 @@ class MarkerModel {
         const feature = new Feature(new Point([this.lng, this.lat]));
         feature.setId(this.id);
         if (this.info)
-            feature.set('info', this.info);
+            feature.set(MapConstants.FeatureInfo, this.info);
         return feature;
     }
 }
 
+class PolygonModel {
+    info;
+    id;
+    lat;
+    lng;
+    _feature;
+    static fromGeoJson(id, json, info) {
+        let feature = new GeoJSON().readFeature(json);
+        feature.setId(id);
+        return new PolygonModel(feature, id, info);
+    }
+    static fromWKT(id, wkt, info) {
+        let feature = new WKT().readFeature(wkt);
+        feature.setId(id);
+        return new PolygonModel(feature, id, info);
+    }
+    constructor(feature, id, info) {
+        this.info = info;
+        this.id = id == null ? IdGenerator.get() : id;
+        this._feature = feature;
+        [this.lng, this.lat] = getCenter(this._feature.getGeometry()?.getExtent());
+    }
+    get feature() {
+        return this._feature;
+    }
+}
+
 class GenericMessage {
 }
 class CallbackMessage extends GenericMessage {
@@ -168,11 +204,13 @@ class MapRenderedEvent extends GenericMessage {
 class MapClickEvent extends GenericMessage {
     coordinates;
     entities;
+    features;
     static ID = '323df526-8d9c-49c6-83e8-6e9a1e7762f7';
-    constructor(coordinates, entities) {
+    constructor(coordinates, entities, features) {
         super();
         this.coordinates = coordinates;
         this.entities = entities;
+        this.features = features;
     }
     get id() {
         return MapClickEvent.ID;
@@ -253,6 +291,20 @@ class RemoveTileCommand extends GenericMessage {
     }
 }
 
+class FitToFeaturesCommand extends GenericMessage {
+    features;
+    zoomAfter;
+    static ID = '76cdc091-3793-4b6c-82f7-1e0334cf08a8';
+    constructor(features, zoomAfter = 0) {
+        super();
+        this.features = features;
+        this.zoomAfter = zoomAfter;
+    }
+    get id() {
+        return FitToFeaturesCommand.ID;
+    }
+}
+
 class MapPostboyService extends PostboyService {
     observe = (id) => this.subscribe(id);
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapPostboyService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
@@ -308,8 +360,11 @@ class MapManagementService {
         this.postboy.subscribe(PlaceLayerFeaturesCommand.ID).subscribe((c) => {
             if (!this.layers[c.layer])
                 return;
-            this.layers[c.layer]?.getSource()?.clear();
-            this.layers[c.layer].getSource()?.addFeatures(c.features);
+            let source = this.layers[c.layer]?.getSource();
+            if (!!source['getSource'])
+                source = source?.getSource();
+            source?.clear();
+            source?.addFeatures(c.features);
         });
     }
     observeRemoveLayer() {
@@ -343,6 +398,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
+class MapFeatureService {
+    postboy;
+    map;
+    constructor(postboy) {
+        this.postboy = postboy;
+    }
+    up() {
+        this.observeMapRender();
+        this.observeFitToFeatures();
+    }
+    observeMapRender() {
+        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+            this.map = m.map;
+        });
+    }
+    observeFitToFeatures() {
+        this.postboy.subscribe(FitToFeaturesCommand.ID).subscribe((m) => {
+            this.fitToGeometries(m.features.map((f) => f.getGeometry()), m.zoomAfter);
+        });
+    }
+    fitToGeometries(geometries, zoomAfter) {
+        if (!geometries?.length || !this.map)
+            return;
+        const extent = createEmpty();
+        geometries.forEach((g) => extend(extent, g.getExtent()));
+        this.map.getView().fit(extent);
+        this.map.getView().setZoom(this.map.getView().getZoom() + zoomAfter);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapFeatureService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapFeatureService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapFeatureService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
+
 class MapClickService {
     postboy;
     map;
@@ -361,7 +451,7 @@ class MapClickService {
         });
     }
     onClick(ev) {
-        const model = new MapClickEvent(ev.coordinate, {});
+        const model = new MapClickEvent(ev.coordinate, {}, {});
         this.map?.forEachFeatureAtPixel(ev.pixel, (f, l) => {
             this.getFeatureCollectionWithInner([f])
                 .filter((f) => f.getId() != null)
@@ -369,7 +459,10 @@ class MapClickService {
                 let layerName = l.get('name');
                 if (!model.entities[layerName])
                     model.entities[layerName] = [];
-                model.entities[layerName].push(f.getId());
+                if (!model.features[layerName])
+                    model.features[layerName] = [];
+                model.entities[layerName].push({ id: fs.getId(), ...fs.get(MapConstants.FeatureInfo) });
+                model.features[layerName].push(fs);
             });
         });
         return model;
@@ -390,9 +483,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
 
 class MessageRegistratorService extends PostboyAbstractRegistrator {
-    constructor(service, management, state, interaction) {
+    constructor(service, management, state, feature, interaction) {
         super(service);
-        this.registerServices([management, state, interaction]);
+        this.registerServices([management, state, interaction, feature]);
     }
     _up() {
         this.registerReplay(MapRenderedEvent.ID);
@@ -403,13 +496,14 @@ class MessageRegistratorService extends PostboyAbstractRegistrator {
         this.registerSubject(RemoveTileCommand.ID);
         this.registerSubject(MapClickEvent.ID);
         this.registerSubject(CloseTooltipCommand.ID);
+        this.registerSubject(FitToFeaturesCommand.ID);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapClickService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }, { token: MapManagementService }, { token: MapStateService }, { token: MapFeatureService }, { token: MapClickService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageRegistratorService, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapClickService }]; } });
+        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: MapManagementService }, { type: MapStateService }, { type: MapFeatureService }, { type: MapClickService }]; } });
 
 class MapPlateFactory {
     build(settings) {
@@ -532,11 +626,11 @@ class MapPlateComponent extends DestructibleComponent {
         this.registrator.down();
     };
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapPlateComponent, deps: [{ token: i0.ElementRef }, { token: MapPostboyService }, { token: MapPlateFactory }, { token: MessageRegistratorService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: MapPlateComponent, selector: "lib-map-plate", inputs: { settings: "settings" }, providers: [MessageRegistratorService, MapStateService, MapManagementService, MapClickService], usesInheritance: true, ngImport: i0, template: "<ng-content></ng-content>\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: ["url", "map"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: MapPlateComponent, selector: "lib-map-plate", inputs: { settings: "settings" }, providers: [MessageRegistratorService, MapStateService, MapManagementService, MapClickService, MapFeatureService], usesInheritance: true, ngImport: i0, template: "<ng-content></ng-content>\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: ["url", "map"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapPlateComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'lib-map-plate', changeDetection: ChangeDetectionStrategy.OnPush, providers: [MessageRegistratorService, MapStateService, MapManagementService, MapClickService], template: "<ng-content></ng-content>\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"] }]
+            args: [{ selector: 'lib-map-plate', changeDetection: ChangeDetectionStrategy.OnPush, providers: [MessageRegistratorService, MapStateService, MapManagementService, MapClickService, MapFeatureService], template: "<ng-content></ng-content>\n<lib-osm-tile-layer *ngIf=\"osmUrl && map\" [map]=\"map\" [url]=\"osmUrl\"></lib-osm-tile-layer>\n", styles: ["lib-map-plate{position:relative;display:flex;flex-direction:column;height:100%}\n"] }]
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MapPostboyService }, { type: MapPlateFactory }, { type: MessageRegistratorService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { settings: [{
                 type: Input
             }] } });
@@ -921,6 +1015,211 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input
             }] } });
 
+class PolygonsComponent extends DestructibleComponent {
+    postboy;
+    layerName = '';
+    constructor(postboy) {
+        super();
+        this.postboy = postboy;
+    }
+    _polygons = [];
+    set polygons(value) {
+        this._polygons = value;
+        this.putPolygons();
+    }
+    ngOnInit() {
+        this.postboy
+            .subscribe(MapRenderedEvent.ID)
+            .pipe(filter((m) => !!m), first())
+            .subscribe(() => this.putPolygons());
+    }
+    putPolygons() {
+        if (!this._polygons?.length)
+            return;
+        this.postboy.fire(new PlaceLayerFeaturesCommand(this.layerName, this._polygons.map((m) => m.feature)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PolygonsComponent, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: PolygonsComponent, selector: "lib-polygons", inputs: { layerName: "layerName", polygons: "polygons" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PolygonsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-polygons', template: '', changeDetection: ChangeDetectionStrategy.OnPush }]
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; }, propDecorators: { layerName: [{
+                type: Input
+            }], polygons: [{
+                type: Input
+            }] } });
+
+class ClusterLayerSettings {
+    name = IdGenerator.get();
+    zIndex = 1;
+    maxZoom = 19;
+    minZoom = 0;
+    distance = 20;
+    bbox = false;
+    style;
+    static copy(model) {
+        const result = new ClusterLayerSettings();
+        result.name = model.name;
+        result.maxZoom = model.maxZoom;
+        result.minZoom = model.minZoom;
+        result.zIndex = model.zIndex;
+        result.bbox = model.bbox;
+        result.distance = model.distance;
+        result.style = model.style;
+        return result;
+    }
+    setZIndex(zIndex) {
+        return ClusterLayerSettings.copy({ ...this, zIndex });
+    }
+    setDistance(distance) {
+        return ClusterLayerSettings.copy({ ...this, distance });
+    }
+    setName(name) {
+        return ClusterLayerSettings.copy({ ...this, name });
+    }
+    setMaxZoom(maxZoom) {
+        return ClusterLayerSettings.copy({ ...this, maxZoom });
+    }
+    setMinZoom(minZoom) {
+        return ClusterLayerSettings.copy({ ...this, minZoom });
+    }
+    setBbox(bbox) {
+        return ClusterLayerSettings.copy({ ...this, bbox });
+    }
+    setStyle(style) {
+        return ClusterLayerSettings.copy({ ...this, style });
+    }
+    isSame(model) {
+        if (this.maxZoom !== model.maxZoom)
+            return false;
+        if (this.minZoom !== model.minZoom)
+            return false;
+        if (this.zIndex !== model.zIndex)
+            return false;
+        if (this.name !== model.name)
+            return false;
+        if (this.distance !== model.distance)
+            return false;
+        if (this.bbox !== model.bbox)
+            return false;
+        if (this.style !== model.style)
+            return false;
+        return true;
+    }
+}
+
+class ClusterLayerManager {
+    settings;
+    layer;
+    postboy;
+    constructor(settings, layer, postboy) {
+        this.settings = settings;
+        this.layer = layer;
+        this.postboy = postboy;
+        this.observeClick();
+    }
+    observeClick() {
+        this.postboy.subscribe(MapClickEvent.ID).subscribe((m) => {
+            if ((m.features[this.settings.name]?.length ?? 0) > 1) {
+                this.postboy.fire(new FitToFeaturesCommand(m.features[this.settings.name], -1));
+            }
+        });
+    }
+}
+
+class ClusterLayerFactory {
+    build(settings, postboy) {
+        const source = new Vector({
+            strategy: settings.bbox ? bbox : undefined,
+        });
+        const cluster = new Cluster({
+            distance: settings.distance,
+            source: source,
+            geometryFunction: (feature) => {
+                const geom = feature.getGeometry();
+                if (geom?.getType() == 'Point') {
+                    return geom;
+                }
+                else if (geom?.getType() == 'Polygon') {
+                    return geom?.getInteriorPoint();
+                }
+                else if (geom?.getType() == 'MultiPolygon') {
+                    return fromExtent(geom.getExtent())?.getInteriorPoint();
+                }
+                return undefined;
+            },
+        });
+        const layer = new Vector$1({
+            source: cluster,
+            maxZoom: settings.maxZoom || undefined,
+            minZoom: settings.minZoom || undefined,
+            zIndex: settings.zIndex || 0,
+        });
+        layer.setStyle(this.styleFunc(settings));
+        layer.set('name', settings.name);
+        return new ClusterLayerManager(settings, layer, postboy);
+    }
+    styleFunc(settings) {
+        return (feature) => {
+            const features = feature.get('features');
+            if (!settings.style)
+                return undefined;
+            return settings.style(features.map((f) => ({ id: f.getId(), ...f.get(MapConstants.FeatureInfo) })));
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClusterLayerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClusterLayerFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClusterLayerFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class ClusterLayerComponent extends DestructibleComponent {
+    postboy;
+    factory;
+    manager = null;
+    _settings = new ClusterLayerSettings();
+    constructor(postboy, factory) {
+        super();
+        this.postboy = postboy;
+        this.factory = factory;
+    }
+    ngOnInit() {
+        this.postboy
+            .subscribe(MapRenderedEvent.ID)
+            .pipe(filter((m) => !!m), first())
+            .subscribe((m) => this.initLayer());
+    }
+    set settings(value) {
+        if (!value || this._settings.isSame(value))
+            return;
+        this._settings = value;
+        this.initLayer();
+    }
+    onDestroy = () => this.removeLayer();
+    initLayer() {
+        this.removeLayer();
+        this.manager = this.factory.build(this._settings, this.postboy);
+        this.postboy.fire(new AddLayerCommand(this.manager.layer));
+    }
+    removeLayer() {
+        if (this.manager?.layer)
+            this.postboy.fire(new RemoveLayerCommand(this.manager.layer));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClusterLayerComponent, deps: [{ token: MapPostboyService }, { token: ClusterLayerFactory }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: ClusterLayerComponent, selector: "lib-cluster-layer", inputs: { settings: "settings" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClusterLayerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-cluster-layer', template: '', changeDetection: ChangeDetectionStrategy.OnPush }]
+        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: ClusterLayerFactory }]; }, propDecorators: { settings: [{
+                type: Input
+            }] } });
+
 class MapModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
     static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: MapModule, declarations: [DestructibleComponent,
@@ -929,7 +1228,15 @@ class MapModule {
             OsmTileLayerComponent,
             FeatureLayerComponent,
             MarkersComponent,
-            TooltipComponent], imports: [CommonModule], exports: [MapPlateComponent, FeatureLayerComponent, MarkersComponent, TileLayerComponent, TooltipComponent] });
+            TooltipComponent,
+            PolygonsComponent,
+            ClusterLayerComponent], imports: [CommonModule], exports: [MapPlateComponent,
+            FeatureLayerComponent,
+            MarkersComponent,
+            TileLayerComponent,
+            TooltipComponent,
+            PolygonsComponent,
+            ClusterLayerComponent] });
     static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapModule, imports: [CommonModule] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MapModule, decorators: [{
@@ -944,8 +1251,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                         FeatureLayerComponent,
                         MarkersComponent,
                         TooltipComponent,
+                        PolygonsComponent,
+                        ClusterLayerComponent,
+                    ],
+                    exports: [
+                        MapPlateComponent,
+                        FeatureLayerComponent,
+                        MarkersComponent,
+                        TileLayerComponent,
+                        TooltipComponent,
+                        PolygonsComponent,
+                        ClusterLayerComponent,
                     ],
-                    exports: [MapPlateComponent, FeatureLayerComponent, MarkersComponent, TileLayerComponent, TooltipComponent],
                 }]
         }] });
 
@@ -970,6 +1287,37 @@ class MarkerStyleHelper {
             }),
         });
     }
+    static withText(style, text) {
+        style.setText(text);
+        return style;
+    }
+}
+
+class PolygonStyleHelper {
+    static simple(fill, stroke, strokeWidth = 1) {
+        return new Style({
+            fill: new Fill({
+                color: fill,
+            }),
+            stroke: new Stroke({
+                color: stroke,
+                width: strokeWidth,
+            }),
+        });
+    }
+}
+
+class TextStyleHelper {
+    static get(text, font, color) {
+        return new Text({
+            text: text,
+            font: font,
+            textAlign: 'center',
+            fill: new Fill({
+                color: color,
+            }),
+        });
+    }
 }
 
 /*
@@ -984,5 +1332,5 @@ class MarkerStyleHelper {
  * Generated bundle index. Do not edit.
  */
 
-export { CallbackMessage, CloseTooltipCommand, FeatureLayerComponent, FeatureLayerSettings, GenericMessage, MapClickEvent, MapLyrs, MapLyrsLabel, MapModule, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, OsmTileLayerComponent, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings };
+export { CallbackMessage, CloseTooltipCommand, ClusterLayerComponent, ClusterLayerSettings, FeatureLayerComponent, FeatureLayerSettings, GenericMessage, MapClickEvent, MapLyrs, MapLyrsLabel, MapModule, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, OsmTileLayerComponent, PolygonModel, PolygonStyleHelper, PolygonsComponent, TextStyleHelper, TileLayerComponent, TileLayerSettings, TooltipComponent, TooltipSettings };
 //# sourceMappingURL=maps-components.mjs.map