@bluehalo/ngx-leaflet 18.0.2

package/esm2022/lib/layers/control/leaflet-control-layers.directive.mjs

@@ -0,0 +1,100 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { LeafletDirectiveWrapper } from '../../core/leaflet.directive.wrapper';
+import { LeafletControlLayersWrapper } from './leaflet-control-layers.wrapper';
+import { LeafletControlLayersConfig } from './leaflet-control-layers-config.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/leaflet.directive";
+/**
+ * Layers Control
+ *
+ * This directive is used to configure the layers control. The input accepts an object with two
+ * key-value maps of layer name -> layer. Mutable changes are detected. On changes, a differ is
+ * used to determine what changed so that layers are appropriately added or removed.
+ *
+ * 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 last one it sees will be used.
+ */
+export class LeafletLayersControlDirective {
+    set layersControlConfig(v) {
+        // Validation/init stuff
+        if (null == v) {
+            v = new LeafletControlLayersConfig();
+        }
+        if (null == v.baseLayers) {
+            v.baseLayers = {};
+        }
+        if (null == v.overlays) {
+            v.overlays = {};
+        }
+        // Store the value
+        this.layersControlConfigValue = v;
+        // Update the map
+        this.updateLayers();
+    }
+    get layersControlConfig() {
+        return this.layersControlConfigValue;
+    }
+    constructor(leafletDirective, differs, zone) {
+        this.differs = differs;
+        this.zone = zone;
+        this.layersControlReady = new EventEmitter();
+        this.leafletDirective = new LeafletDirectiveWrapper(leafletDirective);
+        this.controlLayers = new LeafletControlLayersWrapper(this.zone, this.layersControlReady);
+        // Generate differs
+        this.baseLayersDiffer = this.differs.find({}).create();
+        this.overlaysDiffer = this.differs.find({}).create();
+    }
+    ngOnInit() {
+        // Init the map
+        this.leafletDirective.init();
+        // Set up control outside of angular to avoid change detection when using the control
+        this.zone.runOutsideAngular(() => {
+            // Set up all the initial settings
+            this.controlLayers
+                .init({}, this.layersControlOptions)
+                .addTo(this.leafletDirective.getMap());
+        });
+        this.updateLayers();
+    }
+    ngOnDestroy() {
+        this.layersControlConfig = { baseLayers: {}, overlays: {} };
+        this.controlLayers.getLayersControl().remove();
+    }
+    ngDoCheck() {
+        this.updateLayers();
+    }
+    updateLayers() {
+        const map = this.leafletDirective.getMap();
+        const layersControl = this.controlLayers.getLayersControl();
+        if (null != map && null != layersControl) {
+            // Run the baselayers differ
+            if (null != this.baseLayersDiffer && null != this.layersControlConfigValue.baseLayers) {
+                const changes = this.baseLayersDiffer.diff(this.layersControlConfigValue.baseLayers);
+                this.controlLayers.applyBaseLayerChanges(changes);
+            }
+            // Run the overlays differ
+            if (null != this.overlaysDiffer && null != this.layersControlConfigValue.overlays) {
+                const changes = this.overlaysDiffer.diff(this.layersControlConfigValue.overlays);
+                this.controlLayers.applyOverlayChanges(changes);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayersControlDirective, 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: LeafletLayersControlDirective, selector: "[leafletLayersControl]", inputs: { layersControlConfig: ["leafletLayersControl", "layersControlConfig"], layersControlOptions: ["leafletLayersControlOptions", "layersControlOptions"] }, outputs: { layersControlReady: "leafletLayersControlReady" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayersControlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[leafletLayersControl]'
+                }]
+        }], ctorParameters: () => [{ type: i1.LeafletDirective }, { type: i0.KeyValueDiffers }, { type: i0.NgZone }], propDecorators: { layersControlConfig: [{
+                type: Input,
+                args: ['leafletLayersControl']
+            }], layersControlOptions: [{
+                type: Input,
+                args: ['leafletLayersControlOptions']
+            }], layersControlReady: [{
+                type: Output,
+                args: ['leafletLayersControlReady']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leaflet-control-layers.directive.js","sourceRoot":"","sources":["../../../../../../projects/ngx-leaflet/src/lib/layers/control/leaflet-control-layers.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tDirective, DoCheck, EventEmitter, Input, KeyValueDiffer, KeyValueDiffers, NgZone, OnDestroy, OnInit,\n\tOutput\n} from '@angular/core';\n\nimport { Control, Layer } from 'leaflet';\n\nimport { LeafletDirective } from '../../core/leaflet.directive';\nimport { LeafletDirectiveWrapper } from '../../core/leaflet.directive.wrapper';\nimport { LeafletControlLayersWrapper } from './leaflet-control-layers.wrapper';\nimport { LeafletControlLayersConfig } from './leaflet-control-layers-config.model';\n\n\n/**\n * Layers Control\n *\n * This directive is used to configure the layers control. The input accepts an object with two\n * key-value maps of layer name -> layer. Mutable changes are detected. On changes, a differ is\n * used to determine what changed so that layers are appropriately added or removed.\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 last one it sees will be used.\n */\n@Directive({\n\tselector: '[leafletLayersControl]'\n})\nexport class LeafletLayersControlDirective\n\timplements DoCheck, OnDestroy, OnInit {\n\n\t// Control Layers Configuration\n\tlayersControlConfigValue: LeafletControlLayersConfig;\n\n\tbaseLayersDiffer: KeyValueDiffer<string, Layer>;\n\toverlaysDiffer: KeyValueDiffer<string, Layer>;\n\n\t@Input('leafletLayersControl')\n\tset layersControlConfig(v: LeafletControlLayersConfig) {\n\n\t\t// Validation/init stuff\n\t\tif (null == v) { v = new LeafletControlLayersConfig(); }\n\t\tif (null == v.baseLayers) { v.baseLayers = {}; }\n\t\tif (null == v.overlays) { v.overlays = {}; }\n\n\t\t// Store the value\n\t\tthis.layersControlConfigValue = v;\n\n\t\t// Update the map\n\t\tthis.updateLayers();\n\n\t}\n\tget layersControlConfig(): LeafletControlLayersConfig {\n\t\treturn this.layersControlConfigValue;\n\t}\n\n\t@Input('leafletLayersControlOptions') layersControlOptions: any;\n\n\t@Output('leafletLayersControlReady') layersControlReady = new EventEmitter<Control.Layers>();\n\n\tprivate controlLayers: LeafletControlLayersWrapper;\n\tprivate leafletDirective: LeafletDirectiveWrapper;\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\n\t\t// Generate differs\n\t\tthis.baseLayersDiffer = this.differs.find({}).create<string, Layer>();\n\t\tthis.overlaysDiffer = this.differs.find({}).create<string, Layer>();\n\n\t}\n\n\tngOnInit() {\n\n\t\t// Init the map\n\t\tthis.leafletDirective.init();\n\n\t\t// Set up control outside of angular to avoid change detection when using the control\n\t\tthis.zone.runOutsideAngular(() => {\n\n\t\t\t// Set up all the initial settings\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.updateLayers();\n\n\t}\n\n\tngOnDestroy() {\n\t\tthis.layersControlConfig = { baseLayers: {}, overlays: {} };\n\t\tthis.controlLayers.getLayersControl().remove();\n\t}\n\n\tngDoCheck() {\n\t\tthis.updateLayers();\n\t}\n\n\tprotected updateLayers() {\n\n\t\tconst map = this.leafletDirective.getMap();\n\t\tconst layersControl = this.controlLayers.getLayersControl();\n\n\t\tif (null != map && null != layersControl) {\n\n\t\t\t// Run the baselayers differ\n\t\t\tif (null != this.baseLayersDiffer && null != this.layersControlConfigValue.baseLayers) {\n\t\t\t\tconst changes = this.baseLayersDiffer.diff(this.layersControlConfigValue.baseLayers);\n\t\t\t\tthis.controlLayers.applyBaseLayerChanges(changes);\n\t\t\t}\n\n\t\t\t// Run the overlays differ\n\t\t\tif (null != this.overlaysDiffer && null != this.layersControlConfigValue.overlays) {\n\t\t\t\tconst changes = this.overlaysDiffer.diff(this.layersControlConfigValue.overlays);\n\t\t\t\tthis.controlLayers.applyOverlayChanges(changes);\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}\n"]}

package/esm2022/lib/layers/control/leaflet-control-layers.wrapper.mjs

@@ -0,0 +1,58 @@
+import { control } from 'leaflet';
+import { LeafletControlLayersChanges } from './leaflet-control-layers-changes.model';
+export class LeafletControlLayersWrapper {
+    constructor(zone, layersControlReady) {
+        this.zone = zone;
+        this.layersControlReady = layersControlReady;
+    }
+    getLayersControl() {
+        return this.layersControl;
+    }
+    init(controlConfig, controlOptions) {
+        const baseLayers = controlConfig.baseLayers || {};
+        const overlays = controlConfig.overlays || {};
+        // Create the control outside of angular to ensure events don't trigger change detection
+        this.zone.runOutsideAngular(() => {
+            this.layersControl = control.layers(baseLayers, overlays, controlOptions);
+        });
+        this.layersControlReady.emit(this.layersControl);
+        return this.layersControl;
+    }
+    applyBaseLayerChanges(changes) {
+        let results = new LeafletControlLayersChanges();
+        if (null != this.layersControl) {
+            results = this.applyChanges(changes, this.layersControl.addBaseLayer);
+        }
+        return results;
+    }
+    applyOverlayChanges(changes) {
+        let results = new LeafletControlLayersChanges();
+        if (null != this.layersControl) {
+            results = this.applyChanges(changes, this.layersControl.addOverlay);
+        }
+        return results;
+    }
+    applyChanges(changes, addFn) {
+        const results = new LeafletControlLayersChanges();
+        if (null != changes) {
+            // All layer management is outside angular to avoid layer events from triggering change detection
+            this.zone.runOutsideAngular(() => {
+                changes.forEachChangedItem((c) => {
+                    this.layersControl.removeLayer(c.previousValue);
+                    addFn.call(this.layersControl, c.currentValue, c.key);
+                    results.layersChanged++;
+                });
+                changes.forEachRemovedItem((c) => {
+                    this.layersControl.removeLayer(c.previousValue);
+                    results.layersRemoved++;
+                });
+                changes.forEachAddedItem((c) => {
+                    addFn.call(this.layersControl, c.currentValue, c.key);
+                    results.layersAdded++;
+                });
+            });
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layers/leaflet-layer.directive.mjs

@@ -0,0 +1,78 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { LeafletDirectiveWrapper } from '../core/leaflet.directive.wrapper';
+import { LeafletUtil } from '../core/leaflet.util';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/leaflet.directive";
+/**
+ * Layer directive
+ *
+ * This directive is used to directly control a single map layer. The purpose of this directive is to
+ * be used as part of a child structural directive of the map element.
+ *
+ */
+export class LeafletLayerDirective {
+    constructor(leafletDirective, zone) {
+        this.zone = zone;
+        // Layer Events
+        this.onAdd = new EventEmitter();
+        this.onRemove = new EventEmitter();
+        this.leafletDirective = new LeafletDirectiveWrapper(leafletDirective);
+    }
+    ngOnInit() {
+        // Init the map
+        this.leafletDirective.init();
+    }
+    ngOnDestroy() {
+        if (null != this.layer) {
+            // Unregister the event handlers
+            this.removeLayerEventListeners(this.layer);
+            // Remove the layer from the map
+            this.layer.remove();
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['layer']) {
+            // Update the layer
+            const p = changes['layer'].previousValue;
+            const n = changes['layer'].currentValue;
+            this.zone.runOutsideAngular(() => {
+                if (null != p) {
+                    this.removeLayerEventListeners(p);
+                    p.remove();
+                }
+                if (null != n) {
+                    this.addLayerEventListeners(n);
+                    this.leafletDirective.getMap().addLayer(n);
+                }
+            });
+        }
+    }
+    addLayerEventListeners(l) {
+        this.onAddLayerHandler = (e) => LeafletUtil.handleEvent(this.zone, this.onAdd, e);
+        l.on('add', this.onAddLayerHandler);
+        this.onRemoveLayerHandler = (e) => LeafletUtil.handleEvent(this.zone, this.onRemove, e);
+        l.on('remove', this.onRemoveLayerHandler);
+    }
+    removeLayerEventListeners(l) {
+        l.off('add', this.onAddLayerHandler);
+        l.off('remove', this.onRemoveLayerHandler);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayerDirective, deps: [{ token: i1.LeafletDirective }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.1", type: LeafletLayerDirective, selector: "[leafletLayer]", inputs: { layer: ["leafletLayer", "layer"] }, outputs: { onAdd: "leafletLayerAdd", onRemove: "leafletLayerRemove" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[leafletLayer]'
+                }]
+        }], ctorParameters: () => [{ type: i1.LeafletDirective }, { type: i0.NgZone }], propDecorators: { layer: [{
+                type: Input,
+                args: ['leafletLayer']
+            }], onAdd: [{
+                type: Output,
+                args: ['leafletLayerAdd']
+            }], onRemove: [{
+                type: Output,
+                args: ['leafletLayerRemove']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,83 @@
+import { Directive, Input } from '@angular/core';
+import { LeafletDirectiveWrapper } from '../core/leaflet.directive.wrapper';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/leaflet.directive";
+/**
+ * Layers directive
+ *
+ * This directive is used to directly control map layers. As changes are made to the input array of
+ * layers, the map is synched to the array. As layers are added or removed from the input array, they
+ * are also added or removed from the map. The input array is treated as immutable. To detect changes,
+ * you must change the array instance.
+ *
+ * Important Note: The input layers array is assumed to be immutable. This means you need to use an
+ * immutable array implementation or create a new copy of your array when you make changes, otherwise
+ * this directive won't detect the change. This is by design. It's for performance reasons. Change
+ * detection of mutable arrays requires diffing the state of the array on every DoCheck cycle, which
+ * is extremely expensive from a time complexity perspective.
+ *
+ */
+export class LeafletLayersDirective {
+    // Set/get the layers
+    set layers(v) {
+        this.layersValue = v;
+        // Now that we have a differ, do an immediate layer update
+        this.updateLayers();
+    }
+    get layers() {
+        return this.layersValue;
+    }
+    constructor(leafletDirective, differs, zone) {
+        this.differs = differs;
+        this.zone = zone;
+        this.leafletDirective = new LeafletDirectiveWrapper(leafletDirective);
+        this.layersDiffer = this.differs.find([]).create();
+    }
+    ngDoCheck() {
+        this.updateLayers();
+    }
+    ngOnInit() {
+        // Init the map
+        this.leafletDirective.init();
+        // Update layers once the map is ready
+        this.updateLayers();
+    }
+    ngOnDestroy() {
+        this.layers = [];
+    }
+    /**
+     * Update the state of the layers.
+     * We use an iterable differ to synchronize the map layers with the state of the bound layers array.
+     * This is important because it allows us to react to changes to the contents of the array as well
+     * as changes to the actual array instance.
+     */
+    updateLayers() {
+        const map = this.leafletDirective.getMap();
+        if (null != map && null != this.layersDiffer) {
+            const changes = this.layersDiffer.diff(this.layersValue);
+            if (null != changes) {
+                // Run outside angular to ensure layer events don't trigger change detection
+                this.zone.runOutsideAngular(() => {
+                    changes.forEachRemovedItem((c) => {
+                        map.removeLayer(c.item);
+                    });
+                    changes.forEachAddedItem((c) => {
+                        map.addLayer(c.item);
+                    });
+                });
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayersDirective, deps: [{ token: i1.LeafletDirective }, { token: i0.IterableDiffers }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.1", type: LeafletLayersDirective, selector: "[leafletLayers]", inputs: { layers: ["leafletLayers", "layers"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletLayersDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[leafletLayers]'
+                }]
+        }], ctorParameters: () => [{ type: i1.LeafletDirective }, { type: i0.IterableDiffers }, { type: i0.NgZone }], propDecorators: { layers: [{
+                type: Input,
+                args: ['leafletLayers']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layers/leaflet-tile-layer-definition.model.mjs

@@ -0,0 +1,53 @@
+import { tileLayer } from 'leaflet';
+export class LeafletTileLayerDefinition {
+    constructor(type, url, options) {
+        this.type = type;
+        this.url = url;
+        this.options = options;
+    }
+    /**
+     * Creates a TileLayer from the provided definition. This is a convenience function
+     * to help with generating layers from objects.
+     *
+     * @param layerDef The layer to create
+     * @returns {TileLayer} The TileLayer that has been created
+     */
+    static createTileLayer(layerDef) {
+        let layer;
+        switch (layerDef.type) {
+            case 'xyz':
+                layer = tileLayer(layerDef.url, layerDef.options);
+                break;
+            case 'wms':
+            default:
+                layer = tileLayer.wms(layerDef.url, layerDef.options);
+                break;
+        }
+        return layer;
+    }
+    /**
+     * Creates a TileLayer for each key in the incoming map. This is a convenience function
+     * for generating an associative array of layers from an associative array of objects
+     *
+     * @param layerDefs A map of key to tile layer definition
+     * @returns {{[p: string]: TileLayer}} A new map of key to TileLayer
+     */
+    static createTileLayers(layerDefs) {
+        const layers = {};
+        for (const k in layerDefs) {
+            if (layerDefs.hasOwnProperty(k)) {
+                layers[k] = (LeafletTileLayerDefinition.createTileLayer(layerDefs[k]));
+            }
+        }
+        return layers;
+    }
+    /**
+     * Create a Tile Layer from the current state of this object
+     *
+     * @returns {TileLayer} A new TileLayer
+     */
+    createTileLayer() {
+        return LeafletTileLayerDefinition.createTileLayer(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/leaflet.module.mjs

@@ -0,0 +1,40 @@
+import { NgModule } from '@angular/core';
+import { LeafletDirective } from './core/leaflet.directive';
+import { LeafletLayerDirective } from './layers/leaflet-layer.directive';
+import { LeafletLayersDirective } from './layers/leaflet-layers.directive';
+import { LeafletLayersControlDirective } from './layers/control/leaflet-control-layers.directive';
+import { LeafletBaseLayersDirective } from './layers/base/leaflet-baselayers.directive';
+import * as i0 from "@angular/core";
+export class LeafletModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.1", ngImport: i0, type: LeafletModule, declarations: [LeafletDirective,
+            LeafletLayerDirective,
+            LeafletLayersDirective,
+            LeafletLayersControlDirective,
+            LeafletBaseLayersDirective], exports: [LeafletDirective,
+            LeafletLayerDirective,
+            LeafletLayersDirective,
+            LeafletLayersControlDirective,
+            LeafletBaseLayersDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: LeafletModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        LeafletDirective,
+                        LeafletLayerDirective,
+                        LeafletLayersDirective,
+                        LeafletLayersControlDirective,
+                        LeafletBaseLayersDirective
+                    ],
+                    declarations: [
+                        LeafletDirective,
+                        LeafletLayerDirective,
+                        LeafletLayersDirective,
+                        LeafletLayersControlDirective,
+                        LeafletBaseLayersDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/public-api.mjs

@@ -0,0 +1,13 @@
+export { LeafletModule } from './lib/leaflet.module';
+export { LeafletDirective } from './lib/core/leaflet.directive';
+export { LeafletDirectiveWrapper } from './lib/core/leaflet.directive.wrapper';
+export { LeafletUtil } from './lib/core/leaflet.util';
+export { LeafletLayerDirective } from './lib/layers/leaflet-layer.directive';
+export { LeafletLayersDirective } from './lib/layers/leaflet-layers.directive';
+export { LeafletTileLayerDefinition } from './lib/layers/leaflet-tile-layer-definition.model';
+export { LeafletBaseLayersDirective } from './lib/layers/base/leaflet-baselayers.directive';
+export { LeafletLayersControlDirective } from './lib/layers/control/leaflet-control-layers.directive';
+export { LeafletControlLayersWrapper } from './lib/layers/control/leaflet-control-layers.wrapper';
+export { LeafletControlLayersConfig } from './lib/layers/control/leaflet-control-layers-config.model';
+export { LeafletControlLayersChanges } from './lib/layers/control/leaflet-control-layers-changes.model';
+//# sourceMappingURL=data:application/json;base64,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