@bluehalo/ngx-leaflet 18.0.2 → 20.0.0

package/lib/layers/base/leaflet-baselayers.directive.d.ts

@@ -1,45 +0,0 @@
-import { DoCheck, EventEmitter, KeyValueDiffer, KeyValueDiffers, NgZone, OnDestroy, OnInit } from '@angular/core';
-import { Control, Layer } from 'leaflet';
-import { LeafletDirective } from '../../core/leaflet.directive';
-import * as i0 from "@angular/core";
-/**
- * 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 declare class LeafletBaseLayersDirective implements DoCheck, OnDestroy, OnInit {
-    private differs;
-    private zone;
-    baseLayersValue: {
-        [name: string]: Layer;
-    };
-    baseLayersDiffer: KeyValueDiffer<string, Layer>;
-    set baseLayers(v: {
-        [name: string]: Layer;
-    });
-    get baseLayers(): {
-        [name: string]: Layer;
-    };
-    layersControlOptions: Control.LayersOptions;
-    layersControlReady: EventEmitter<Control.Layers>;
-    private baseLayer;
-    private leafletDirective;
-    private controlLayers;
-    constructor(leafletDirective: LeafletDirective, differs: KeyValueDiffers, zone: NgZone);
-    ngOnDestroy(): void;
-    ngOnInit(): void;
-    ngDoCheck(): void;
-    protected updateBaseLayers(): void;
-    /**
-     * Check the current base layer and change it to the new one if necessary
-     */
-    protected syncBaseLayer(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletBaseLayersDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LeafletBaseLayersDirective, "[leafletBaseLayers]", never, { "baseLayers": { "alias": "leafletBaseLayers"; "required": false; }; "layersControlOptions": { "alias": "leafletLayersControlOptions"; "required": false; }; }, { "layersControlReady": "leafletLayersControlReady"; }, never, never, false, never>;
-}

package/lib/layers/control/leaflet-control-layers-changes.model.d.ts

@@ -1,6 +0,0 @@
-export declare class LeafletControlLayersChanges {
-    layersRemoved: number;
-    layersChanged: number;
-    layersAdded: number;
-    changed(): boolean;
-}

package/lib/layers/control/leaflet-control-layers-config.model.d.ts

@@ -1,9 +0,0 @@
-import { Layer } from 'leaflet';
-export declare class LeafletControlLayersConfig {
-    baseLayers: {
-        [name: string]: Layer;
-    };
-    overlays: {
-        [name: string]: Layer;
-    };
-}

package/lib/layers/control/leaflet-control-layers.directive.d.ts

@@ -1,35 +0,0 @@
-import { DoCheck, EventEmitter, KeyValueDiffer, KeyValueDiffers, NgZone, OnDestroy, OnInit } from '@angular/core';
-import { Control, Layer } from 'leaflet';
-import { LeafletDirective } from '../../core/leaflet.directive';
-import { LeafletControlLayersConfig } from './leaflet-control-layers-config.model';
-import * as i0 from "@angular/core";
-/**
- * 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 declare class LeafletLayersControlDirective implements DoCheck, OnDestroy, OnInit {
-    private differs;
-    private zone;
-    layersControlConfigValue: LeafletControlLayersConfig;
-    baseLayersDiffer: KeyValueDiffer<string, Layer>;
-    overlaysDiffer: KeyValueDiffer<string, Layer>;
-    set layersControlConfig(v: LeafletControlLayersConfig);
-    get layersControlConfig(): LeafletControlLayersConfig;
-    layersControlOptions: any;
-    layersControlReady: EventEmitter<Control.Layers>;
-    private controlLayers;
-    private leafletDirective;
-    constructor(leafletDirective: LeafletDirective, differs: KeyValueDiffers, zone: NgZone);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    ngDoCheck(): void;
-    protected updateLayers(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletLayersControlDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LeafletLayersControlDirective, "[leafletLayersControl]", never, { "layersControlConfig": { "alias": "leafletLayersControl"; "required": false; }; "layersControlOptions": { "alias": "leafletLayersControlOptions"; "required": false; }; }, { "layersControlReady": "leafletLayersControlReady"; }, never, never, false, never>;
-}

package/lib/layers/control/leaflet-control-layers.wrapper.d.ts

@@ -1,14 +0,0 @@
-import { EventEmitter, KeyValueChanges, NgZone } from '@angular/core';
-import { Control, Layer } from 'leaflet';
-import { LeafletControlLayersChanges } from './leaflet-control-layers-changes.model';
-export declare class LeafletControlLayersWrapper {
-    private zone;
-    protected layersControl: Control.Layers;
-    protected layersControlReady: EventEmitter<Control.Layers>;
-    constructor(zone: NgZone, layersControlReady: EventEmitter<Control.Layers>);
-    getLayersControl(): Control.Layers;
-    init(controlConfig: any, controlOptions: any): Control.Layers;
-    applyBaseLayerChanges(changes: KeyValueChanges<string, Layer>): LeafletControlLayersChanges;
-    applyOverlayChanges(changes: KeyValueChanges<string, Layer>): LeafletControlLayersChanges;
-    private applyChanges;
-}

package/lib/layers/leaflet-layer.directive.d.ts

@@ -1,30 +0,0 @@
-import { EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, SimpleChange } from '@angular/core';
-import { Layer, LeafletEvent } from 'leaflet';
-import { LeafletDirective } from '../core/leaflet.directive';
-import * as i0 from "@angular/core";
-/**
- * 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 declare class LeafletLayerDirective implements OnChanges, OnDestroy, OnInit {
-    private zone;
-    layer: Layer;
-    onAdd: EventEmitter<LeafletEvent>;
-    onRemove: EventEmitter<LeafletEvent>;
-    private onAddLayerHandler;
-    private onRemoveLayerHandler;
-    private leafletDirective;
-    constructor(leafletDirective: LeafletDirective, zone: NgZone);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    ngOnChanges(changes: {
-        [key: string]: SimpleChange;
-    }): void;
-    private addLayerEventListeners;
-    private removeLayerEventListeners;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletLayerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LeafletLayerDirective, "[leafletLayer]", never, { "layer": { "alias": "leafletLayer"; "required": false; }; }, { "onAdd": "leafletLayerAdd"; "onRemove": "leafletLayerRemove"; }, never, never, false, never>;
-}

package/lib/layers/leaflet-layers.directive.d.ts

@@ -1,41 +0,0 @@
-import { DoCheck, IterableDiffer, IterableDiffers, NgZone, OnDestroy, OnInit } from '@angular/core';
-import { Layer } from 'leaflet';
-import { LeafletDirective } from '../core/leaflet.directive';
-import * as i0 from "@angular/core";
-/**
- * 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 declare class LeafletLayersDirective implements DoCheck, OnDestroy, OnInit {
-    private differs;
-    private zone;
-    layersValue: Layer[];
-    layersDiffer: IterableDiffer<Layer>;
-    set layers(v: Layer[]);
-    get layers(): Layer[];
-    private leafletDirective;
-    constructor(leafletDirective: LeafletDirective, differs: IterableDiffers, zone: NgZone);
-    ngDoCheck(): void;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /**
-     * 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.
-     */
-    private updateLayers;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletLayersDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LeafletLayersDirective, "[leafletLayers]", never, { "layers": { "alias": "leafletLayers"; "required": false; }; }, {}, never, never, false, never>;
-}

package/lib/layers/leaflet-tile-layer-definition.model.d.ts

@@ -1,33 +0,0 @@
-import { TileLayer } from 'leaflet';
-export declare class LeafletTileLayerDefinition {
-    type: string;
-    url: string;
-    options: any;
-    constructor(type: string, url: string, options: any);
-    /**
-     * 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: LeafletTileLayerDefinition): TileLayer;
-    /**
-     * 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: {
-        [key: string]: LeafletTileLayerDefinition;
-    }): {
-        [key: string]: TileLayer;
-    };
-    /**
-     * Create a Tile Layer from the current state of this object
-     *
-     * @returns {TileLayer} A new TileLayer
-     */
-    createTileLayer(): TileLayer;
-}

package/lib/leaflet.module.d.ts

@@ -1,11 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./core/leaflet.directive";
-import * as i2 from "./layers/leaflet-layer.directive";
-import * as i3 from "./layers/leaflet-layers.directive";
-import * as i4 from "./layers/control/leaflet-control-layers.directive";
-import * as i5 from "./layers/base/leaflet-baselayers.directive";
-export declare class LeafletModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafletModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<LeafletModule, [typeof i1.LeafletDirective, typeof i2.LeafletLayerDirective, typeof i3.LeafletLayersDirective, typeof i4.LeafletLayersControlDirective, typeof i5.LeafletBaseLayersDirective], never, [typeof i1.LeafletDirective, typeof i2.LeafletLayerDirective, typeof i3.LeafletLayersDirective, typeof i4.LeafletLayersControlDirective, typeof i5.LeafletBaseLayersDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<LeafletModule>;
-}

package/public-api.d.ts

@@ -1,12 +0,0 @@
-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';