@bluehalo/ngx-leaflet 18.0.2

package/esm2022/bluehalo-ngx-leaflet.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmx1ZWhhbG8tbmd4LWxlYWZsZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGVhZmxldC9zcmMvYmx1ZWhhbG8tbmd4LWxlYWZsZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/core/leaflet.directive.mjs

@@ -0,0 +1,330 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { latLng, map } from 'leaflet';
+import { LeafletUtil } from './leaflet.util';
+import * as i0 from "@angular/core";
+export class LeafletDirective {
+    constructor(element, zone) {
+        this.element = element;
+        this.zone = zone;
+        this.DEFAULT_ZOOM = 1;
+        this.DEFAULT_CENTER = latLng(38.907192, -77.036871);
+        this.DEFAULT_FPZ_OPTIONS = {};
+        this.fitBoundsOptions = this.DEFAULT_FPZ_OPTIONS;
+        this.panOptions = this.DEFAULT_FPZ_OPTIONS;
+        this.zoomOptions = this.DEFAULT_FPZ_OPTIONS;
+        this.zoomPanOptions = this.DEFAULT_FPZ_OPTIONS;
+        // Default configuration
+        this.options = {};
+        // Configure callback function for the map
+        this.mapReady = new EventEmitter();
+        this.zoomChange = new EventEmitter();
+        this.centerChange = new EventEmitter();
+        // Mouse Map Events
+        this.onClick = new EventEmitter();
+        this.onDoubleClick = new EventEmitter();
+        this.onMouseDown = new EventEmitter();
+        this.onMouseUp = new EventEmitter();
+        this.onMouseMove = new EventEmitter();
+        this.onMouseOver = new EventEmitter();
+        this.onMouseOut = new EventEmitter();
+        // Map Move Events
+        this.onMapMove = new EventEmitter();
+        this.onMapMoveStart = new EventEmitter();
+        this.onMapMoveEnd = new EventEmitter();
+        // Map Zoom Events
+        this.onMapZoom = new EventEmitter();
+        this.onMapZoomStart = new EventEmitter();
+        this.onMapZoomEnd = new EventEmitter();
+        // Nothing here
+    }
+    ngOnInit() {
+        // Create the map outside of angular so the various map events don't trigger change detection
+        this.zone.runOutsideAngular(() => {
+            // Create the map with some reasonable defaults
+            this.map = map(this.element.nativeElement, this.options);
+            this.addMapEventListeners();
+        });
+        // Only setView if there is a center/zoom
+        if (null != this.center && null != this.zoom) {
+            this.setView(this.center, this.zoom);
+        }
+        // Set up all the initial settings
+        if (null != this.fitBounds) {
+            this.setFitBounds(this.fitBounds);
+        }
+        if (null != this.maxBounds) {
+            this.setMaxBounds(this.maxBounds);
+        }
+        if (null != this.minZoom) {
+            this.setMinZoom(this.minZoom);
+        }
+        if (null != this.maxZoom) {
+            this.setMaxZoom(this.maxZoom);
+        }
+        this.doResize();
+        // Fire map ready event
+        this.mapReady.emit(this.map);
+    }
+    ngOnChanges(changes) {
+        /*
+         * The following code is to address an issue with our (basic) implementation of
+         * zooming and panning. From our testing, it seems that a pan operation followed
+         * by a zoom operation in the same thread will interfere with eachother. The zoom
+         * operation interrupts/cancels the pan, resulting in a final center point that is
+         * inaccurate. The solution seems to be to either separate them with a timeout or
+          * to collapse them into a setView call.
+         */
+        // Zooming and Panning
+        if (changes['zoom'] && changes['center'] && null != this.zoom && null != this.center) {
+            this.setView(changes['center'].currentValue, changes['zoom'].currentValue);
+        }
+        // Set the zoom level
+        else if (changes['zoom']) {
+            this.setZoom(changes['zoom'].currentValue);
+        }
+        // Set the map center
+        else if (changes['center']) {
+            this.setCenter(changes['center'].currentValue);
+        }
+        // Other options
+        if (changes['fitBounds']) {
+            this.setFitBounds(changes['fitBounds'].currentValue);
+        }
+        if (changes['maxBounds']) {
+            this.setMaxBounds(changes['maxBounds'].currentValue);
+        }
+        if (changes['minZoom']) {
+            this.setMinZoom(changes['minZoom'].currentValue);
+        }
+        if (changes['maxZoom']) {
+            this.setMaxZoom(changes['maxZoom'].currentValue);
+        }
+    }
+    ngOnDestroy() {
+        // If this directive is destroyed, the map is too
+        if (null != this.map) {
+            this.map.remove();
+        }
+    }
+    getMap() {
+        return this.map;
+    }
+    onResize() {
+        this.delayResize();
+    }
+    addMapEventListeners() {
+        const registerEventHandler = (eventName, handler) => {
+            this.map.on(eventName, handler);
+        };
+        // Add all the pass-through mouse event handlers
+        registerEventHandler('click', (e) => LeafletUtil.handleEvent(this.zone, this.onClick, e));
+        registerEventHandler('dblclick', (e) => LeafletUtil.handleEvent(this.zone, this.onDoubleClick, e));
+        registerEventHandler('mousedown', (e) => LeafletUtil.handleEvent(this.zone, this.onMouseDown, e));
+        registerEventHandler('mouseup', (e) => LeafletUtil.handleEvent(this.zone, this.onMouseUp, e));
+        registerEventHandler('mouseover', (e) => LeafletUtil.handleEvent(this.zone, this.onMouseOver, e));
+        registerEventHandler('mouseout', (e) => LeafletUtil.handleEvent(this.zone, this.onMouseOut, e));
+        registerEventHandler('mousemove', (e) => LeafletUtil.handleEvent(this.zone, this.onMouseMove, e));
+        registerEventHandler('zoomstart', (e) => LeafletUtil.handleEvent(this.zone, this.onMapZoomStart, e));
+        registerEventHandler('zoom', (e) => LeafletUtil.handleEvent(this.zone, this.onMapZoom, e));
+        registerEventHandler('zoomend', (e) => LeafletUtil.handleEvent(this.zone, this.onMapZoomEnd, e));
+        registerEventHandler('movestart', (e) => LeafletUtil.handleEvent(this.zone, this.onMapMoveStart, e));
+        registerEventHandler('move', (e) => LeafletUtil.handleEvent(this.zone, this.onMapMove, e));
+        registerEventHandler('moveend', (e) => LeafletUtil.handleEvent(this.zone, this.onMapMoveEnd, e));
+        // Update any things for which we provide output bindings
+        const outputUpdateHandler = () => {
+            const zoom = this.map.getZoom();
+            if (zoom !== this.zoom) {
+                this.zoom = zoom;
+                LeafletUtil.handleEvent(this.zone, this.zoomChange, zoom);
+            }
+            const center = this.map.getCenter();
+            if (null != center || null != this.center) {
+                if (((null == center || null == this.center) && center !== this.center)
+                    || (center.lat !== this.center.lat || center.lng !== this.center.lng)) {
+                    this.center = center;
+                    LeafletUtil.handleEvent(this.zone, this.centerChange, center);
+                }
+            }
+        };
+        registerEventHandler('moveend', outputUpdateHandler);
+        registerEventHandler('zoomend', outputUpdateHandler);
+    }
+    /**
+     * Resize the map to fit it's parent container
+     */
+    doResize() {
+        // Run this outside of angular so the map events stay outside of angular
+        this.zone.runOutsideAngular(() => {
+            // Invalidate the map size to trigger it to update itself
+            if (null != this.map) {
+                this.map.invalidateSize({});
+            }
+        });
+    }
+    /**
+     * Manage a delayed resize of the component
+     */
+    delayResize() {
+        if (null != this.resizeTimer) {
+            clearTimeout(this.resizeTimer);
+        }
+        this.resizeTimer = setTimeout(this.doResize.bind(this), 200);
+    }
+    /**
+     * Set the view (center/zoom) all at once
+     * @param center The new center
+     * @param zoom The new zoom level
+     */
+    setView(center, zoom) {
+        if (null != this.map && null != center && null != zoom) {
+            this.map.setView(center, zoom, this.zoomPanOptions);
+        }
+    }
+    /**
+     * Set the map zoom level
+     * @param zoom the new zoom level for the map
+     */
+    setZoom(zoom) {
+        if (null != this.map && null != zoom) {
+            this.map.setZoom(zoom, this.zoomOptions);
+        }
+    }
+    /**
+     * Set the center of the map
+     * @param center the center point
+     */
+    setCenter(center) {
+        if (null != this.map && null != center) {
+            this.map.panTo(center, this.panOptions);
+        }
+    }
+    /**
+     * Fit the map to the bounds
+     * @param latLngBounds the boundary to set
+     */
+    setFitBounds(latLngBounds) {
+        if (null != this.map && null != latLngBounds) {
+            this.map.fitBounds(latLngBounds, this.fitBoundsOptions);
+        }
+    }
+    /**
+     * Set the map's max bounds
+     * @param latLngBounds the boundary to set
+     */
+    setMaxBounds(latLngBounds) {
+        if (null != this.map && null != latLngBounds) {
+            this.map.setMaxBounds(latLngBounds);
+        }
+    }
+    /**
+     * Set the map's min zoom
+     * @param number the new min zoom
+     */
+    setMinZoom(zoom) {
+        if (null != this.map && null != zoom) {
+            this.map.setMinZoom(zoom);
+        }
+    }
+    /**
+     * Set the map's min zoom
+     * @param number the new min zoom
+     */
+    setMaxZoom(zoom) {
+        if (null != this.map && null != zoom) {
+            this.map.setMaxZoom(zoom);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.1", type: LeafletDirective, selector: "[leaflet]", inputs: { fitBoundsOptions: ["leafletFitBoundsOptions", "fitBoundsOptions"], panOptions: ["leafletPanOptions", "panOptions"], zoomOptions: ["leafletZoomOptions", "zoomOptions"], zoomPanOptions: ["leafletZoomPanOptions", "zoomPanOptions"], options: ["leafletOptions", "options"], zoom: ["leafletZoom", "zoom"], center: ["leafletCenter", "center"], fitBounds: ["leafletFitBounds", "fitBounds"], maxBounds: ["leafletMaxBounds", "maxBounds"], minZoom: ["leafletMinZoom", "minZoom"], maxZoom: ["leafletMaxZoom", "maxZoom"] }, outputs: { mapReady: "leafletMapReady", zoomChange: "leafletZoomChange", centerChange: "leafletCenterChange", onClick: "leafletClick", onDoubleClick: "leafletDoubleClick", onMouseDown: "leafletMouseDown", onMouseUp: "leafletMouseUp", onMouseMove: "leafletMouseMove", onMouseOver: "leafletMouseOver", onMouseOut: "leafletMouseOut", onMapMove: "leafletMapMove", onMapMoveStart: "leafletMapMoveStart", onMapMoveEnd: "leafletMapMoveEnd", onMapZoom: "leafletMapZoom", onMapZoomStart: "leafletMapZoomStart", onMapZoomEnd: "leafletMapZoomEnd" }, host: { listeners: { "window:resize": "onResize()" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[leaflet]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { fitBoundsOptions: [{
+                type: Input,
+                args: ['leafletFitBoundsOptions']
+            }], panOptions: [{
+                type: Input,
+                args: ['leafletPanOptions']
+            }], zoomOptions: [{
+                type: Input,
+                args: ['leafletZoomOptions']
+            }], zoomPanOptions: [{
+                type: Input,
+                args: ['leafletZoomPanOptions']
+            }], options: [{
+                type: Input,
+                args: ['leafletOptions']
+            }], mapReady: [{
+                type: Output,
+                args: ['leafletMapReady']
+            }], zoom: [{
+                type: Input,
+                args: ['leafletZoom']
+            }], zoomChange: [{
+                type: Output,
+                args: ['leafletZoomChange']
+            }], center: [{
+                type: Input,
+                args: ['leafletCenter']
+            }], centerChange: [{
+                type: Output,
+                args: ['leafletCenterChange']
+            }], fitBounds: [{
+                type: Input,
+                args: ['leafletFitBounds']
+            }], maxBounds: [{
+                type: Input,
+                args: ['leafletMaxBounds']
+            }], minZoom: [{
+                type: Input,
+                args: ['leafletMinZoom']
+            }], maxZoom: [{
+                type: Input,
+                args: ['leafletMaxZoom']
+            }], onClick: [{
+                type: Output,
+                args: ['leafletClick']
+            }], onDoubleClick: [{
+                type: Output,
+                args: ['leafletDoubleClick']
+            }], onMouseDown: [{
+                type: Output,
+                args: ['leafletMouseDown']
+            }], onMouseUp: [{
+                type: Output,
+                args: ['leafletMouseUp']
+            }], onMouseMove: [{
+                type: Output,
+                args: ['leafletMouseMove']
+            }], onMouseOver: [{
+                type: Output,
+                args: ['leafletMouseOver']
+            }], onMouseOut: [{
+                type: Output,
+                args: ['leafletMouseOut']
+            }], onMapMove: [{
+                type: Output,
+                args: ['leafletMapMove']
+            }], onMapMoveStart: [{
+                type: Output,
+                args: ['leafletMapMoveStart']
+            }], onMapMoveEnd: [{
+                type: Output,
+                args: ['leafletMapMoveEnd']
+            }], onMapZoom: [{
+                type: Output,
+                args: ['leafletMapZoom']
+            }], onMapZoomStart: [{
+                type: Output,
+                args: ['leafletMapZoomStart']
+            }], onMapZoomEnd: [{
+                type: Output,
+                args: ['leafletMapZoomEnd']
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize', []]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leaflet.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-leaflet/src/lib/core/leaflet.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tDirective, ElementRef, EventEmitter, HostListener, Input, NgZone, OnChanges, OnDestroy, OnInit, Output,\n\tSimpleChange\n} from '@angular/core';\n\nimport { latLng, LatLng, LatLngBounds, LeafletEvent, LeafletMouseEvent, map, Map, MapOptions } from 'leaflet';\n\nimport { LeafletUtil } from './leaflet.util';\n\n@Directive({\n\tselector: '[leaflet]'\n})\nexport class LeafletDirective\n\timplements OnChanges, OnDestroy, OnInit {\n\n\treadonly DEFAULT_ZOOM = 1;\n\treadonly DEFAULT_CENTER = latLng(38.907192, -77.036871);\n\treadonly DEFAULT_FPZ_OPTIONS = {};\n\n\tresizeTimer: any;\n\n\t// Reference to the primary map object\n\tmap: Map;\n\n\t@Input('leafletFitBoundsOptions') fitBoundsOptions = this.DEFAULT_FPZ_OPTIONS;\n\t@Input('leafletPanOptions') panOptions = this.DEFAULT_FPZ_OPTIONS;\n\t@Input('leafletZoomOptions') zoomOptions = this.DEFAULT_FPZ_OPTIONS;\n\t@Input('leafletZoomPanOptions') zoomPanOptions = this.DEFAULT_FPZ_OPTIONS;\n\n\n\t// Default configuration\n\t@Input('leafletOptions') options: MapOptions = {};\n\n\t// Configure callback function for the map\n\t@Output('leafletMapReady') mapReady = new EventEmitter<Map>();\n\n\t// Zoom level for the map\n\t@Input('leafletZoom') zoom: number;\n\t@Output('leafletZoomChange') zoomChange = new EventEmitter<number>();\n\n\t// Center of the map\n\t@Input('leafletCenter') center: LatLng;\n\t@Output('leafletCenterChange') centerChange = new EventEmitter<LatLng>();\n\n\t// Set fit bounds for map\n\t@Input('leafletFitBounds') fitBounds: LatLngBounds;\n\n\t// Set the max bounds for the map\n\t@Input('leafletMaxBounds') maxBounds: LatLngBounds;\n\n\t// Set the min zoom for the map\n\t@Input('leafletMinZoom') minZoom: number;\n\n\t// Set the max zoom for the map\n\t@Input('leafletMaxZoom') maxZoom: number;\n\n\n\t// Mouse Map Events\n\t@Output('leafletClick') onClick = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletDoubleClick') onDoubleClick = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletMouseDown') onMouseDown = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletMouseUp') onMouseUp = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletMouseMove') onMouseMove = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletMouseOver') onMouseOver = new EventEmitter<LeafletMouseEvent>();\n\t@Output('leafletMouseOut') onMouseOut = new EventEmitter<LeafletMouseEvent>();\n\n\t// Map Move Events\n\t@Output('leafletMapMove') onMapMove = new EventEmitter<LeafletEvent>();\n\t@Output('leafletMapMoveStart') onMapMoveStart = new EventEmitter<LeafletEvent>();\n\t@Output('leafletMapMoveEnd') onMapMoveEnd = new EventEmitter<LeafletEvent>();\n\n\t// Map Zoom Events\n\t@Output('leafletMapZoom') onMapZoom = new EventEmitter<LeafletEvent>();\n\t@Output('leafletMapZoomStart') onMapZoomStart = new EventEmitter<LeafletEvent>();\n\t@Output('leafletMapZoomEnd') onMapZoomEnd = new EventEmitter<LeafletEvent>();\n\n\tconstructor(private element: ElementRef, private zone: NgZone) {\n\t\t// Nothing here\n\t}\n\n\tngOnInit() {\n\n\t\t// Create the map outside of angular so the various map events don't trigger change detection\n\t\tthis.zone.runOutsideAngular(() => {\n\n\t\t\t// Create the map with some reasonable defaults\n\t\t\tthis.map = map(this.element.nativeElement, this.options);\n\t\t\tthis.addMapEventListeners();\n\n\t\t});\n\n\t\t// Only setView if there is a center/zoom\n\t\tif (null != this.center && null != this.zoom) {\n\t\t\tthis.setView(this.center, this.zoom);\n\t\t}\n\n\t\t// Set up all the initial settings\n\t\tif (null != this.fitBounds) {\n\t\t\tthis.setFitBounds(this.fitBounds);\n\t\t}\n\n\t\tif (null != this.maxBounds) {\n\t\t\tthis.setMaxBounds(this.maxBounds);\n\t\t}\n\n\t\tif (null != this.minZoom) {\n\t\t\tthis.setMinZoom(this.minZoom);\n\t\t}\n\n\t\tif (null != this.maxZoom) {\n\t\t\tthis.setMaxZoom(this.maxZoom);\n\t\t}\n\n\t\tthis.doResize();\n\n\t\t// Fire map ready event\n\t\tthis.mapReady.emit(this.map);\n\n\t}\n\n\tngOnChanges(changes: { [key: string]: SimpleChange }) {\n\n\t\t/*\n\t\t * The following code is to address an issue with our (basic) implementation of\n\t\t * zooming and panning. From our testing, it seems that a pan operation followed\n\t\t * by a zoom operation in the same thread will interfere with eachother. The zoom\n\t\t * operation interrupts/cancels the pan, resulting in a final center point that is\n\t\t * inaccurate. The solution seems to be to either separate them with a timeout or\n\t\t  * to collapse them into a setView call.\n\t\t */\n\n\t\t// Zooming and Panning\n\t\tif (changes['zoom'] && changes['center'] && null != this.zoom && null != this.center) {\n\t\t\tthis.setView(changes['center'].currentValue, changes['zoom'].currentValue);\n\t\t}\n\t\t// Set the zoom level\n\t\telse if (changes['zoom']) {\n\t\t\tthis.setZoom(changes['zoom'].currentValue);\n\t\t}\n\t\t// Set the map center\n\t\telse if (changes['center']) {\n\t\t\tthis.setCenter(changes['center'].currentValue);\n\t\t}\n\n\t\t// Other options\n\t\tif (changes['fitBounds']) {\n\t\t\tthis.setFitBounds(changes['fitBounds'].currentValue);\n\t\t}\n\n\t\tif (changes['maxBounds']) {\n\t\t\tthis.setMaxBounds(changes['maxBounds'].currentValue);\n\t\t}\n\n\t\tif (changes['minZoom']) {\n\t\t\tthis.setMinZoom(changes['minZoom'].currentValue);\n\t\t}\n\n\t\tif (changes['maxZoom']) {\n\t\t\tthis.setMaxZoom(changes['maxZoom'].currentValue);\n\t\t}\n\n\t}\n\n\tngOnDestroy() {\n\t\t// If this directive is destroyed, the map is too\n\t\tif (null != this.map) {\n\t\t\tthis.map.remove();\n\t\t}\n\t}\n\n\tpublic getMap() {\n\t\treturn this.map;\n\t}\n\n\n\t@HostListener('window:resize', [])\n\tonResize() {\n\t\tthis.delayResize();\n\t}\n\n\tprivate addMapEventListeners() {\n\n\t\tconst registerEventHandler = (eventName: string, handler: (e: LeafletEvent) => any) => {\n\t\t\tthis.map.on(eventName, handler);\n\t\t};\n\n\n\t\t// Add all the pass-through mouse event handlers\n\t\tregisterEventHandler('click', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onClick, e));\n\t\tregisterEventHandler('dblclick', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onDoubleClick, e));\n\t\tregisterEventHandler('mousedown', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onMouseDown, e));\n\t\tregisterEventHandler('mouseup', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onMouseUp, e));\n\t\tregisterEventHandler('mouseover', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onMouseOver, e));\n\t\tregisterEventHandler('mouseout', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onMouseOut, e));\n\t\tregisterEventHandler('mousemove', (e: LeafletMouseEvent) => LeafletUtil.handleEvent(this.zone, this.onMouseMove, e));\n\n\t\tregisterEventHandler('zoomstart', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapZoomStart, e));\n\t\tregisterEventHandler('zoom', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapZoom, e));\n\t\tregisterEventHandler('zoomend', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapZoomEnd, e));\n\t\tregisterEventHandler('movestart', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapMoveStart, e));\n\t\tregisterEventHandler('move', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapMove, e));\n\t\tregisterEventHandler('moveend', (e: LeafletEvent) => LeafletUtil.handleEvent(this.zone, this.onMapMoveEnd, e));\n\n\n\t\t// Update any things for which we provide output bindings\n\t\tconst outputUpdateHandler = () => {\n\t\t\tconst zoom = this.map.getZoom();\n\t\t\tif (zoom !== this.zoom) {\n\t\t\t\tthis.zoom = zoom;\n\t\t\t\tLeafletUtil.handleEvent(this.zone, this.zoomChange, zoom);\n\t\t\t}\n\n\t\t\tconst center = this.map.getCenter();\n\t\t\tif (null != center || null != this.center) {\n\n\t\t\t\tif (((null == center || null == this.center) && center !== this.center)\n\t\t\t\t\t|| (center.lat !== this.center.lat || center.lng !== this.center.lng)) {\n\n\t\t\t\t\tthis.center = center;\n\t\t\t\t\tLeafletUtil.handleEvent(this.zone, this.centerChange, center);\n\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\tregisterEventHandler('moveend', outputUpdateHandler);\n\t\tregisterEventHandler('zoomend', outputUpdateHandler);\n\t}\n\n\t/**\n\t * Resize the map to fit it's parent container\n\t */\n\tprivate doResize() {\n\n\t\t// Run this outside of angular so the map events stay outside of angular\n\t\tthis.zone.runOutsideAngular(() => {\n\n\t\t\t// Invalidate the map size to trigger it to update itself\n\t\t\tif (null != this.map) {\n\t\t\t\tthis.map.invalidateSize({});\n\t\t\t}\n\n\t\t});\n\n\t}\n\n\t/**\n\t * Manage a delayed resize of the component\n\t */\n\tprivate delayResize() {\n\t\tif (null != this.resizeTimer) {\n\t\t\tclearTimeout(this.resizeTimer);\n\t\t}\n\t\tthis.resizeTimer = setTimeout(this.doResize.bind(this), 200);\n\t}\n\n\n\t/**\n\t * Set the view (center/zoom) all at once\n\t * @param center The new center\n\t * @param zoom The new zoom level\n\t */\n\tprivate setView(center: LatLng, zoom: number) {\n\n\t\tif (null != this.map && null != center && null != zoom) {\n\t\t\tthis.map.setView(center, zoom, this.zoomPanOptions);\n\t\t}\n\n\t}\n\n\t/**\n\t * Set the map zoom level\n\t * @param zoom the new zoom level for the map\n\t */\n\tprivate setZoom(zoom: number) {\n\n\t\tif (null != this.map && null != zoom) {\n\t\t\tthis.map.setZoom(zoom, this.zoomOptions);\n\t\t}\n\n\t}\n\n\t/**\n\t * Set the center of the map\n\t * @param center the center point\n\t */\n\tprivate setCenter(center: LatLng) {\n\n\t\tif (null != this.map && null != center) {\n\t\t\tthis.map.panTo(center, this.panOptions);\n\t\t}\n\n\t}\n\n\t/**\n\t * Fit the map to the bounds\n\t * @param latLngBounds the boundary to set\n\t */\n\tprivate setFitBounds(latLngBounds: LatLngBounds) {\n\n\t\tif (null != this.map && null != latLngBounds) {\n\t\t\tthis.map.fitBounds(latLngBounds, this.fitBoundsOptions);\n\t\t}\n\n\t}\n\n\t/**\n\t * Set the map's max bounds\n\t * @param latLngBounds the boundary to set\n\t */\n\tprivate setMaxBounds(latLngBounds: LatLngBounds) {\n\n\t\tif (null != this.map && null != latLngBounds) {\n\t\t\tthis.map.setMaxBounds(latLngBounds);\n\t\t}\n\n\t}\n\n\t/**\n\t * Set the map's min zoom\n\t * @param number the new min zoom\n\t */\n\tprivate setMinZoom(zoom: number) {\n\n\t\tif (null != this.map && null != zoom) {\n\t\t\tthis.map.setMinZoom(zoom);\n\t\t}\n\n\t}\n\n\t/**\n\t * Set the map's min zoom\n\t * @param number the new min zoom\n\t */\n\tprivate setMaxZoom(zoom: number) {\n\n\t\tif (null != this.map && null != zoom) {\n\t\t\tthis.map.setMaxZoom(zoom);\n\t\t}\n\n\t}\n\n}\n"]}

package/esm2022/lib/core/leaflet.directive.wrapper.mjs

@@ -0,0 +1,12 @@
+export class LeafletDirectiveWrapper {
+    constructor(leafletDirective) {
+        this.leafletDirective = leafletDirective;
+    }
+    init() {
+        // Nothing for now
+    }
+    getMap() {
+        return this.leafletDirective.getMap();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZmxldC5kaXJlY3RpdmUud3JhcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1sZWFmbGV0L3NyYy9saWIvY29yZS9sZWFmbGV0LmRpcmVjdGl2ZS53cmFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE1BQU0sT0FBTyx1QkFBdUI7SUFLbkMsWUFBWSxnQkFBa0M7UUFDN0MsSUFBSSxDQUFDLGdCQUFnQixHQUFHLGdCQUFnQixDQUFDO0lBQzFDLENBQUM7SUFFRCxJQUFJO1FBQ0gsa0JBQWtCO0lBQ25CLENBQUM7SUFFRCxNQUFNO1FBQ0wsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDdkMsQ0FBQztDQUVEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTGVhZmxldERpcmVjdGl2ZSB9IGZyb20gJy4vbGVhZmxldC5kaXJlY3RpdmUnO1xuXG5pbXBvcnQgeyBNYXAgfSBmcm9tICdsZWFmbGV0JztcblxuZXhwb3J0IGNsYXNzIExlYWZsZXREaXJlY3RpdmVXcmFwcGVyIHtcblxuXHQvLyBSZWZlcmVuY2UgdG8gdGhlIG1haW4gbGVhZmxldCBkaXJlY3RpdmVcblx0cHJvdGVjdGVkIGxlYWZsZXREaXJlY3RpdmU6IExlYWZsZXREaXJlY3RpdmU7XG5cblx0Y29uc3RydWN0b3IobGVhZmxldERpcmVjdGl2ZTogTGVhZmxldERpcmVjdGl2ZSkge1xuXHRcdHRoaXMubGVhZmxldERpcmVjdGl2ZSA9IGxlYWZsZXREaXJlY3RpdmU7XG5cdH1cblxuXHRpbml0KCkge1xuXHRcdC8vIE5vdGhpbmcgZm9yIG5vd1xuXHR9XG5cblx0Z2V0TWFwKCk6IE1hcCB7XG5cdFx0cmV0dXJuIHRoaXMubGVhZmxldERpcmVjdGl2ZS5nZXRNYXAoKTtcblx0fVxuXG59XG4iXX0=

package/esm2022/lib/core/leaflet.util.mjs

@@ -0,0 +1,20 @@
+export class LeafletUtil {
+    static mapToArray(map) {
+        const toReturn = [];
+        for (const k in map) {
+            if (map.hasOwnProperty(k)) {
+                toReturn.push(map[k]);
+            }
+        }
+        return toReturn;
+    }
+    static handleEvent(zone, eventEmitter, event) {
+        // Don't want to emit if there are no observers
+        if (0 < eventEmitter.observers.length) {
+            zone.run(() => {
+                eventEmitter.emit(event);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZmxldC51dGlsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWxlYWZsZXQvc3JjL2xpYi9jb3JlL2xlYWZsZXQudXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sV0FBVztJQUV2QixNQUFNLENBQUMsVUFBVSxDQUFJLEdBQTJCO1FBQy9DLE1BQU0sUUFBUSxHQUFRLEVBQUUsQ0FBQztRQUV6QixLQUFLLE1BQU0sQ0FBQyxJQUFJLEdBQUcsRUFBRSxDQUFDO1lBQ3JCLElBQUksR0FBRyxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO2dCQUMzQixRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3ZCLENBQUM7UUFDRixDQUFDO1FBRUQsT0FBTyxRQUFRLENBQUM7SUFDakIsQ0FBQztJQUVELE1BQU0sQ0FBQyxXQUFXLENBQUksSUFBWSxFQUFFLFlBQTZCLEVBQUUsS0FBUTtRQUUxRSwrQ0FBK0M7UUFDL0MsSUFBSSxDQUFDLEdBQUcsWUFBWSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUN2QyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRTtnQkFDYixZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQzFCLENBQUMsQ0FBQyxDQUFDO1FBQ0osQ0FBQztJQUVGLENBQUM7Q0FDRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV2ZW50RW1pdHRlciwgTmdab25lIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjbGFzcyBMZWFmbGV0VXRpbCB7XG5cblx0c3RhdGljIG1hcFRvQXJyYXk8VD4obWFwOiB7IFsga2V5OiBzdHJpbmcgXTogVCB9KTogVFtdIHtcblx0XHRjb25zdCB0b1JldHVybjogVFtdID0gW107XG5cblx0XHRmb3IgKGNvbnN0IGsgaW4gbWFwKSB7XG5cdFx0XHRpZiAobWFwLmhhc093blByb3BlcnR5KGspKSB7XG5cdFx0XHRcdHRvUmV0dXJuLnB1c2gobWFwW2tdKTtcblx0XHRcdH1cblx0XHR9XG5cblx0XHRyZXR1cm4gdG9SZXR1cm47XG5cdH1cblxuXHRzdGF0aWMgaGFuZGxlRXZlbnQ8VD4oem9uZTogTmdab25lLCBldmVudEVtaXR0ZXI6IEV2ZW50RW1pdHRlcjxUPiwgZXZlbnQ6IFQpIHtcblxuXHRcdC8vIERvbid0IHdhbnQgdG8gZW1pdCBpZiB0aGVyZSBhcmUgbm8gb2JzZXJ2ZXJzXG5cdFx0aWYgKDAgPCBldmVudEVtaXR0ZXIub2JzZXJ2ZXJzLmxlbmd0aCkge1xuXHRcdFx0em9uZS5ydW4oKCkgPT4ge1xuXHRcdFx0XHRldmVudEVtaXR0ZXIuZW1pdChldmVudCk7XG5cdFx0XHR9KTtcblx0XHR9XG5cblx0fVxufVxuIl19

package/esm2022/lib/layers/base/leaflet-baselayers.directive.mjs

@@ -0,0 +1,113 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { LeafletUtil } from '../../core/leaflet.util';
+import { LeafletDirectiveWrapper } from '../../core/leaflet.directive.wrapper';
+import { LeafletControlLayersWrapper } from '../control/leaflet-control-layers.wrapper';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/leaflet.directive";
+/**
+ * Baselayers directive
+ *
+ * This directive is provided as a convenient way to add baselayers to the map. The input accepts
+ * a key-value map of layer name -> layer. Mutable changed are detected. On changes, a differ is
+ * used to determine what changed so that layers are appropriately added or removed. This directive
+ * will also add the layers control so users can switch between available base layers.
+ *
+ * To specify which layer to show as the 'active' baselayer, you will want to add it to the map
+ * using the layers directive. Otherwise, the plugin will use the last one it sees.
+ */
+export class LeafletBaseLayersDirective {
+    // Set/get baseLayers
+    set baseLayers(v) {
+        this.baseLayersValue = v;
+        this.updateBaseLayers();
+    }
+    get baseLayers() {
+        return this.baseLayersValue;
+    }
+    constructor(leafletDirective, differs, zone) {
+        this.differs = differs;
+        this.zone = zone;
+        // Output for once the layers control is ready
+        this.layersControlReady = new EventEmitter();
+        this.leafletDirective = new LeafletDirectiveWrapper(leafletDirective);
+        this.controlLayers = new LeafletControlLayersWrapper(this.zone, this.layersControlReady);
+        this.baseLayersDiffer = this.differs.find({}).create();
+    }
+    ngOnDestroy() {
+        this.baseLayers = {};
+        if (null != this.controlLayers.getLayersControl()) {
+            this.controlLayers.getLayersControl().remove();
+        }
+    }
+    ngOnInit() {
+        // Init the map
+        this.leafletDirective.init();
+        // Create the control outside angular to prevent events from triggering chnage detection
+        this.zone.runOutsideAngular(() => {
+            // Initially configure the controlLayers
+            this.controlLayers
+                .init({}, this.layersControlOptions)
+                .addTo(this.leafletDirective.getMap());
+        });
+        this.updateBaseLayers();
+    }
+    ngDoCheck() {
+        this.updateBaseLayers();
+    }
+    updateBaseLayers() {
+        const map = this.leafletDirective.getMap();
+        const layersControl = this.controlLayers.getLayersControl();
+        if (null != map && null != layersControl && null != this.baseLayersDiffer) {
+            const changes = this.baseLayersDiffer.diff(this.baseLayersValue);
+            const results = this.controlLayers.applyBaseLayerChanges(changes);
+            if (results.changed()) {
+                this.syncBaseLayer();
+            }
+        }
+    }
+    /**
+     * Check the current base layer and change it to the new one if necessary
+     */
+    syncBaseLayer() {
+        const map = this.leafletDirective.getMap();
+        const layers = LeafletUtil.mapToArray(this.baseLayers);
+        let foundLayer;
+        // Search all the layers in the map to see if we can find them in the baselayer array
+        map.eachLayer((l) => {
+            foundLayer = layers.find((bl) => (l === bl));
+        });
+        // Did we find the layer?
+        if (null != foundLayer) {
+            // Yes - set the baselayer to the one we found
+            this.baseLayer = foundLayer;
+        }
+        else {
+            // No - set the baselayer to the first in the array and add it to the map
+            if (layers.length > 0) {
+                this.baseLayer = layers[0];
+                // Add layers outside of angular to prevent events from triggering change detection
+                this.zone.runOutsideAngular(() => {
+                    this.baseLayer.addTo(map);
+                });
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletBaseLayersDirective, deps: [{ token: i1.LeafletDirective }, { token: i0.KeyValueDiffers }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.1", type: LeafletBaseLayersDirective, selector: "[leafletBaseLayers]", inputs: { baseLayers: ["leafletBaseLayers", "baseLayers"], layersControlOptions: ["leafletLayersControlOptions", "layersControlOptions"] }, outputs: { layersControlReady: "leafletLayersControlReady" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletBaseLayersDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[leafletBaseLayers]'
+                }]
+        }], ctorParameters: () => [{ type: i1.LeafletDirective }, { type: i0.KeyValueDiffers }, { type: i0.NgZone }], propDecorators: { baseLayers: [{
+                type: Input,
+                args: ['leafletBaseLayers']
+            }], layersControlOptions: [{
+                type: Input,
+                args: ['leafletLayersControlOptions']
+            }], layersControlReady: [{
+                type: Output,
+                args: ['leafletLayersControlReady']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leaflet-baselayers.directive.js","sourceRoot":"","sources":["../../../../../../projects/ngx-leaflet/src/lib/layers/base/leaflet-baselayers.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tDirective, DoCheck, EventEmitter, Input, KeyValueDiffer, KeyValueDiffers, NgZone, OnDestroy,\n\tOnInit, Output\n} from '@angular/core';\n\nimport { Control, Layer } from 'leaflet';\n\nimport { LeafletUtil } from '../../core/leaflet.util';\nimport { LeafletDirective } from '../../core/leaflet.directive';\nimport { LeafletDirectiveWrapper } from '../../core/leaflet.directive.wrapper';\nimport { LeafletControlLayersWrapper } from '../control/leaflet-control-layers.wrapper';\n\n\n/**\n * Baselayers directive\n *\n * This directive is provided as a convenient way to add baselayers to the map. The input accepts\n * a key-value map of layer name -> layer. Mutable changed are detected. On changes, a differ is\n * used to determine what changed so that layers are appropriately added or removed. This directive\n * will also add the layers control so users can switch between available base layers.\n *\n * To specify which layer to show as the 'active' baselayer, you will want to add it to the map\n * using the layers directive. Otherwise, the plugin will use the last one it sees.\n */\n@Directive({\n\tselector: '[leafletBaseLayers]'\n})\nexport class LeafletBaseLayersDirective\n\timplements DoCheck, OnDestroy, OnInit {\n\n\t// Base Layers\n\tbaseLayersValue: { [name: string]: Layer };\n\n\t// Base Layers Map Differ\n\tbaseLayersDiffer: KeyValueDiffer<string, Layer>;\n\n\t// Set/get baseLayers\n\t@Input('leafletBaseLayers')\n\tset baseLayers(v: { [name: string]: Layer }) {\n\t\tthis.baseLayersValue = v;\n\n\t\tthis.updateBaseLayers();\n\t}\n\tget baseLayers(): { [name: string]: Layer } {\n\t\treturn this.baseLayersValue;\n\t}\n\n\t// Control Options\n\t@Input('leafletLayersControlOptions') layersControlOptions: Control.LayersOptions;\n\n\t// Output for once the layers control is ready\n\t@Output('leafletLayersControlReady') layersControlReady = new EventEmitter<Control.Layers>();\n\n\t// Active Base Layer\n\tprivate baseLayer: Layer;\n\n\tprivate leafletDirective: LeafletDirectiveWrapper;\n\tprivate controlLayers: LeafletControlLayersWrapper;\n\n\tconstructor(leafletDirective: LeafletDirective, private differs: KeyValueDiffers, private zone: NgZone) {\n\t\tthis.leafletDirective = new LeafletDirectiveWrapper(leafletDirective);\n\t\tthis.controlLayers = new LeafletControlLayersWrapper(this.zone, this.layersControlReady);\n\t\tthis.baseLayersDiffer = this.differs.find({}).create<string, Layer>();\n\t}\n\n\tngOnDestroy() {\n\t\tthis.baseLayers = {};\n\t\tif (null != this.controlLayers.getLayersControl()) {\n\t\t\tthis.controlLayers.getLayersControl().remove();\n\t\t}\n\t}\n\n\tngOnInit() {\n\n\t\t// Init the map\n\t\tthis.leafletDirective.init();\n\n\t\t// Create the control outside angular to prevent events from triggering chnage detection\n\t\tthis.zone.runOutsideAngular(() => {\n\n\t\t\t// Initially configure the controlLayers\n\t\t\tthis.controlLayers\n\t\t\t\t.init({}, this.layersControlOptions)\n\t\t\t\t.addTo(this.leafletDirective.getMap());\n\n\t\t});\n\n\t\tthis.updateBaseLayers();\n\n\t}\n\n\tngDoCheck() {\n\t\tthis.updateBaseLayers();\n\t}\n\n\tprotected updateBaseLayers() {\n\n\t\tconst map = this.leafletDirective.getMap();\n\t\tconst layersControl = this.controlLayers.getLayersControl();\n\n\t\tif (null != map && null != layersControl && null != this.baseLayersDiffer) {\n\t\t\tconst changes = this.baseLayersDiffer.diff(this.baseLayersValue);\n\t\t\tconst results = this.controlLayers.applyBaseLayerChanges(changes);\n\n\t\t\tif (results.changed()) {\n\t\t\t\tthis.syncBaseLayer();\n\t\t\t}\n\t\t}\n\n\t}\n\n\t/**\n\t * Check the current base layer and change it to the new one if necessary\n\t */\n\tprotected syncBaseLayer() {\n\n\t\tconst map = this.leafletDirective.getMap();\n\t\tconst layers = LeafletUtil.mapToArray(this.baseLayers);\n\t\tlet foundLayer: Layer;\n\n\t\t// Search all the layers in the map to see if we can find them in the baselayer array\n\t\tmap.eachLayer((l: Layer) => {\n\t\t\tfoundLayer = layers.find((bl) => (l === bl));\n\t\t});\n\n\t\t// Did we find the layer?\n\t\tif (null != foundLayer) {\n\t\t\t// Yes - set the baselayer to the one we found\n\t\t\tthis.baseLayer = foundLayer;\n\t\t}\n\t\telse {\n\t\t\t// No - set the baselayer to the first in the array and add it to the map\n\t\t\tif (layers.length > 0) {\n\t\t\t\tthis.baseLayer = layers[0];\n\n\t\t\t\t// Add layers outside of angular to prevent events from triggering change detection\n\t\t\t\tthis.zone.runOutsideAngular(() => {\n\t\t\t\t\tthis.baseLayer.addTo(map);\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t}\n}\n"]}

package/esm2022/lib/layers/control/leaflet-control-layers-changes.model.mjs

@@ -0,0 +1,11 @@
+export class LeafletControlLayersChanges {
+    constructor() {
+        this.layersRemoved = 0;
+        this.layersChanged = 0;
+        this.layersAdded = 0;
+    }
+    changed() {
+        return !(this.layersRemoved === 0 && this.layersChanged === 0 && this.layersAdded === 0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZmxldC1jb250cm9sLWxheWVycy1jaGFuZ2VzLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWxlYWZsZXQvc3JjL2xpYi9sYXllcnMvY29udHJvbC9sZWFmbGV0LWNvbnRyb2wtbGF5ZXJzLWNoYW5nZXMubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLDJCQUEyQjtJQUF4QztRQUNDLGtCQUFhLEdBQVcsQ0FBQyxDQUFDO1FBQzFCLGtCQUFhLEdBQVcsQ0FBQyxDQUFDO1FBQzFCLGdCQUFXLEdBQVcsQ0FBQyxDQUFDO0lBS3pCLENBQUM7SUFIQSxPQUFPO1FBQ04sT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDLGFBQWEsS0FBSyxDQUFDLElBQUksSUFBSSxDQUFDLFdBQVcsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUMxRixDQUFDO0NBQ0QiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTGVhZmxldENvbnRyb2xMYXllcnNDaGFuZ2VzIHtcblx0bGF5ZXJzUmVtb3ZlZDogbnVtYmVyID0gMDtcblx0bGF5ZXJzQ2hhbmdlZDogbnVtYmVyID0gMDtcblx0bGF5ZXJzQWRkZWQ6IG51bWJlciA9IDA7XG5cblx0Y2hhbmdlZCgpOiBib29sZWFuIHtcblx0XHRyZXR1cm4gISh0aGlzLmxheWVyc1JlbW92ZWQgPT09IDAgJiYgdGhpcy5sYXllcnNDaGFuZ2VkID09PSAwICYmIHRoaXMubGF5ZXJzQWRkZWQgPT09IDApO1xuXHR9XG59XG4iXX0=

package/esm2022/lib/layers/control/leaflet-control-layers-config.model.mjs

@@ -0,0 +1,7 @@
+export class LeafletControlLayersConfig {
+    constructor() {
+        this.baseLayers = {};
+        this.overlays = {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZmxldC1jb250cm9sLWxheWVycy1jb25maWcubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbGVhZmxldC9zcmMvbGliL2xheWVycy9jb250cm9sL2xlYWZsZXQtY29udHJvbC1sYXllcnMtY29uZmlnLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTywwQkFBMEI7SUFBdkM7UUFDQyxlQUFVLEdBQThCLEVBQUUsQ0FBQztRQUMzQyxhQUFRLEdBQThCLEVBQUUsQ0FBQztJQUMxQyxDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMYXllciB9IGZyb20gJ2xlYWZsZXQnO1xuXG5leHBvcnQgY2xhc3MgTGVhZmxldENvbnRyb2xMYXllcnNDb25maWcge1xuXHRiYXNlTGF5ZXJzOiB7IFtuYW1lOiBzdHJpbmddOiBMYXllciB9ID0ge307XG5cdG92ZXJsYXlzOiB7IFtuYW1lOiBzdHJpbmddOiBMYXllciB9ID0ge307XG59XG4iXX0=