@geogirafe/lib-geoportal/components/map/component.d.ts

GeoGirafe is a flexible application to build online geoportals.

import { Map, Feature, MapBrowserEvent, MapEvent, Collection, Overlay } from 'ol';
import { ProjectionLike } from 'ol/proj';
import VectorSource from 'ol/source/Vector';
import VectorLayer from 'ol/layer/Vector';
import { DragBox } from 'ol/interaction';
import { DragBoxEvent } from 'ol/interaction/DragBox';
import { Geometry } from 'ol/geom';
import { Coordinate } from 'ol/coordinate';
import { Extent } from 'ol/extent';
import SwipeManager from './tools/swipemanager';
import WmsManager from '../../tools/wms/wmsmanager';
import WmsManager3d from './tools/wmsmanager3d';
import OsmManager from './tools/osmmanager';
import VectorTilesManager from './tools/vectortilesmanager';
import WmtsManager from './tools/wmtsmanager';
import ViewManager from './tools/viewmanager';
import LocalFileManager from './tools/localfilemanager';
import CogManager from './tools/cogmanager';
import GirafeHTMLElement from '../../base/GirafeHTMLElement';
import Basemap from '../../models/basemap';
import Layer from '../../models/layers/layer';
import MapPosition from '../../tools/state/mapposition';
import BaseLayer from '../../models/layers/baselayer';
import { FocusFeature } from './tools/focusfeature';
import XyzManager from './tools/xyzmanager';
import SelectionParam from '../../models/selectionparam';
declare global {
    interface Window {
        Cesium: unknown;
    }
}
export default class MapComponent extends GirafeHTMLElement {
    template: () => import("uhtml").Hole;
    olMap: Map;
    mapTarget: HTMLDivElement;
    map3d: any;
    map3dTarget: HTMLDivElement;
    map3dShadowsTimestamp: number;
    loading: boolean;
    swiper: HTMLInputElement;
    closeSwiperButton: HTMLButtonElement;
    swipeManager: SwipeManager;
    wmtsManager: WmtsManager;
    wmsManager: WmsManager;
    wmsManager3d: WmsManager3d | null;
    osmManager: OsmManager;
    cogManager: CogManager;
    xyzManager: XyzManager;
    viewManager: ViewManager;
    vectorTilesManager: VectorTilesManager;
    localFileManager: LocalFileManager;
    defaultSrid: ProjectionLike;
    crosshairFeature: Feature;
    crosshairLayer: VectorLayer<VectorSource>;
    tooltipContainer: HTMLElement;
    tooltipOverlay: Overlay;
    get projection(): import("ol/proj").Projection;
    selectedFeaturesCollection: Collection<Feature<Geometry>>;
    highlightedFeaturesCollection: Collection<Feature<Geometry>>;
    selectionLayer: VectorLayer<VectorSource>;
    highlightLayer: VectorLayer<VectorSource>;
    pixelTolerance: number;
    dragbox: DragBox;
    focusFeature: FocusFeature;
    private readonly initialPositionFromUrl;
    constructor();
    resetAllSwipedLayers(layers: BaseLayer[]): void;
    registerEvents(): void;
    activateSharedLayers(layers: BaseLayer[]): void;
    render(): void;
    /**
     * Add a click handler to hide the popup.
     */
    closePopup(): void;
    listenOpenLayersEvents(): void;
    onLoadStart(_e: MapEvent): void;
    onLoadEnd(_e: MapEvent): void;
    onPointerMove(e: MapBrowserEvent<PointerEvent>): void;
    onMoveEnd(_e: MapEvent): void;
    onClick(e: MapBrowserEvent<PointerEvent>): void;
    onDragSelection(_e: DragBoxEvent): void;
    select(extent: number[]): void;
    onSelectFeatures(selectionParams: SelectionParam[]): Promise<void>;
    connectedCallback(): void;
    onCustomGirafeEvent(details: {
        action: string;
        layer: Layer;
        extent: Extent;
    }): void;
    onChangeSwiped(layer: Layer): void;
    /**
     * updates icon position when swipe is moved
     */
    updateCloseSwiperPosition(): void;
    private setSelectLayerStyle;
    private setHighlightLayerStyle;
    private setCrosshairStyle;
    create3dMap(): Promise<void>;
    addAllActiveLayers3dMap(layer: BaseLayer): void;
    onGlobeToggled(): Promise<void>;
    onShadowsToggled(shadows: boolean): void;
    onShadowsTimestampChanged(shadowsTimestamp: number): void;
    onFeaturesSelected(features: Feature[]): void;
    onFeatureHighlighted(features: Feature[]): void;
    onPositionChanged(position: MapPosition): void;
    onChangeScale(scale: number): void;
    zoomToResolution(resolution: number): void;
    zoomToZoom(zoom: number): void;
    zoomToExtent(extent: Extent): void;
    panToCoordinate(coordinate: Coordinate): void;
    onChangeProjection(_oldSrid: string, newSrid: string): void;
    onChangeDarkMode(): void;
    onLayerToggled(layer: Layer): void;
    onAddLayers(layerInfos: Layer[]): void;
    onRemoveLayers(layerInfos: Layer[]): void;
    onChangeOrder: () => void;
    private reorderLayers;
    onChangeOpacity(layerInfos: Layer): void;
    onChangeFilter(layerInfos: Layer): void;
    onChangeTime(layer: BaseLayer): void;
    onChangeBasemap(basemap: Basemap): void;
    /**
     * Add the current map position and zoom level to the URL. The coordinates are provided in
     * the default reference system or in WGS84.
     */
    private updateUrlWithMapPosition;
    /**
     * Reads the map position data from the URL and applies it to the map,
     * making sure map initialization and loading of the shared state have finished beforehand.
     */
    private setMapPositionFromUrlAfterInit;
    /**
     * Updates the map position based on a provided position from the URL. Ensures the position is transformed
     * to the correct map reference system and applies it to the map view if valid.
     * @param {MapPosition} position - The map position object, including center coordinates in the default reference
     * system or WGS84, and zoom level.
     */
    private applyMapPositionFromUrl;
}