@metadev/lux 0.26.0 → 0.28.0

package/esm2022/lib/map/map.component.mjs

@@ -0,0 +1,275 @@
+/* eslint-disable no-self-assign */
+import { Component, EventEmitter, Input, Output } 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";
+export class MapComponent {
+    static idCounter = 0;
+    loaded$ = new BehaviorSubject(false);
+    _map;
+    mapId;
+    _zoom;
+    set zoom(zoom) {
+        if (!isNaN(zoom)) {
+            this._zoom = zoom;
+            if (this._map) {
+                this._map.getView().setZoom(zoom);
+            }
+        }
+    }
+    get zoom() {
+        return this._zoom;
+    }
+    _center;
+    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;
+    }
+    _readonly;
+    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;
+    }
+    _marker;
+    _markerInteraction;
+    _markerCoordinates;
+    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
+        };
+    }
+    valueChange = new EventEmitter();
+    _markerSource;
+    _markerStyle;
+    constructor(olLoader) {
+        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);
+        });
+    }
+    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();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: MapComponent, deps: [{ token: i1.OpenLayerLoaderService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.4", 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"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", 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: () => [{ 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":["/* eslint-disable no-self-assign */\n\nimport {\n  AfterViewInit,\n  Component,\n  EventEmitter,\n  Input,\n  OnInit,\n  Output\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/esm2022/lib/modal/modal-backdrop.mjs

@@ -0,0 +1,25 @@
+import { Component, Input, HostBinding } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LuxModalBackdropComponent {
+    backdropClass;
+    class = 'modal-backdrop fade show';
+    style = 'z-index: 1050';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: LuxModalBackdropComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.4", 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: "17.0.4", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtYmFja2Ryb3AuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sdXgvc3JjL2xpYi9tb2RhbC9tb2RhbC1iYWNrZHJvcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxXQUFXLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBTTVELE1BQU0sT0FBTyx5QkFBeUI7SUFDM0IsYUFBYSxDQUFTO0lBRVQsS0FBSyxHQUFHLDBCQUEwQixDQUFDO0lBQ25DLEtBQUssR0FBRyxlQUFlLENBQUM7dUdBSm5DLHlCQUF5QjsyRkFBekIseUJBQXlCLDhLQUYxQixFQUFFOzsyRkFFRCx5QkFBeUI7a0JBSnJDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtvQkFDOUIsUUFBUSxFQUFFLEVBQUU7aUJBQ2I7OEJBRVUsYUFBYTtzQkFBckIsS0FBSztnQkFFZ0IsS0FBSztzQkFBMUIsV0FBVzt1QkFBQyxPQUFPO2dCQUNFLEtBQUs7c0JBQTFCLFdBQVc7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q29tcG9uZW50LCBJbnB1dCwgSG9zdEJpbmRpbmd9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdsdXgtbW9kYWwtYmFja2Ryb3AnLFxuICB0ZW1wbGF0ZTogJydcbn0pXG5leHBvcnQgY2xhc3MgTHV4TW9kYWxCYWNrZHJvcENvbXBvbmVudCB7XG4gIEBJbnB1dCgpIGJhY2tkcm9wQ2xhc3M6IHN0cmluZztcblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzJykgY2xhc3MgPSAnbW9kYWwtYmFja2Ryb3AgZmFkZSBzaG93JztcbiAgQEhvc3RCaW5kaW5nKCdzdHlsZScpIHN0eWxlID0gJ3otaW5kZXg6IDEwNTAnO1xufVxuIl19

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

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

package/{esm2020 → esm2022}/lib/modal/modal-dismiss-reasons.mjs

@@ -1,6 +1,6 @@
-export var ModalDismissReasons;
-(function (ModalDismissReasons) {
-    ModalDismissReasons[ModalDismissReasons["BackdropClick"] = 0] = "BackdropClick";
-    ModalDismissReasons[ModalDismissReasons["Esc"] = 1] = "Esc";
-})(ModalDismissReasons || (ModalDismissReasons = {}));
+export var ModalDismissReasons;
+(function (ModalDismissReasons) {
+    ModalDismissReasons[ModalDismissReasons["BackdropClick"] = 0] = "BackdropClick";
+    ModalDismissReasons[ModalDismissReasons["Esc"] = 1] = "Esc";
+})(ModalDismissReasons || (ModalDismissReasons = {}));
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtZGlzbWlzcy1yZWFzb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbHV4L3NyYy9saWIvbW9kYWwvbW9kYWwtZGlzbWlzcy1yZWFzb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLG1CQUdYO0FBSEQsV0FBWSxtQkFBbUI7SUFDM0IsK0VBQWEsQ0FBQTtJQUNiLDJEQUFHLENBQUE7QUFDUCxDQUFDLEVBSFcsbUJBQW1CLEtBQW5CLG1CQUFtQixRQUc5QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIE1vZGFsRGlzbWlzc1JlYXNvbnMge1xuICAgIEJhY2tkcm9wQ2xpY2ssXG4gICAgRXNjXG59XG4iXX0=

package/esm2022/lib/modal/modal-ref.mjs

@@ -0,0 +1,101 @@
+export class ActiveModal {
+    close(result) { }
+    dismiss(reason) { }
+}
+export class ModalRef {
+    _windowCmptRef;
+    _contentRef;
+    _backdropCmptRef;
+    _beforeDismiss;
+    _resolve;
+    _reject;
+    /**
+     * The instance of a component used for the modal content.
+     *
+     * When a `TemplateRef` is used as the content, will return `undefined`.
+     */
+    get componentInstance() {
+        if (this._contentRef.componentRef) {
+            return this._contentRef.componentRef.instance;
+        }
+    }
+    /**
+     * The promise that is resolved when the modal is closed and rejected when the modal is dismissed.
+     */
+    result;
+    constructor(_windowCmptRef, _contentRef, _backdropCmptRef, _beforeDismiss) {
+        this._windowCmptRef = _windowCmptRef;
+        this._contentRef = _contentRef;
+        this._backdropCmptRef = _backdropCmptRef;
+        this._beforeDismiss = _beforeDismiss;
+        _windowCmptRef.instance.dismissEvent.subscribe((reason) => {
+            this.dismiss(reason);
+        });
+        this.result = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this.result.then(null, () => { });
+    }
+    /**
+     * Closes the modal with an optional `result` value.
+     *
+     * The `NgbMobalRef.result` promise will be resolved with the provided value.
+     */
+    close(result) {
+        if (this._windowCmptRef) {
+            if (this._resolve) {
+                this._resolve(result);
+            }
+            this._removeModalElements();
+        }
+    }
+    _dismiss(reason) {
+        if (this._reject) {
+            this._reject(reason);
+        }
+        this._removeModalElements();
+    }
+    /**
+     * Dismisses the modal with an optional `reason` value.
+     *
+     * The `NgbModalRef.result` promise will be rejected with the provided value.
+     */
+    dismiss(reason) {
+        if (this._windowCmptRef) {
+            if (!this._beforeDismiss) {
+                this._dismiss(reason);
+            }
+            else {
+                const dismiss = this._beforeDismiss();
+                if (dismiss && dismiss.then) {
+                    dismiss.then((result) => {
+                        if (result !== false) {
+                            this._dismiss(reason);
+                        }
+                    }, () => { });
+                }
+                else if (dismiss !== false) {
+                    this._dismiss(reason);
+                }
+            }
+        }
+    }
+    _removeModalElements() {
+        const windowNativeEl = this._windowCmptRef.location.nativeElement;
+        windowNativeEl.parentNode.removeChild(windowNativeEl);
+        this._windowCmptRef.destroy();
+        if (this._backdropCmptRef) {
+            const backdropNativeEl = this._backdropCmptRef.location.nativeElement;
+            backdropNativeEl.parentNode.removeChild(backdropNativeEl);
+            this._backdropCmptRef.destroy();
+        }
+        if (this._contentRef && this._contentRef.viewRef) {
+            this._contentRef.viewRef.destroy();
+        }
+        this._windowCmptRef = null;
+        this._backdropCmptRef = null;
+        this._contentRef = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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