@artstesh/maps 1.0.0

package/dist/fesm2015/maps-components-src-map.js

@@ -0,0 +1,727 @@
+import * as i0 from '@angular/core';
+import { Component, Injectable, ChangeDetectionStrategy, Input, NgModule } from '@angular/core';
+import * as i5 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { Feature } from 'ol';
+import { Point } from 'ol/geom';
+import { useGeographic } from 'ol/proj';
+import { Subject, ReplaySubject } from 'rxjs';
+import Map from 'ol/Map';
+import View from 'ol/View';
+import TileLayer from 'ol/layer/Tile';
+import OSM from 'ol/source/OSM';
+import { filter, first } from 'rxjs/operators';
+import { Vector } from 'ol/source';
+import { Vector as Vector$1 } from 'ol/layer';
+import Style from 'ol/style/Style';
+import { Icon, Circle, Fill, Stroke } from 'ol/style';
+
+class DestructibleComponent {
+    constructor() {
+        this.subs = [];
+    }
+    ngOnDestroy() {
+        this.subs.forEach((s) => s.unsubscribe());
+        if (this.onDestroy)
+            this.onDestroy();
+    }
+}
+DestructibleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DestructibleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DestructibleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: DestructibleComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DestructibleComponent, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }] });
+
+var MapLyrs;
+(function (MapLyrs) {
+    MapLyrs[MapLyrs["Hybrid"] = 1] = "Hybrid";
+    MapLyrs[MapLyrs["Satellite"] = 2] = "Satellite";
+    MapLyrs[MapLyrs["Streets"] = 3] = "Streets";
+    MapLyrs[MapLyrs["Terrain"] = 4] = "Terrain";
+})(MapLyrs || (MapLyrs = {}));
+class MapLyrsLabel {
+    static get(lyrs) {
+        return MapLyrsLabel.lyrs[lyrs];
+    }
+}
+MapLyrsLabel.lyrs = {
+    [MapLyrs.Hybrid]: 's,h',
+    [MapLyrs.Satellite]: 's',
+    [MapLyrs.Streets]: 'm',
+    [MapLyrs.Terrain]: 'p',
+};
+
+class MapSettings {
+    constructor() {
+        this.center = [0, 0];
+        this.maxZoom = 19;
+        this.minZoom = 0;
+        this.zoom = 4;
+        this.lyrs = MapLyrs.Hybrid;
+        this.language = 'en';
+    }
+    static copy(model) {
+        const result = new MapSettings();
+        result.center = model.center;
+        result.maxZoom = model.maxZoom;
+        result.minZoom = model.minZoom;
+        result.zoom = model.zoom;
+        result.lyrs = model.lyrs;
+        result.language = model.language;
+        return result;
+    }
+    setCenter(center) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { center }));
+    }
+    setMaxZoom(maxZoom) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { maxZoom }));
+    }
+    setMinZoom(minZoom) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { minZoom }));
+    }
+    setZoom(zoom) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { zoom }));
+    }
+    setLyrs(lyrs) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { lyrs }));
+    }
+    setLanguage(language) {
+        return MapSettings.copy(Object.assign(Object.assign({}, this), { language }));
+    }
+    isSame(model) {
+        if (this.maxZoom !== model.maxZoom)
+            return false;
+        if (this.minZoom !== model.minZoom)
+            return false;
+        if (this.zoom !== model.zoom)
+            return false;
+        if (this.lyrs !== model.lyrs)
+            return false;
+        if (this.language !== model.language)
+            return false;
+        return this.center.length !== model.center.length || !!this.center.filter((c, i) => c !== model.center[i]);
+    }
+}
+
+class IdGenerator {
+    static get() {
+        let result = [];
+        for (let i = 0; i < 7; i++) {
+            result.push(IdGenerator.collection
+                .sort(() => 0.5 - Math.random())
+                .slice(0, 5)
+                .join(''));
+        }
+        return result.join('-');
+    }
+}
+IdGenerator.collection = 'ABCDEFGHIJKLMNOPQRSTUVWXTZ0123456789'.split('');
+
+class MarkerModel {
+    constructor(lat, lng, id, info) {
+        this.lat = lat;
+        this.lng = lng;
+        this.id = id;
+        this.info = info;
+        if (id == null)
+            this.id = IdGenerator.get();
+        this._feature = this.getFeature();
+    }
+    get feature() {
+        return this._feature;
+    }
+    getFeature() {
+        const feature = new Feature(new Point([this.lng, this.lat]));
+        feature.setId(this.id);
+        if (this.info) {
+            Object.keys(this.info).forEach((k) => feature.set(k, this.info[k]));
+        }
+        return feature;
+    }
+}
+
+class GenericMessage {
+}
+class CallbackMessage extends GenericMessage {
+    constructor() {
+        super(...arguments);
+        this.result$ = new Subject();
+        this.result = this.result$.asObservable();
+    }
+    finish(value) {
+        this.result$.next(value);
+        this.result$.complete();
+    }
+}
+
+class MapRenderedEvent extends GenericMessage {
+    constructor(map) {
+        super();
+        this.map = map;
+    }
+    get id() {
+        return MapRenderedEvent.ID;
+    }
+}
+MapRenderedEvent.ID = 'b6121807-3b89-4cd3-82cf-089d2cefdc4f';
+
+class AddLayerCommand extends GenericMessage {
+    constructor(layer) {
+        super();
+        this.layer = layer;
+    }
+    get id() {
+        return AddLayerCommand.ID;
+    }
+}
+AddLayerCommand.ID = 'd93e250f-92bc-43ac-9c6a-46c521a1aaa5';
+
+class PlaceLayerFeaturesCommand extends GenericMessage {
+    constructor(layer, features) {
+        super();
+        this.layer = layer;
+        this.features = features;
+    }
+    get id() {
+        return PlaceLayerFeaturesCommand.ID;
+    }
+}
+PlaceLayerFeaturesCommand.ID = '8caf86bc-869b-426f-b36d-4642f6b8aab0';
+
+class RemoveLayerCommand extends GenericMessage {
+    constructor(layer) {
+        super();
+        this.layer = layer;
+    }
+    get id() {
+        return RemoveLayerCommand.ID;
+    }
+}
+RemoveLayerCommand.ID = 'ab484e0e-e185-45cd-8434-12101f3c7eb1';
+
+class ClearLayerCommand extends GenericMessage {
+    constructor(layer) {
+        super();
+        this.layer = layer;
+    }
+    get id() {
+        return ClearLayerCommand.ID;
+    }
+}
+ClearLayerCommand.ID = 'd02842b7-fa62-458d-b1e4-12dd814610c5';
+
+class MapPostboyService {
+    constructor() {
+        this.applications = {};
+    }
+    register(id, sub) {
+        this.applications[id] = sub;
+    }
+    subscribe(id) {
+        if (!this.applications[id])
+            throw new Error(`There is no event with id ${id}`);
+        return this.applications[id].asObservable();
+    }
+    fire(message) {
+        if (!this.applications[message.id])
+            throw new Error(`There is no event with id ${message.id}`);
+        this.applications[message.id].next(message);
+    }
+}
+MapPostboyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPostboyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapPostboyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPostboyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPostboyService, decorators: [{
+            type: Injectable
+        }] });
+
+class MessageRegistratorService {
+    constructor(service) {
+        service.register(MapRenderedEvent.ID, new ReplaySubject(1));
+        service.register(AddLayerCommand.ID, new Subject());
+        service.register(PlaceLayerFeaturesCommand.ID, new ReplaySubject(1));
+        service.register(RemoveLayerCommand.ID, new Subject());
+        service.register(ClearLayerCommand.ID, new Subject());
+    }
+}
+MessageRegistratorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageRegistratorService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageRegistratorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageRegistratorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageRegistratorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
+
+class MapStateService {
+    constructor(postboy) {
+        this.postboy = postboy;
+        postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => (this.map = m));
+    }
+}
+MapStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapStateService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+MapStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapStateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapStateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
+
+class MapManagementService {
+    constructor(postboy) {
+        this.postboy = postboy;
+        this.layers = {};
+        this.observeMapRender();
+        this.observeAddLayer();
+        this.observeRemoveLayer();
+        this.observePlaceFeatures();
+        this.observeClearLayer();
+    }
+    observeMapRender() {
+        this.postboy.subscribe(MapRenderedEvent.ID).subscribe((m) => {
+            this.map = m.map;
+        });
+    }
+    observeClearLayer() {
+        this.postboy.subscribe(ClearLayerCommand.ID).subscribe((c) => {
+            var _a, _b;
+            (_b = (_a = this.layers[c.layer]) === null || _a === void 0 ? void 0 : _a.getSource()) === null || _b === void 0 ? void 0 : _b.clear();
+        });
+    }
+    observeAddLayer() {
+        this.postboy.subscribe(AddLayerCommand.ID).subscribe((c) => {
+            if (!this.map)
+                return;
+            this.layers[c.layer.get('name')] = c.layer;
+            this.map.addLayer(c.layer);
+        });
+    }
+    observePlaceFeatures() {
+        this.postboy.subscribe(PlaceLayerFeaturesCommand.ID).subscribe((c) => {
+            var _a, _b, _c;
+            if (!this.layers[c.layer])
+                return;
+            (_b = (_a = this.layers[c.layer]) === null || _a === void 0 ? void 0 : _a.getSource()) === null || _b === void 0 ? void 0 : _b.clear();
+            (_c = this.layers[c.layer].getSource()) === null || _c === void 0 ? void 0 : _c.addFeatures(c.features);
+        });
+    }
+    observeRemoveLayer() {
+        this.postboy.subscribe(RemoveLayerCommand.ID).subscribe((c) => {
+            if (!this.map)
+                return;
+            delete this.layers[c.layer.get('name')];
+            this.map.removeLayer(c.layer);
+        });
+    }
+}
+MapManagementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapManagementService, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Injectable });
+MapManagementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapManagementService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapManagementService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; } });
+
+class ServiceCollector {
+    constructor(registrator, management, state) { }
+}
+ServiceCollector.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ServiceCollector, deps: [{ token: MessageRegistratorService }, { token: MapManagementService }, { token: MapStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+ServiceCollector.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ServiceCollector });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ServiceCollector, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: MessageRegistratorService }, { type: MapManagementService }, { type: MapStateService }]; } });
+
+class MapPlateFactory {
+    build(settings) {
+        return new Map({
+            controls: [],
+            view: new View({
+                center: (settings === null || settings === void 0 ? void 0 : settings.center) || [0, 0],
+                zoom: (settings === null || settings === void 0 ? void 0 : settings.zoom) || 4,
+                minZoom: (settings === null || settings === void 0 ? void 0 : settings.minZoom) || 0,
+                maxZoom: (settings === null || settings === void 0 ? void 0 : settings.maxZoom) || 19,
+            }),
+            layers: [],
+        });
+    }
+}
+MapPlateFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapPlateFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class OsmTileLayerComponent extends DestructibleComponent {
+    constructor() {
+        super();
+        this._url = '';
+    }
+    set url(value) {
+        if (!value || this._url === value)
+            return;
+        this._url = value;
+        this.initLayer();
+    }
+    set map(value) {
+        if (!value || this._map === value)
+            return;
+        this._map = value;
+        this.initLayer();
+    }
+    ngOnInit() { }
+    ngOnDestroy() {
+        var _a, _b;
+        if (this.layer) {
+            (_a = this._map) === null || _a === void 0 ? void 0 : _a.removeLayer(this.layer);
+        }
+        // @ts-ignore
+        (_b = this.layer) === null || _b === void 0 ? void 0 : _b.setMap(null);
+    }
+    initLayer() {
+        if (!this._url || !this._map)
+            return;
+        if (this.layer)
+            this._map.removeLayer(this.layer);
+        this.layer = new TileLayer({
+            source: new OSM({
+                url: this._url,
+            }),
+        });
+        this.layer.set('name', 'osm-tile-layer');
+        this._map.addLayer(this.layer);
+    }
+}
+OsmTileLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: OsmTileLayerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+OsmTileLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: { url: "url", map: "map" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: OsmTileLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-osm-tile-layer',
+                    template: '',
+                    styleUrls: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { url: [{
+                type: Input
+            }], map: [{
+                type: Input
+            }] } });
+
+class MapPlateComponent extends DestructibleComponent {
+    constructor(elementRef, postboy, mapFactory, registrator, detector) {
+        super();
+        this.elementRef = elementRef;
+        this.postboy = postboy;
+        this.mapFactory = mapFactory;
+        this.detector = detector;
+        this.osmUrl = '';
+        this._settings = new MapSettings();
+    }
+    set settings(value) {
+        if (!value || this._settings.isSame(value))
+            return;
+        this._settings = value;
+        this.setOsm();
+    }
+    ngOnInit() {
+        useGeographic();
+        this.map = this.mapFactory.build(this._settings);
+        this.map.setTarget(this.elementRef.nativeElement);
+        this.detector.detectChanges();
+        this.map.once('postrender', () => {
+            this.map.updateSize();
+            this.postboy.fire(new MapRenderedEvent(this.map));
+        });
+        this.setOsm();
+    }
+    setOsm() {
+        if (!this.map)
+            return;
+        this.osmUrl = `https://mt{0-3}.google.com/vt/lyrs=${MapLyrsLabel.get(this._settings.lyrs)}&hl=${this._settings.language}&x={x}&y={y}&z={z}`;
+        this.detector.detectChanges();
+        this.map.updateSize();
+    }
+}
+MapPlateComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateComponent, deps: [{ token: i0.ElementRef }, { token: MapPostboyService }, { token: MapPlateFactory }, { token: ServiceCollector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MapPlateComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MapPlateComponent, selector: "lib-map-plate", inputs: { settings: "settings" }, providers: [MessageRegistratorService, MapStateService, MapManagementService, ServiceCollector], 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"], components: [{ type: OsmTileLayerComponent, selector: "lib-osm-tile-layer", inputs: ["url", "map"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapPlateComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-map-plate',
+                    templateUrl: './map-plate.component.html',
+                    styleUrls: ['./map-plate.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [MessageRegistratorService, MapStateService, MapManagementService, ServiceCollector],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: MapPostboyService }, { type: MapPlateFactory }, { type: ServiceCollector }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { settings: [{
+                type: Input
+            }] } });
+
+class TileLayerComponent extends DestructibleComponent {
+    constructor() {
+        super();
+    }
+}
+TileLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TileLayerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TileLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: TileLayerComponent, selector: "lib-tile-layer", usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TileLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-tile-layer',
+                    template: '',
+                    styleUrls: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class FeatureLayerSettings {
+    constructor() {
+        this.name = IdGenerator.get();
+        this.zIndex = 1;
+        this.maxZoom = 19;
+        this.minZoom = 0;
+    }
+    static copy(model) {
+        const result = new FeatureLayerSettings();
+        result.name = model.name;
+        result.maxZoom = model.maxZoom;
+        result.minZoom = model.minZoom;
+        result.zIndex = model.zIndex;
+        result.style = model.style;
+        return result;
+    }
+    setZIndex(zIndex) {
+        return FeatureLayerSettings.copy(Object.assign(Object.assign({}, this), { zIndex }));
+    }
+    setName(name) {
+        return FeatureLayerSettings.copy(Object.assign(Object.assign({}, this), { name }));
+    }
+    setMaxZoom(maxZoom) {
+        return FeatureLayerSettings.copy(Object.assign(Object.assign({}, this), { maxZoom }));
+    }
+    setMinZoom(minZoom) {
+        return FeatureLayerSettings.copy(Object.assign(Object.assign({}, this), { minZoom }));
+    }
+    setStyle(style) {
+        return FeatureLayerSettings.copy(Object.assign(Object.assign({}, 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.style !== model.style)
+            return false;
+        return true;
+    }
+}
+
+class FeatureLayerFactory {
+    build(settings) {
+        const source = new Vector({});
+        const layer = new Vector$1({
+            source: source,
+            maxZoom: settings.maxZoom,
+            minZoom: settings.minZoom,
+            zIndex: settings.zIndex,
+        });
+        if (settings.style)
+            layer.setStyle(settings.style);
+        layer.set('name', settings.name);
+        return layer;
+    }
+}
+FeatureLayerFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureLayerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FeatureLayerFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureLayerFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureLayerFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class FeatureLayerComponent extends DestructibleComponent {
+    constructor(postboy, factory) {
+        super();
+        this.postboy = postboy;
+        this.factory = factory;
+        this.layer = null;
+        this._settings = new FeatureLayerSettings();
+        this.onDestroy = () => this.removeLayer();
+    }
+    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();
+    }
+    initLayer() {
+        this.removeLayer();
+        this.layer = this.factory.build(this._settings);
+        this.postboy.fire(new AddLayerCommand(this.layer));
+    }
+    removeLayer() {
+        if (this.layer)
+            this.postboy.fire(new RemoveLayerCommand(this.layer));
+    }
+}
+FeatureLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureLayerComponent, deps: [{ token: MapPostboyService }, { token: FeatureLayerFactory }], target: i0.ɵɵFactoryTarget.Component });
+FeatureLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FeatureLayerComponent, selector: "lib-feature-layer", inputs: { settings: "settings" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FeatureLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-feature-layer',
+                    template: '',
+                    styleUrls: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: MapPostboyService }, { type: FeatureLayerFactory }]; }, propDecorators: { settings: [{
+                type: Input
+            }] } });
+
+class MarkersComponent extends DestructibleComponent {
+    constructor(postboy) {
+        super();
+        this.postboy = postboy;
+        this.layerName = '';
+        this._markers = [];
+    }
+    set markers(value) {
+        this._markers = value;
+        this.putMarkers();
+    }
+    ngOnInit() {
+        this.postboy
+            .subscribe(MapRenderedEvent.ID)
+            .pipe(filter((m) => !!m), first())
+            .subscribe(() => this.putMarkers());
+    }
+    putMarkers() {
+        var _a;
+        if (!((_a = this._markers) === null || _a === void 0 ? void 0 : _a.length))
+            return;
+        this.postboy.fire(new PlaceLayerFeaturesCommand(this.layerName, this._markers.map((m) => m.feature)));
+    }
+}
+MarkersComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MarkersComponent, deps: [{ token: MapPostboyService }], target: i0.ɵɵFactoryTarget.Component });
+MarkersComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MarkersComponent, selector: "lib-markers", inputs: { layerName: "layerName", markers: "markers" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MarkersComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-markers',
+                    template: '',
+                    styleUrls: [],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: MapPostboyService }]; }, propDecorators: { layerName: [{
+                type: Input
+            }], markers: [{
+                type: Input
+            }] } });
+
+class MapModule {
+}
+MapModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MapModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapModule, declarations: [DestructibleComponent,
+        MapPlateComponent,
+        TileLayerComponent,
+        OsmTileLayerComponent,
+        FeatureLayerComponent,
+        MarkersComponent], imports: [CommonModule], exports: [MapPlateComponent, FeatureLayerComponent, MarkersComponent] });
+MapModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        DestructibleComponent,
+                        MapPlateComponent,
+                        TileLayerComponent,
+                        OsmTileLayerComponent,
+                        FeatureLayerComponent,
+                        MarkersComponent,
+                    ],
+                    exports: [MapPlateComponent, FeatureLayerComponent, MarkersComponent],
+                }]
+        }] });
+
+class TileLayerSettings {
+    constructor() {
+        this.name = 'tiles';
+        this.maxZoom = 19;
+        this.minZoom = 0;
+        this.opacity = 1;
+        this.url = '';
+    }
+    static copy(model) {
+        const result = new TileLayerSettings();
+        result.name = model.name;
+        result.maxZoom = model.maxZoom;
+        result.minZoom = model.minZoom;
+        result.url = model.url;
+        return result;
+    }
+    setUrl(url) {
+        return TileLayerSettings.copy(Object.assign(Object.assign({}, this), { url }));
+    }
+    setName(name) {
+        return TileLayerSettings.copy(Object.assign(Object.assign({}, this), { name }));
+    }
+    setMaxZoom(maxZoom) {
+        return TileLayerSettings.copy(Object.assign(Object.assign({}, this), { maxZoom }));
+    }
+    setMinZoom(minZoom) {
+        return TileLayerSettings.copy(Object.assign(Object.assign({}, this), { minZoom }));
+    }
+    isSame(model) {
+        if (this.maxZoom !== model.maxZoom)
+            return false;
+        if (this.minZoom !== model.minZoom)
+            return false;
+        if (this.url !== model.url)
+            return false;
+        if (this.name !== model.name)
+            return false;
+        return true;
+    }
+}
+
+class MarkerStyleHelper {
+    static fromSvg(svg, size = [30, 30], zIndex = 400) {
+        let image = new Image();
+        image.src = 'data:image/svg+xml,' + escape(svg);
+        return new Style({
+            image: new Icon({
+                img: image,
+                imgSize: size,
+            }),
+            zIndex,
+        });
+    }
+    static circle(radius, fill, strokeColor, strokeWidth = 1) {
+        return new Style({
+            image: new Circle({
+                radius,
+                fill: new Fill({ color: fill }),
+                stroke: new Stroke({ color: strokeColor, width: strokeWidth }),
+            }),
+        });
+    }
+}
+
+/*
+ * Public API Surface of maps
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CallbackMessage, FeatureLayerComponent, FeatureLayerSettings, GenericMessage, MapLyrs, MapLyrsLabel, MapModule, MapPlateComponent, MapPostboyService, MapRenderedEvent, MapSettings, MarkerModel, MarkerStyleHelper, MarkersComponent, MessageRegistratorService, OsmTileLayerComponent, TileLayerComponent, TileLayerSettings };
+//# sourceMappingURL=maps-components-src-map.js.map