@ndwnu/map 0.0.1-beta.5 → 0.0.1-beta.7

package/{index.d.ts → types/ndwnu-map.d.ts}

@@ -1,5 +1,5 @@
 import * as maplibre_gl from 'maplibre-gl';
-import { LngLatLike, LngLatBoundsLike, LayerSpecification, FilterSpecification, MapMouseEvent, MapGeoJSONFeature, SourceSpecification, Map, AnimationOptions, BackgroundLayerSpecification, StyleSpecification } from 'maplibre-gl';
+import { Point, LayerSpecification, FilterSpecification, MapMouseEvent, MapGeoJSONFeature, SourceSpecification, Map, BackgroundLayerSpecification, StyleSpecification, LngLatBoundsLike, LngLatLike, AnimationOptions, DataDrivenPropertyValueSpecification } from 'maplibre-gl';
 import * as rxjs from 'rxjs';
 import { Subject, Observable } from 'rxjs';
 import { Feature, FeatureCollection } from 'geojson';
@@ -7,137 +7,65 @@ import * as i0 from '@angular/core';
 import { AfterViewInit, OnDestroy, ElementRef } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 
-declare const BOUNDS_NL: [LngLatLike, LngLatLike];
-declare const BOUNDS_AMERSFOORT: [LngLatLike, LngLatLike];
-
-interface MapConfig {
-    /** Initial center position of the map */
-    center?: LngLatLike;
-    /** Initial zoom level */
-    zoom?: number;
-    /** Maximum zoom level */
-    maxZoom?: number;
-    /** Minimum zoom level */
-    minZoom?: number;
-    /** Initial bounds to fit the map to */
-    bounds?: LngLatBoundsLike;
-    /** Enable/disable all map interactions */
-    interactive?: boolean;
-    /** Enable/disable map rotation via drag */
-    dragRotate?: boolean;
-    /** Enable/disable double-click to zoom */
-    doubleClickZoom?: boolean;
-    /** Enable/disable scroll wheel zoom */
-    scrollZoom?: boolean;
-    /** Enable/disable shift+drag box zoom */
-    boxZoom?: boolean;
-    /** Enable/disable drag to pan */
-    dragPan?: boolean;
-    /** Enable/disable keyboard navigation */
-    keyboard?: boolean;
-    /** Enable/disable touch zoom and rotation on mobile */
-    touchZoomRotate?: boolean;
-}
-declare const DEFAULT_MAP_CONFIG: Required<Omit<MapConfig, 'bounds'>>;
-declare const COMMON_BOUNDS: {
-    readonly NETHERLANDS: LngLatBoundsLike;
-    readonly AMERSFOORT: LngLatBoundsLike;
-};
-
-declare abstract class MapLayer<TElementType> {
+declare abstract class MapLayer<TElementType, TFilter = unknown, TLegendItem = unknown> {
     #private;
-    protected readonly config: MapElementConfig<TElementType>;
+    protected readonly config: MapElementConfig<TElementType, TFilter, TLegendItem>;
     protected readonly sourceId: string;
     protected readonly layerIdSuffix?: string | undefined;
     initialized: boolean;
     protected unsubscribe: Subject<void>;
-    constructor(config: MapElementConfig<TElementType>, sourceId: string, layerIdSuffix?: string | undefined);
+    constructor(config: MapElementConfig<TElementType, TFilter, TLegendItem>, sourceId: string, layerIdSuffix?: string | undefined);
     get id(): string;
     get styleLayer(): maplibre_gl.StyleLayer | undefined;
     onInit(): void;
     onDestroy(): void;
     setVisible(visible: boolean): void;
-    protected onClick?(features: Feature[]): void;
+    protected onClick?(point: Point, features: Feature[]): void;
     protected abstract getSpecification(): Partial<LayerSpecification>;
-    getFilterSpecification?(): FilterSpecification;
+    getFilterSpecification?(filter?: TFilter): FilterSpecification;
 }
 type ClickEvent = MapMouseEvent & {
     features?: MapGeoJSONFeature[];
 } & object;
 
-declare abstract class MapSource<TElementType> {
+declare abstract class MapSource<TElementType, TFilter = unknown, TLegendItem = unknown> {
     #private;
     readonly id: string;
-    protected readonly config: MapElementConfig<TElementType>;
-    layers: MapLayer<TElementType>[];
+    protected readonly config: MapElementConfig<TElementType, TFilter, TLegendItem>;
+    layers: MapLayer<TElementType, TFilter, TLegendItem>[];
     protected unsubscribe: Subject<void>;
-    constructor(id: string, config: MapElementConfig<TElementType>);
+    protected activeFilter: TFilter | undefined;
+    constructor(id: string, config: MapElementConfig<TElementType, TFilter, TLegendItem>);
     onInit(): void;
     onDestroy(): void;
     get featureCollection$(): Observable<FeatureCollection> | undefined;
     set featureCollection$(value: Observable<FeatureCollection> | undefined);
     get isInitialized(): boolean;
     set isInitialized(value: boolean);
+    get filter$(): Observable<TFilter> | undefined;
+    set filter$(value: Observable<TFilter> | undefined);
     setVisible(visible: boolean): void;
+    reload(): void;
     protected abstract getSpecification(): Partial<SourceSpecification>;
+    protected getFilterSpecification?(filter: TFilter | undefined): FilterSpecification;
+    protected applyFilterToLayers(filterValue: TFilter | undefined): void;
 }
 
-/**
- * Service for managing MapLibre map cursor interactions.
- *
- * Maplibre has no automatic cursor handling for layers, so when you add a clickHandler
- * to a layer, the user can click on it, but the cursor will not change to a pointer.
- * This service provides methods to set the cursor to pointer when hovering over a layer,
- * and to enable crosshair mode which takes precedence over all other cursor types.
- */
-declare class MaplibreCursorService {
-    #private;
-    /**
-     * Sets up mouse cursor handling for a map layer.
-     * Changes cursor to pointer when mouse enters the layer and resets when leaving.
-     *
-     * @param map - The MapLibre map instance
-     * @param layerId - ID of the layer to apply cursor behavior to
-     */
-    setMouseCursor(map: Map, layerId: string): void;
-    /**
-     * Enables or disables crosshair cursor mode for the map.
-     * When enabled, crosshair cursor will take precedence over all other cursor types.
-     *
-     * @param value - True to enable crosshair mode, false to disable
-     * @param map - The MapLibre map instance to apply the cursor to
-     */
-    /**
-     * Enables or disables crosshair cursor mode for the map.
-     * When enabled, crosshair cursor will take precedence over all other cursor types.
-     *
-     * @param value - True to enable crosshair mode, false to disable
-     * @param map - The MapLibre map instance to apply the cursor to
-     */
-    setCrosshairMode(value: boolean, map: Map): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MaplibreCursorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MaplibreCursorService>;
-}
-
-interface MapElementConfig<TElementType> {
-    map: Map;
-    mapElementRepository: MapElementRepository<TElementType>;
-    maplibreCursorService: MaplibreCursorService;
-    elementId: TElementType;
-    elementOrder: number;
-}
-declare abstract class MapElement<TElementType> {
-    protected readonly config: MapElementConfig<TElementType>;
+declare abstract class MapElement<TElementType, TFilter = unknown, TLegendItem = unknown> {
+    protected readonly config: MapElementConfig<TElementType, TFilter, TLegendItem>;
     id: TElementType;
     elementOrder: number;
-    sources: MapSource<TElementType>[];
+    sources: MapSource<TElementType, TFilter, TLegendItem>[];
     alwaysVisible: boolean;
     isVisible: boolean;
+    isInteractive: boolean;
     protected unsubscribe: Subject<void>;
-    constructor(config: MapElementConfig<TElementType>);
+    constructor(config: MapElementConfig<TElementType, TFilter, TLegendItem>);
+    get legendItems(): TLegendItem[];
     onInit(): void;
     onDestroy(): void;
     setVisible(visible: boolean): void;
+    reload(): void;
 }
 
 /**
@@ -146,14 +74,18 @@ declare abstract class MapElement<TElementType> {
  * Also tracks element visibility state and provides observable streams for elements.
  *
  * @typeparam TElementType - The type of ID used for the map elements
+ * @typeparam TFilter - The type of filter used for the map elements
+ * @typeparam TLegendItem - The type of legend item used for the map elements
  */
-declare abstract class MapElementRepository<TElementType> {
+declare abstract class MapElementRepository<TElementType, TFilter = unknown, TLegendItem = unknown> {
     /** Subject that holds the current array of map elements */
     private readonly mapElementsSubject;
     /** Observable stream of all map elements */
-    private readonly mapElements$;
+    readonly mapElements$: rxjs.Observable<MapElement<TElementType, TFilter, TLegendItem>[]>;
     /** Observable stream of only visible map elements */
-    private readonly visibleMapElements$;
+    readonly visibleMapElements$: rxjs.Observable<MapElement<TElementType, TFilter, TLegendItem>[]>;
+    /** Observable stream of legend items from all visible map elements */
+    readonly legendItems$: rxjs.Observable<TLegendItem[]>;
     /**
      * Gets the ids (TElementType) as an array of all map element
      * @returns Array of TElementType
@@ -164,23 +96,28 @@ declare abstract class MapElementRepository<TElementType> {
      * @returns Array of TElementType
      */
     visibleMapElementIds$: rxjs.Observable<TElementType[]>;
+    /**
+     * Gets the ids (TElementType) as an array of all visible map element
+     * @returns Array of TElementType
+     */
+    get visibleMapElementIds(): TElementType[];
     /**
      * Gets the current array of all map elements
      * @returns Array of map elements
      */
-    get mapElements(): MapElement<TElementType>[];
+    get mapElements(): MapElement<TElementType, TFilter, TLegendItem>[];
     /**
      * Gets only the currently visible map elements
      * @returns Array of visible map elements
      */
-    get visibleMapElements(): MapElement<TElementType>[];
+    get visibleMapElements(): MapElement<TElementType, TFilter, TLegendItem>[];
     /**
      * Finds a map element by its ID
      *
      * @param elementId - The ID of the element to find
      * @returns The map element if found, undefined otherwise
      */
-    getMapElementById(elementId: TElementType): MapElement<TElementType> | undefined;
+    getMapElementById(elementId: TElementType): MapElement<TElementType, TFilter, TLegendItem> | undefined;
     /**
      * Checks if a map element is currently visible
      *
@@ -194,13 +131,13 @@ declare abstract class MapElementRepository<TElementType> {
      *
      * @param mapElement - The map element to add
      */
-    addMapElement(mapElement: MapElement<TElementType>): void;
+    addMapElement(mapElement: MapElement<TElementType, TFilter, TLegendItem>): void;
     /**
      * Removes a map element from the repository and destroys it.
      *
      * @param mapElement - The map element to remove
      */
-    removeMapElement(mapElement: MapElement<TElementType>): void;
+    removeMapElement(mapElement: MapElement<TElementType, TFilter, TLegendItem>): void;
     /**
      * Removes all map elements from the repository and destroys them.
      */
@@ -224,6 +161,12 @@ declare abstract class MapElementRepository<TElementType> {
      * @param elementId - The ID of the element to hide
      */
     hideMapElement(elementId: TElementType): void;
+    /**
+     * Triggers a reload of the tiles in the sources of the map element with the given ID
+     *
+     * @param elementId - The ID of the element to reload
+     */
+    reloadMapElement(elementId: TElementType): void;
     /**
      * Toggles the visibility of a map element by its ID.
      * If the element is currently visible, it will be hidden, and vice versa.
@@ -241,53 +184,139 @@ declare abstract class MapElementRepository<TElementType> {
     getBeforeId(elementId: TElementType): string | undefined;
 }
 
-declare abstract class MapComponent implements AfterViewInit, OnDestroy {
+/**
+ * Service for managing MapLibre map cursor interactions.
+ *
+ * Maplibre has no automatic cursor handling for layers, so when you add a clickHandler
+ * to a layer, the user can click on it, but the cursor will not change to a pointer.
+ * This service provides methods to set the cursor to pointer when hovering over a layer,
+ * and to enable crosshair mode which takes precedence over all other cursor types.
+ */
+declare class MaplibreCursorService {
     #private;
-    mapContainer: i0.Signal<ElementRef<any>>;
-    config: i0.InputSignal<Partial<MapConfig>>;
+    /**
+     * Sets up mouse cursor handling for a map layer.
+     * Changes cursor to pointer when mouse enters the layer and resets when leaving.
+     *
+     * @param map - The MapLibre map instance
+     * @param layerId - ID of the layer to apply cursor behavior to
+     */
+    setMouseCursor(map: Map, layerId: string): void;
+    /**
+     * Enables or disables crosshair cursor mode for the map.
+     * When enabled, crosshair cursor will take precedence over all other cursor types.
+     *
+     * @param value - True to enable crosshair mode, false to disable
+     * @param map - The MapLibre map instance to apply the cursor to
+     */
+    /**
+     * Enables or disables crosshair cursor mode for the map.
+     * When enabled, crosshair cursor will take precedence over all other cursor types.
+     *
+     * @param value - True to enable crosshair mode, false to disable
+     * @param map - The MapLibre map instance to apply the cursor to
+     */
+    setCrosshairMode(value: boolean, map: Map): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaplibreCursorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaplibreCursorService>;
+}
+
+interface MapElementConfig<TElementType, TFilter = unknown, TLegendItem = unknown> {
     map: Map;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    resizeMap(): void;
-    zoomToLevel(zoomLevel: number, options?: AnimationOptions): void;
-    protected abstract onLoadMap(): void;
-    protected abstract onRemoveMap(): void;
-    protected abstract onIdle(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MapComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MapComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    mapElementRepository: MapElementRepository<TElementType, TFilter, TLegendItem>;
+    maplibreCursorService: MaplibreCursorService;
+    elementId: TElementType;
+    elementOrder: number;
+    isInteractive?: boolean;
 }
 
-declare class ApiLayer<TElementType> extends MapLayer<TElementType> {
+declare class ApiLayer<TElementType, TFilter = unknown, TLegendItem = unknown> extends MapLayer<TElementType, TFilter, TLegendItem> {
     private readonly _layerSpecification;
-    constructor(config: MapElementConfig<TElementType>, _layerSpecification: LayerSpecification);
+    constructor(config: MapElementConfig<TElementType, TFilter, TLegendItem>, _layerSpecification: LayerSpecification);
     get id(): string;
     protected getSpecification(): Partial<LayerSpecification>;
 }
 
-declare class ApiBackgroundLayer<TEelementType> extends ApiLayer<TEelementType> {
-    constructor(config: MapElementConfig<TEelementType>, layerSpecification: BackgroundLayerSpecification);
+declare class ApiBackgroundLayer<TElementType, TFilter = unknown, TLegendItem = unknown> extends ApiLayer<TElementType, TFilter, TLegendItem> {
+    constructor(config: MapElementConfig<TElementType, TFilter, TLegendItem>, layerSpecification: BackgroundLayerSpecification);
 }
 
 type LayerFilterFunction = (layer: LayerSpecification) => boolean;
-declare class ApiSource<TEelementType> extends MapSource<TEelementType> {
+declare class ApiSource<TElementType, TFilter = unknown, TLegendItem = unknown> extends MapSource<TElementType, TFilter, TLegendItem> {
     private readonly _styleSpecification;
     private readonly _layerFilter?;
-    constructor(id: string, config: MapElementConfig<TEelementType>, _styleSpecification: StyleSpecification, _layerFilter?: LayerFilterFunction | undefined);
-    overrideonInit(): void;
+    constructor(id: string, config: MapElementConfig<TElementType, TFilter, TLegendItem>, _styleSpecification: StyleSpecification, _layerFilter?: LayerFilterFunction | undefined);
     protected getSpecification(): Partial<SourceSpecification>;
-    protected createLayers(layers: LayerSpecification[]): void;
+    /**
+     * Creates ApiLayer instances for this source without initializing them.
+     */
+    createLayers(layers: LayerSpecification[]): void;
 }
 
-declare class ApiElement<TEelementType> extends MapElement<TEelementType> {
+declare class ApiElement<TElementType, TFilter = unknown, TLegendItem = unknown> extends MapElement<TElementType, TFilter, TLegendItem> {
     #private;
     private readonly _http;
     private readonly _mapStyleUrl;
     private readonly _layerFilter?;
-    backgroundLayers: ApiBackgroundLayer<TEelementType>[];
-    constructor(config: MapElementConfig<TEelementType>, _http: HttpClient, _mapStyleUrl: string, _layerFilter?: LayerFilterFunction | undefined);
+    backgroundLayers: ApiBackgroundLayer<TElementType, TFilter, TLegendItem>[];
+    constructor(config: MapElementConfig<TElementType, TFilter, TLegendItem>, _http: HttpClient, _mapStyleUrl: string, _layerFilter?: LayerFilterFunction | undefined);
     onInit(): void;
     setVisible(visible: boolean): void;
 }
 
-export { ApiBackgroundLayer, ApiElement, ApiLayer, ApiSource, BOUNDS_AMERSFOORT, BOUNDS_NL, COMMON_BOUNDS, DEFAULT_MAP_CONFIG, MapComponent, MapElement, MapElementRepository, MapLayer, MapSource, MaplibreCursorService };
+interface MapConfig {
+    /** Initial center position of the map */
+    center?: LngLatLike;
+    /** Initial zoom level */
+    zoom?: number;
+    /** Maximum zoom level */
+    maxZoom?: number;
+    /** Minimum zoom level */
+    minZoom?: number;
+    /** Initial bounds to fit the map to */
+    bounds?: LngLatBoundsLike;
+    /** Enable/disable all map interactions */
+    interactive?: boolean;
+    /** Enable/disable map rotation via drag */
+    dragRotate?: boolean;
+    /** Enable/disable double-click to zoom */
+    doubleClickZoom?: boolean;
+    /** Enable/disable scroll wheel zoom */
+    scrollZoom?: boolean;
+    /** Enable/disable shift+drag box zoom */
+    boxZoom?: boolean;
+    /** Enable/disable drag to pan */
+    dragPan?: boolean;
+    /** Enable/disable keyboard navigation */
+    keyboard?: boolean;
+    /** Enable/disable touch zoom and rotation on mobile */
+    touchZoomRotate?: boolean;
+}
+declare const DEFAULT_MAP_CONFIG: Required<Omit<MapConfig, 'bounds'>>;
+declare const COMMON_BOUNDS: {
+    readonly NETHERLANDS: LngLatBoundsLike;
+    readonly AMERSFOORT: LngLatBoundsLike;
+};
+
+declare abstract class MapComponent implements AfterViewInit, OnDestroy {
+    #private;
+    mapContainer: i0.Signal<ElementRef<any>>;
+    config: i0.InputSignal<Partial<MapConfig>>;
+    map: Map;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    resizeMap(): void;
+    zoomToLevel(zoomLevel: number, options?: AnimationOptions): void;
+    protected abstract onLoadMap(): void;
+    protected abstract onRemoveMap(): void;
+    protected abstract onIdle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapComponent, "ng-component", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const BOUNDS_NL: [LngLatLike, LngLatLike];
+declare const BOUNDS_AMERSFOORT: [LngLatLike, LngLatLike];
+declare const lineWidthFrcSpecification: DataDrivenPropertyValueSpecification<number>;
+
+export { ApiBackgroundLayer, ApiElement, ApiLayer, ApiSource, BOUNDS_AMERSFOORT, BOUNDS_NL, COMMON_BOUNDS, DEFAULT_MAP_CONFIG, MapComponent, MapElement, MapElementRepository, MapLayer, MapSource, MaplibreCursorService, lineWidthFrcSpecification };
 export type { ClickEvent, LayerFilterFunction, MapConfig, MapElementConfig };