@metadev/lux 0.16.3 → 0.19.0

package/esm2020/lib/lux.module.mjs

@@ -0,0 +1,130 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { AngularResizedEventModule } from 'angular-resize-event';
+import { AutocompleteComponent } from './autocomplete/autocomplete.component';
+import { AutocompleteListComponent } from './autocomplete-list/autocomplete-list.component';
+import { CheckboxComponent } from './checkbox/checkbox.component';
+import { DatetimeComponent } from './datetime/datetime.component';
+import { InputComponent } from './input/input.component';
+import { FilterComponent } from './filter/filter.component';
+import { GeolocationComponent } from './geolocation/geolocation.component';
+import { HttpClientModule } from '@angular/common/http';
+import { LuxTooltipDirective } from './tooltip/tooltip.directive';
+import { LuxBreadcrumbComponent } from './breadcrumb/breadcrumb.component';
+import { LuxModalWindowComponent } from './modal/modal-window';
+import { LuxModalBackdropComponent } from './modal/modal-backdrop';
+import { MapComponent } from './map/map.component';
+import { ModalService } from './modal/modal.service';
+import { PaginationComponent } from './pagination/pagination.component';
+import { RadiogroupComponent } from './radiogroup/radiogroup.component';
+import { SelectComponent } from './select/select.component';
+import { TooltipComponent } from './tooltip/tooltip.component';
+import { TooltipService } from './tooltip/tooltip.service';
+import { VoiceRecognitionDirective } from './voice-recognition/voice-recognition.directive';
+import { WINDOW_PROVIDERS } from './window/window.service';
+import * as i0 from "@angular/core";
+export class LuxModule {
+}
+LuxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LuxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModule, declarations: [AutocompleteComponent,
+        AutocompleteListComponent,
+        FilterComponent,
+        CheckboxComponent,
+        DatetimeComponent,
+        InputComponent,
+        GeolocationComponent,
+        LuxTooltipDirective,
+        LuxModalWindowComponent,
+        LuxModalBackdropComponent,
+        LuxBreadcrumbComponent,
+        MapComponent,
+        SelectComponent,
+        TooltipComponent,
+        PaginationComponent,
+        RadiogroupComponent,
+        VoiceRecognitionDirective], imports: [AngularResizedEventModule,
+        FormsModule,
+        HttpClientModule,
+        ReactiveFormsModule,
+        RouterModule,
+        CommonModule], exports: [AutocompleteComponent,
+        AutocompleteListComponent,
+        FilterComponent,
+        CheckboxComponent,
+        DatetimeComponent,
+        InputComponent,
+        GeolocationComponent,
+        LuxTooltipDirective,
+        LuxBreadcrumbComponent,
+        LuxBreadcrumbComponent,
+        MapComponent,
+        SelectComponent,
+        PaginationComponent,
+        RadiogroupComponent,
+        VoiceRecognitionDirective] });
+LuxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModule, providers: [ModalService, TooltipService, WINDOW_PROVIDERS], imports: [[
+            AngularResizedEventModule,
+            FormsModule,
+            HttpClientModule,
+            ReactiveFormsModule,
+            RouterModule,
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        AutocompleteComponent,
+                        AutocompleteListComponent,
+                        FilterComponent,
+                        CheckboxComponent,
+                        DatetimeComponent,
+                        InputComponent,
+                        GeolocationComponent,
+                        LuxTooltipDirective,
+                        LuxModalWindowComponent,
+                        LuxModalBackdropComponent,
+                        LuxBreadcrumbComponent,
+                        MapComponent,
+                        SelectComponent,
+                        TooltipComponent,
+                        PaginationComponent,
+                        RadiogroupComponent,
+                        VoiceRecognitionDirective
+                    ],
+                    entryComponents: [
+                        LuxModalWindowComponent,
+                        LuxModalBackdropComponent,
+                        TooltipComponent
+                    ],
+                    providers: [ModalService, TooltipService, WINDOW_PROVIDERS],
+                    imports: [
+                        AngularResizedEventModule,
+                        FormsModule,
+                        HttpClientModule,
+                        ReactiveFormsModule,
+                        RouterModule,
+                        CommonModule
+                    ],
+                    exports: [
+                        AutocompleteComponent,
+                        AutocompleteListComponent,
+                        FilterComponent,
+                        CheckboxComponent,
+                        DatetimeComponent,
+                        InputComponent,
+                        GeolocationComponent,
+                        LuxTooltipDirective,
+                        LuxBreadcrumbComponent,
+                        LuxBreadcrumbComponent,
+                        MapComponent,
+                        SelectComponent,
+                        PaginationComponent,
+                        RadiogroupComponent,
+                        VoiceRecognitionDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/map/map.component.mjs

@@ -0,0 +1,265 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { OpenLayerLoaderService } from '../geolocation/openlayer-loader.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../geolocation/openlayer-loader.service";
+import * as i2 from "angular-resize-event";
+export class MapComponent {
+    constructor(olLoader) {
+        this.loaded$ = new BehaviorSubject(false);
+        this.valueChange = new EventEmitter();
+        olLoader.load().subscribe((_) => {
+            // Initialize
+            this._markerSource = new ol.source.Vector();
+            this._markerStyle = new ol.style.Style({
+                image: new ol.style.Icon({
+                    anchor: [0.5, 1],
+                    scale: 0.25,
+                    src: '/assets/img/marker.png'
+                })
+            });
+            this.loaded$.next(true);
+        });
+    }
+    set zoom(zoom) {
+        if (!isNaN(zoom)) {
+            this._zoom = zoom;
+            if (this._map) {
+                this._map.getView().setZoom(zoom);
+            }
+        }
+    }
+    get zoom() {
+        return this._zoom;
+    }
+    set center(center) {
+        if (center && center.coordinates && center.coordinates.length === 2) {
+            this._center = center;
+            if (this._map) {
+                this._map.getView().setCenter(ol.proj.fromLonLat(center.coordinates));
+            }
+        }
+    }
+    get center() {
+        return this._center;
+    }
+    set readonly(readonly) {
+        if (!readonly) {
+            if (this._map) {
+                this._map.on('click', (args) => {
+                    // args.coordinate is in EPSG:3857 (meters), we transform it into EPSG:4326 (degrees)
+                    const coordinates = ol.proj.toLonLat(args.coordinate);
+                    // alternatively: const lonLat = ol.proj.transform(args.coordinate,'EPSG:3857','EPSG:4326');
+                    this.addMarkerAtCoordinates(coordinates);
+                });
+                this._map.on('pointermove', (event) => {
+                    const pixel = this._map.getEventPixel(event.originalEvent);
+                    const hit = this._map.hasFeatureAtPixel(pixel);
+                    this._map.getViewport().style.cursor = hit ? 'move' : 'grab';
+                });
+            }
+        }
+        else {
+            if (this._map) {
+                this._map.on('click', (args) => { });
+                this._map.on('pointermove', (event) => { });
+                this._map.getViewport().style.cursor = 'grab';
+            }
+        }
+        this._readonly = readonly;
+        // reset marker coordinates so marker interactions can be created or recreated accordingly
+        // to the changes to readonly
+        this.markerCoordinates = this.markerCoordinates;
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    set markerCoordinates(markerCoordinates) {
+        if (markerCoordinates && markerCoordinates.length === 2) {
+            this._markerCoordinates = markerCoordinates;
+            if (this._map) {
+                this.addMarkerAtCoordinates(markerCoordinates);
+            }
+        }
+        else {
+            this._markerCoordinates = undefined;
+            if (this._map) {
+                this.removeMarker();
+            }
+        }
+    }
+    get markerCoordinates() {
+        return this._markerCoordinates;
+    }
+    set markerPoint(markerPoint) {
+        if (!markerPoint ||
+            !(markerPoint.coordinates && markerPoint.coordinates.length === 2)) {
+            this.markerCoordinates = undefined;
+        }
+        else {
+            this.markerCoordinates = [
+                +markerPoint.coordinates[0],
+                +markerPoint.coordinates[1]
+            ];
+        }
+        this.valueChange.emit(markerPoint);
+    }
+    get markerPoint() {
+        return {
+            type: 'Point',
+            coordinates: this.markerCoordinates
+        };
+    }
+    ngOnInit() {
+        this.mapId = this.mapId ? this.mapId : 'map' + MapComponent.idCounter++;
+    }
+    ngAfterViewInit() {
+        this.loaded$.subscribe((loaded) => {
+            if (loaded) {
+                this.initMap();
+            }
+        });
+    }
+    initMap() {
+        this._map = new ol.Map({
+            target: this.mapId,
+            controls: ol.control.defaults({ attribution: false }),
+            layers: [
+                new ol.layer.Tile({
+                    source: new ol.source.OSM()
+                }),
+                new ol.layer.Vector({
+                    source: this._markerSource,
+                    style: this._markerStyle
+                })
+            ],
+            view: new ol.View({
+                center: ol.proj.fromLonLat(this.center !== undefined ? this.center.coordinates : [0, 0]),
+                zoom: this.zoom
+            })
+        });
+        if (this.center === undefined || this.center === null) {
+            // if the center is not set, we set its default value
+            if ('geolocation' in navigator) {
+                navigator.geolocation.getCurrentPosition((position) => {
+                    this.center = {
+                        type: 'Point',
+                        coordinates: [position.coords.longitude, position.coords.latitude]
+                    };
+                }, (error) => {
+                    this.center = {
+                        type: 'Point',
+                        coordinates: [0, 0]
+                    };
+                });
+            }
+            else {
+                this.center = {
+                    type: 'Point',
+                    coordinates: [0, 0]
+                };
+            }
+        }
+        else {
+            // the center needs the map to be properly set, so if it was set before the map was initialized,
+            // we set the center again to perform necessary adjustements
+            this.center = this.center;
+        }
+        if (this.zoom === undefined || this.zoom === null) {
+            // if the zoom is not set, we set its default value
+            this.zoom = 18;
+        }
+        else {
+            // the zoom needs the map to be properly set, so if it was set before the map was initialized,
+            // we set the zoom again to perform necessary adjustements
+            this.zoom = this.zoom;
+        }
+        if (this.readonly === undefined || this.readonly === null) {
+            // if readonly is not set, we set its default value
+            this.readonly = false;
+        }
+        else {
+            // readonly needs the map to be properly set, so if it was set before the map was initialized,
+            // we set readonly again to perform necessary adjustements
+            this.readonly = this.readonly;
+        }
+        if (this.markerCoordinates !== undefined &&
+            this.markerCoordinates !== null) {
+            // the marker coordinates need the map to be properly set, so if they were set before the map was initialized,
+            // we set the marker coordinates again to perform necessary adjustements
+            this.markerCoordinates = this.markerCoordinates;
+        }
+    }
+    addMarkerAtCoordinates(coordinates) {
+        if (coordinates && coordinates.length === 2) {
+            if (this._marker !== undefined) {
+                this.removeMarker();
+            }
+            this._marker = new ol.Feature({
+                geometry: new ol.geom.Point(
+                // [lon, lat] is in EPSG:4326 (degrees), we transform it into EPSG:3857 (meters)
+                ol.proj.transform(coordinates, 'EPSG:4326', 'EPSG:3857'))
+            });
+            this._markerSource.addFeature(this._marker);
+            this._markerCoordinates = this.getMarkerCoordinates();
+            if (!this.readonly) {
+                const dragInteraction = new ol.interaction.Modify({
+                    features: new ol.Collection([this._marker]),
+                    style: this._markerStyle,
+                    pixelTolerance: 50,
+                    hitDetection: true
+                });
+                this._markerInteraction = dragInteraction;
+                this._map.addInteraction(dragInteraction);
+            }
+            this._marker.on('change', () => {
+                this._markerCoordinates = this.getMarkerCoordinates();
+            }, this._marker);
+        }
+    }
+    removeMarker() {
+        if (this._marker !== undefined) {
+            this._markerSource.removeFeature(this._marker);
+            this._marker = undefined;
+        }
+        if (this._markerInteraction !== undefined) {
+            this._map.getInteractions().pop();
+            this._markerInteraction = undefined;
+        }
+    }
+    getMarkerCoordinates() {
+        if (this._marker === undefined || this._marker == null) {
+            return this._marker;
+        }
+        const coordinates = this._marker.getGeometry().getCoordinates();
+        // coordinates is in EPSG:3857 (meters), we transform it into EPSG:4326 (degrees)
+        return ol.proj.transform(coordinates, 'EPSG:3857', 'EPSG:4326');
+    }
+    onResize() {
+        if (this._map) {
+            this._map.updateSize();
+        }
+    }
+}
+MapComponent.idCounter = 0;
+MapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MapComponent, deps: [{ token: i1.OpenLayerLoaderService }], target: i0.ɵɵFactoryTarget.Component });
+MapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: MapComponent, selector: "lux-map", inputs: { mapId: "mapId", zoom: "zoom", center: "center", readonly: "readonly", markerCoordinates: "markerCoordinates", markerPoint: "markerPoint" }, outputs: { valueChange: "valueChange" }, ngImport: i0, template: "<div [id]=\"mapId\" class=\"map\" (resized)=\"onResize()\"></div>\n", styles: [".map{min-height:100px;height:100%;min-width:160px;width:100%}\n"], directives: [{ type: i2.ResizedDirective, selector: "[resized]", outputs: ["resized"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lux-map', template: "<div [id]=\"mapId\" class=\"map\" (resized)=\"onResize()\"></div>\n", styles: [".map{min-height:100px;height:100%;min-width:160px;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.OpenLayerLoaderService }]; }, propDecorators: { mapId: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], center: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], markerCoordinates: [{
+                type: Input
+            }], markerPoint: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.component.js","sourceRoot":"","sources":["../../../../../projects/lux/src/lib/map/map.component.ts","../../../../../projects/lux/src/lib/map/map.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  OnInit,\n  AfterViewInit\n} from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { OpenLayerLoaderService } from '../geolocation/openlayer-loader.service';\n\nimport { GeoPoint } from './geopoint';\n\n// @dynamic\ndeclare const ol: any;\n\n@Component({\n  selector: 'lux-map',\n  templateUrl: './map.component.html',\n  styleUrls: ['./map.component.scss']\n})\nexport class MapComponent implements OnInit, AfterViewInit {\n  static idCounter = 0;\n\n  private loaded$: BehaviorSubject<boolean> = new BehaviorSubject(false);\n\n  private _map: any;\n\n  @Input() mapId;\n\n  _zoom: number;\n  @Input()\n  set zoom(zoom: number) {\n    if (!isNaN(zoom)) {\n      this._zoom = zoom;\n      if (this._map) {\n        this._map.getView().setZoom(zoom);\n      }\n    }\n  }\n  get zoom(): number {\n    return this._zoom;\n  }\n\n  _center: GeoPoint;\n  @Input()\n  set center(center: GeoPoint) {\n    if (center && center.coordinates && center.coordinates.length === 2) {\n      this._center = center;\n      if (this._map) {\n        this._map.getView().setCenter(ol.proj.fromLonLat(center.coordinates));\n      }\n    }\n  }\n  get center(): GeoPoint {\n    return this._center;\n  }\n\n  _readonly: boolean;\n  @Input()\n  set readonly(readonly: boolean) {\n    if (!readonly) {\n      if (this._map) {\n        this._map.on('click', (args: any) => {\n          // args.coordinate is in EPSG:3857 (meters), we transform it into EPSG:4326 (degrees)\n          const coordinates = ol.proj.toLonLat(args.coordinate);\n          // alternatively: const lonLat = ol.proj.transform(args.coordinate,'EPSG:3857','EPSG:4326');\n          this.addMarkerAtCoordinates(coordinates);\n        });\n        this._map.on('pointermove', (event: any) => {\n          const pixel = this._map.getEventPixel(event.originalEvent);\n          const hit = this._map.hasFeatureAtPixel(pixel);\n          this._map.getViewport().style.cursor = hit ? 'move' : 'grab';\n        });\n      }\n    } else {\n      if (this._map) {\n        this._map.on('click', (args: any) => {});\n        this._map.on('pointermove', (event: any) => {});\n        this._map.getViewport().style.cursor = 'grab';\n      }\n    }\n    this._readonly = readonly;\n    // reset marker coordinates so marker interactions can be created or recreated accordingly\n    // to the changes to readonly\n    this.markerCoordinates = this.markerCoordinates;\n  }\n  get readonly(): boolean {\n    return this._readonly;\n  }\n\n  private _marker: any;\n  private _markerInteraction: any;\n  private _markerCoordinates: number[];\n  @Input()\n  private set markerCoordinates(markerCoordinates: number[]) {\n    if (markerCoordinates && markerCoordinates.length === 2) {\n      this._markerCoordinates = markerCoordinates;\n      if (this._map) {\n        this.addMarkerAtCoordinates(markerCoordinates);\n      }\n    } else {\n      this._markerCoordinates = undefined;\n      if (this._map) {\n        this.removeMarker();\n      }\n    }\n  }\n  private get markerCoordinates(): number[] {\n    return this._markerCoordinates;\n  }\n  @Input()\n  set markerPoint(markerPoint: GeoPoint) {\n    if (\n      !markerPoint ||\n      !(markerPoint.coordinates && markerPoint.coordinates.length === 2)\n    ) {\n      this.markerCoordinates = undefined;\n    } else {\n      this.markerCoordinates = [\n        +markerPoint.coordinates[0],\n        +markerPoint.coordinates[1]\n      ];\n    }\n    this.valueChange.emit(markerPoint);\n  }\n  get markerPoint(): GeoPoint {\n    return {\n      type: 'Point',\n      coordinates: this.markerCoordinates\n    };\n  }\n  @Output() valueChange = new EventEmitter<GeoPoint>();\n\n  private _markerSource: any;\n  private _markerStyle: any;\n\n  constructor(olLoader: OpenLayerLoaderService) {\n    olLoader.load().subscribe((_) => {\n      // Initialize\n      this._markerSource = new ol.source.Vector();\n      this._markerStyle = new ol.style.Style({\n        image: new ol.style.Icon({\n          anchor: [0.5, 1],\n          scale: 0.25,\n          src: '/assets/img/marker.png'\n        })\n      });\n      this.loaded$.next(true);\n    });\n  }\n\n  ngOnInit(): void {\n    this.mapId = this.mapId ? this.mapId : 'map' + MapComponent.idCounter++;\n  }\n\n  ngAfterViewInit(): void {\n    this.loaded$.subscribe((loaded) => {\n      if (loaded) {\n        this.initMap();\n      }\n    });\n  }\n  private initMap(): void {\n    this._map = new ol.Map({\n      target: this.mapId,\n      controls: ol.control.defaults({ attribution: false }),\n      layers: [\n        new ol.layer.Tile({\n          source: new ol.source.OSM()\n        }),\n        new ol.layer.Vector({\n          source: this._markerSource,\n          style: this._markerStyle\n        })\n      ],\n      view: new ol.View({\n        center: ol.proj.fromLonLat(\n          this.center !== undefined ? this.center.coordinates : [0, 0]\n        ),\n        zoom: this.zoom\n      })\n    });\n\n    if (this.center === undefined || this.center === null) {\n      // if the center is not set, we set its default value\n      if ('geolocation' in navigator) {\n        navigator.geolocation.getCurrentPosition(\n          (position) => {\n            this.center = {\n              type: 'Point',\n              coordinates: [position.coords.longitude, position.coords.latitude]\n            };\n          },\n          (error) => {\n            this.center = {\n              type: 'Point',\n              coordinates: [0, 0]\n            };\n          }\n        );\n      } else {\n        this.center = {\n          type: 'Point',\n          coordinates: [0, 0]\n        };\n      }\n    } else {\n      // the center needs the map to be properly set, so if it was set before the map was initialized,\n      // we set the center again to perform necessary adjustements\n      this.center = this.center;\n    }\n\n    if (this.zoom === undefined || this.zoom === null) {\n      // if the zoom is not set, we set its default value\n      this.zoom = 18;\n    } else {\n      // the zoom needs the map to be properly set, so if it was set before the map was initialized,\n      // we set the zoom again to perform necessary adjustements\n      this.zoom = this.zoom;\n    }\n\n    if (this.readonly === undefined || this.readonly === null) {\n      // if readonly is not set, we set its default value\n      this.readonly = false;\n    } else {\n      // readonly needs the map to be properly set, so if it was set before the map was initialized,\n      // we set readonly again to perform necessary adjustements\n      this.readonly = this.readonly;\n    }\n\n    if (\n      this.markerCoordinates !== undefined &&\n      this.markerCoordinates !== null\n    ) {\n      // the marker coordinates need the map to be properly set, so if they were set before the map was initialized,\n      // we set the marker coordinates again to perform necessary adjustements\n      this.markerCoordinates = this.markerCoordinates;\n    }\n  }\n\n  private addMarkerAtCoordinates(coordinates: number[]): void {\n    if (coordinates && coordinates.length === 2) {\n      if (this._marker !== undefined) {\n        this.removeMarker();\n      }\n      this._marker = new ol.Feature({\n        geometry: new ol.geom.Point(\n          // [lon, lat] is in EPSG:4326 (degrees), we transform it into EPSG:3857 (meters)\n          ol.proj.transform(coordinates, 'EPSG:4326', 'EPSG:3857')\n        )\n      });\n      this._markerSource.addFeature(this._marker);\n      this._markerCoordinates = this.getMarkerCoordinates();\n\n      if (!this.readonly) {\n        const dragInteraction = new ol.interaction.Modify({\n          features: new ol.Collection([this._marker]),\n          style: this._markerStyle,\n          pixelTolerance: 50,\n          hitDetection: true\n        });\n        this._markerInteraction = dragInteraction;\n        this._map.addInteraction(dragInteraction);\n      }\n\n      this._marker.on(\n        'change',\n        () => {\n          this._markerCoordinates = this.getMarkerCoordinates();\n        },\n        this._marker\n      );\n    }\n  }\n\n  private removeMarker(): void {\n    if (this._marker !== undefined) {\n      this._markerSource.removeFeature(this._marker);\n      this._marker = undefined;\n    }\n    if (this._markerInteraction !== undefined) {\n      this._map.getInteractions().pop();\n      this._markerInteraction = undefined;\n    }\n  }\n\n  private getMarkerCoordinates(): number[] | null {\n    if (this._marker === undefined || this._marker == null) {\n      return this._marker;\n    }\n    const coordinates = this._marker.getGeometry().getCoordinates();\n    // coordinates is in EPSG:3857 (meters), we transform it into EPSG:4326 (degrees)\n    return ol.proj.transform(coordinates, 'EPSG:3857', 'EPSG:4326');\n  }\n\n  onResize(): void {\n    if (this._map) {\n      this._map.updateSize();\n    }\n  }\n}\n","<div [id]=\"mapId\" class=\"map\" (resized)=\"onResize()\"></div>\n"]}

package/esm2020/lib/modal/modal-backdrop.mjs

@@ -0,0 +1,26 @@
+import { Component, Input, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LuxModalBackdropComponent {
+    constructor() {
+        this.class = 'modal-backdrop fade show';
+        this.style = 'z-index: 1050';
+    }
+}
+LuxModalBackdropComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModalBackdropComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LuxModalBackdropComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: LuxModalBackdropComponent, selector: "lux-modal-backdrop", inputs: { backdropClass: "backdropClass" }, host: { properties: { "class": "this.class", "style": "this.style" } }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModalBackdropComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lux-modal-backdrop',
+                    template: ''
+                }]
+        }], propDecorators: { backdropClass: [{
+                type: Input
+            }], class: [{
+                type: HostBinding,
+                args: ['class']
+            }], style: [{
+                type: HostBinding,
+                args: ['style']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtYmFja2Ryb3AuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sdXgvc3JjL2xpYi9tb2RhbC9tb2RhbC1iYWNrZHJvcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBTTVELE1BQU0sT0FBTyx5QkFBeUI7SUFKdEM7UUFPd0IsVUFBSyxHQUFHLDBCQUEwQixDQUFDO1FBQ25DLFVBQUssR0FBRyxlQUFlLENBQUM7S0FDL0M7O3NIQUxZLHlCQUF5QjswR0FBekIseUJBQXlCLDhLQUYxQixFQUFFOzJGQUVELHlCQUF5QjtrQkFKckMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsb0JBQW9CO29CQUM5QixRQUFRLEVBQUUsRUFBRTtpQkFDYjs4QkFFVSxhQUFhO3NCQUFyQixLQUFLO2dCQUVnQixLQUFLO3NCQUExQixXQUFXO3VCQUFDLE9BQU87Z0JBQ0UsS0FBSztzQkFBMUIsV0FBVzt1QkFBQyxPQUFPIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21wb25lbnQsIElucHV0LCBIb3N0QmluZGluZ30gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2x1eC1tb2RhbC1iYWNrZHJvcCcsXG4gIHRlbXBsYXRlOiAnJ1xufSlcbmV4cG9ydCBjbGFzcyBMdXhNb2RhbEJhY2tkcm9wQ29tcG9uZW50IHtcbiAgQElucHV0KCkgYmFja2Ryb3BDbGFzczogc3RyaW5nO1xuXG4gIEBIb3N0QmluZGluZygnY2xhc3MnKSBjbGFzcyA9ICdtb2RhbC1iYWNrZHJvcCBmYWRlIHNob3cnO1xuICBASG9zdEJpbmRpbmcoJ3N0eWxlJykgc3R5bGUgPSAnei1pbmRleDogMTA1MCc7XG59XG4iXX0=

package/esm2020/lib/modal/modal-config.mjs

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LuxModalConfig {
+    constructor() {
+        this.backdrop = true;
+    }
+}
+LuxModalConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModalConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LuxModalConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModalConfig, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LuxModalConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbHV4L3NyYy9saWIvbW9kYWwvbW9kYWwtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBWTNDLE1BQU0sT0FBTyxjQUFjO0lBRDNCO1FBRUUsYUFBUSxHQUFHLElBQUksQ0FBQztLQUNqQjs7MkdBRlksY0FBYzsrR0FBZCxjQUFjLGNBREQsTUFBTTsyRkFDbkIsY0FBYztrQkFEMUIsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTHV4TW9kYWxPcHRpb25zIHtcbiAgYXJpYURlc2NyaWJlZEJ5Pzogc3RyaW5nO1xuICBhcmlhTGFiZWxsZWRCeT86IHN0cmluZztcbiAgYmFja2Ryb3A/OiBib29sZWFuO1xuICBrZXlib2FyZD86IGJvb2xlYW47XG4gIHdpbmRvd0NsYXNzPzogc3RyaW5nO1xuICBiYWNrZHJvcENsYXNzPzogc3RyaW5nO1xufVxuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIEx1eE1vZGFsQ29uZmlnIGltcGxlbWVudHMgTHV4TW9kYWxPcHRpb25zIHtcbiAgYmFja2Ryb3AgPSB0cnVlO1xufVxuIl19