import { ClickedFeaturesByLayer, FEATURE_PIXEL_TOLERANCE, IMapImplement, } from "../../map/MapImplement"; import { HighlightedFeatures } from "../../model/layerstatus"; import { ClickedFeature, InternalContextRefType, InternalContextType, LayerState, LolOpenLayersMapContextType, } from "../../context/LolOpenLayersMapContext"; import BaseEvent from "ol/events/Event"; import { LolOpenLayersMapProps } from "../../map/LolOpenLayersMap"; import { IFeatureSource } from "../../sourceDefinition/LolOpenLayersSourceDef"; import { LayerType, LolOpenLayersLayerDef, } from "../../layerDefinition/LolOpenLayersLayerDef"; import { MockFeature, mockVTFeatureLoad, mockVTFeatures, } from "./MockVTFeatures"; import { LolOpenLayersVectorTileLayerDef } from "../../layerDefinition/LolOpenLayersVectorTileLayerDef"; import { compact, flatten, flattenDepth, max, mean, min, sortBy, } from "lodash-es"; import { metresToPixels, pixelsToMetres, resolutionToZoom, shapeCentre, shapeLimits, zoomToResolution, } from "../../utils/Measure"; import { Layer } from "ol/layer"; import { FeatureLike } from "ol/Feature"; import { LolOpenLayersFeatureSourceDef } from "../../sourceDefinition/LolOpenLayersFeatureSourceDef"; import { LolOpenLayersVectorLayerDef, StyleWithContext, } from "../../layerDefinition/LolOpenLayersVectorLayerDef"; import BaseLayer from "ol/layer/Base"; import { Pixel } from "ol/pixel"; import { Source } from "ol/source"; import { Feature, Overlay } from "ol"; import { LineString } from "ol/geom"; import { HIGHLIGHT_LAYER } from "../../map/map-utils"; import { highlightStyleFunction } from "../../style/highlightStyle"; import { StyleLike } from "ol/style/Style"; import { updatePlacementOnMove } from "../../map/placement/UpdatePlacement"; import GeoImage from "ol-ext/source/GeoImage"; import log from "../../utils/Log"; import { createPlacementParams, PlacementParams, } from "../../map/placement/PlacementParams"; export const mockViewportSize = [1500, 1000]; export interface MockLayerState { visible?: boolean; style?: StyleLike | StyleWithContext; features: MockFeature[]; } // Track when we drag the mouse, causing a pan on completion export interface MousePanState { start: number[]; moved: boolean; } export class MockOverlay { mockMap: MockMap; constructor(mockMap: MockMap) { this.mockMap = mockMap; this.mockMap.overlayElement = document.getElementById( "openlayers-mock-overlay" )!!; } getElement() { return document.getElementById("openlayers-mock-overlay")!!; } setPosition(overlayPosition: number[] | undefined) { this.mockMap.overlayPosition = overlayPosition; const overlayElement = this.getElement(); if (!overlayElement) return; if (overlayPosition) { overlayElement.style.visibility = "display"; overlayElement.style.position = "absolute"; const overlayPosition = metresToPixels( this.mockMap.zoom!!, [this.mockMap.centreX!!, this.mockMap.centreY!!], mockViewportSize, this.mockMap.overlayPosition ) ?? [null, null]; [overlayElement.style.left, overlayElement.style.right] = overlayPosition.map((coo) => (coo ?? 500.0).toString()); } else { overlayElement.style.visibility = "hidden"; } } } export class MockMap implements IMapImplement { mapProps: LolOpenLayersMapProps | undefined; centreX: number | undefined; centreY: number | undefined; zoom: number | undefined; mapResolution: number | undefined; mapContext: LolOpenLayersMapContextType | undefined; mockLayerDefs: LolOpenLayersLayerDef[] | undefined; layerState: Record = {}; mousePanState?: MousePanState; loadedVTFeatures?: { [layerName: string]: MockFeature[] }; overlayElement: HTMLElement | undefined; overlayPosition: number[] | undefined; private withInitialZoom = false; private moveEndHandler?: (internalContext: InternalContextType) => void; constructor() { (globalThis as any).mockMap = this; } public resetState(): void { this.centreX = undefined; this.centreY = undefined; this.zoom = undefined; this.mapResolution = undefined; this.mapContext = undefined; this.mockLayerDefs = undefined; this.layerState = {}; this.mousePanState = undefined; } /** * Set vector tile features. * Vector tiles are loaded from Geoserver. This in effect stubs that and allows an application * to supply features in mock React testing that are treated as vector tiles. * * @param featureLayers a map of feature name to an array of features */ public setVTFeatures(featureLayers: Record): void { this.loadedVTFeatures = mockVTFeatureLoad(this, featureLayers); } copySelectionsToHighlightLayer( allSelectedFeaturesByPanel: HighlightedFeatures[] | null, mapContext: LolOpenLayersMapContextType ): void { if (!allSelectedFeaturesByPanel) return; const highlightLayer = this.layerState[HIGHLIGHT_LAYER]; if (!highlightLayer) this.layerState[HIGHLIGHT_LAYER] = { features: [] }; highlightLayer.features = []; allSelectedFeaturesByPanel?.forEach(({ layerName, selectedFeatures }) => { const layerDef = this.mockLayerDefs?.find((l) => l.name === layerName); if ( mapContext.layerStatus(layerName)?.layerVisibility ?? layerDef?.visible ?? true ) { this.layerState[layerName].features.forEach((f: MockFeature) => { log.debug(`Highlight feature id ${f.get("id")}`); if ( selectedFeatures.includes(f.get("id")) && !highlightLayer.features.find((hf) => hf.get("id") === f.get("id")) ) { const newHighlightFeature = { ...f, layerName: HIGHLIGHT_LAYER }; highlightLayer.features.push(newHighlightFeature); } }); } }); } handleClick(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); mapDiv.addEventListener("click", (event) => { return ( internalContext.ref()?.inContext() && internalContext .ref() ?.onClick?.( [event.clientX, event.clientY], pixelsToMetres( this.zoom!, [this.centreX!, this.centreY!], mockViewportSize, [event.clientX, event.clientY] ) as number[], this ) ); }); } handleRightClick(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); mapDiv.addEventListener("contextmenu", (event) => { let anchorPoint = { x: event.clientX, y: event.clientY, }; if (!internalContext.ref()?.inContext()) return; const clickedFeatures = this.getFeaturesAtPixel( [event.clientX, event.clientY], FEATURE_PIXEL_TOLERANCE ); return ( internalContext.ref()?.inContext() && internalContext .ref() ?.onContextMenu?.( clickedFeatures, pixelsToMetres( this.zoom!, [this.centreX!, this.centreY!], mockViewportSize, [event.clientX, event.clientY] ) as number[], anchorPoint ) ); }); } handleError(_handler: (event: BaseEvent) => void): void {} handleDrawStart(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); /** Use mousedown to trigger draw start */ mapDiv.addEventListener("mousedown", () => { return ( internalContext.ref()?.inContext() && internalContext.ref()?.onDrawStart ); }); } handleDrawEnd(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); /** Use mouseup to trigger draw end */ mapDiv.addEventListener("mouseup", () => { // feature let drawFeature = new Feature({ geometry: new LineString([ [4e6, 2e6], [8e6, -2e6], ]), name: "My line", }); if (drawFeature) { /** * Pass draw feature for draw end callback */ return ( internalContext.ref()?.inContext() && internalContext.ref()?.onDrawEnd?.(drawFeature) ); } }); } handleSnap(): void {} handleModifyStart(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); /** Use mousedown to trigger modify start */ mapDiv.addEventListener("mousedown", () => { return ( internalContext.ref()?.inContext() && internalContext.ref()?.onModifyStart ); }); } handleModifyEnd(internalContext: InternalContextType): void { const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("handleClick when no map element"); /** Use mouseup to trigger modify end */ mapDiv.addEventListener("mouseup", () => { // feature let modifyFeature = new Feature({ geometry: new LineString([ [4e6, 2e6], [5e6, 6e6], [8e6, -2e6], ]), name: "My modify line", }); if (modifyFeature) { /** * Pass modify feature for modify end callback */ return ( internalContext.ref()?.inContext() && internalContext.ref()?.onModifyEnd?.([modifyFeature]) ); } }); } handleLoading( _internalContext: InternalContextType, _setLoading: (state: boolean) => void ): void {} handleMoveStart(_internalContext: InternalContextType): void {} handleMoveEnd( _mapContext: LolOpenLayersMapContextType | undefined, _internalContext: InternalContextType ): void { this.moveEndHandler = (internalContext: InternalContextType) => { updatePlacementOnMove(internalContext, this.getPlacementParams()); }; } unHandleAll(): void {} populateOpenlayersMap( mapProps: LolOpenLayersMapProps, mapContext: LolOpenLayersMapContextType, internalContext: InternalContextType, setLoading: (state: boolean) => void ): void { this.mapProps = mapProps; // Set initial values this.mapProps = mapProps; this.centreX = mapProps.view.center[0]; this.centreY = mapProps.view.center[1]; this.zoom = mapProps.view.zoom; const ZOOM_0_RESOLUTION = 156543.03390625; // resolution for zoom 0 // see https://stackoverflow.com/questions/29900520/is-there-a-getzoomforresolution-in-openlayers-3 this.mapResolution = Math.pow( 2, Math.log2(ZOOM_0_RESOLUTION) - this.mapProps?.view.zoom ); this.mapContext = mapContext; this.mockLayerDefs = mapProps.layers; this.withInitialZoom = mapProps.layers.some( (l) => (l as LolOpenLayersVectorLayerDef).inInitialZoom ); const mockFeatures = this.loadedVTFeatures ?? mockVTFeatures(this); const layerStateEntries: (string | MockLayerState)[][] = flattenDepth( this.mockLayerDefs.map((l) => { if (l.type === LayerType.VECTOR_TILE) { const res = [ [ l.name, { features: mockFeatures[l.name], style: (l as LolOpenLayersVectorTileLayerDef).style, visible: l.visible ?? true, } as MockLayerState, ], ]; if ((l as LolOpenLayersVectorTileLayerDef).labelStyle) { res.push([ `${l.name}_labels`, { features: mockFeatures[l.name], style: (l as LolOpenLayersVectorTileLayerDef).labelStyle, visible: l.visible ?? true, } as MockLayerState, ]); } return res; } let sourceFeatures = (l.source as LolOpenLayersFeatureSourceDef)?.data ?? []; sourceFeatures = (l as LolOpenLayersVectorLayerDef).featureFilter?.(sourceFeatures) ?? sourceFeatures; const features = sourceFeatures?.map((f) => new MockFeature(this, l.name, f)) ?? []; return [ [ l.name, { features, style: (l as LolOpenLayersVectorLayerDef).style, visible: l.visible ?? true, } as MockLayerState, ], ]; }), 1 ) as unknown as (string | MockLayerState)[][]; this.layerState = Object.fromEntries(layerStateEntries); this.layerState[HIGHLIGHT_LAYER] = { features: [], style: highlightStyleFunction, visible: true, } as MockLayerState; const mapDiv = document.getElementById("map"); if (!mapDiv) throw new Error("populateOpenlayersMap when no map element"); if (mapProps.withOverlay) { internalContext ?.ref() ?.setOverlay(new MockOverlay(this) as unknown as Overlay); } setLoading(false); if (internalContext.ref()?.inContext()) { internalContext.ref()?.setLoading(false); } mapDiv.addEventListener("mousedown", (event) => { this.mousePanState = { start: [event.clientX, event.clientY], moved: false, }; }); mapDiv.addEventListener("mousemove", (_event) => { if (this.mousePanState) this.mousePanState.moved = true; }); mapDiv.addEventListener("mouseup", (event) => { if (this.mousePanState?.moved) { const movement = [ event.clientX - this.mousePanState.start[0], event.clientY - this.mousePanState.start[1], ]; const centreBeforeMetres = [this.centreX!, this.centreY!]; const centrePixels = metresToPixels( this.zoom!, centreBeforeMetres, mockViewportSize, centreBeforeMetres ); const centreAfterPixels = centrePixels!.map( (v, idx) => v + movement[idx] ); [this.centreX, this.centreY] = pixelsToMetres( this.zoom!, centreBeforeMetres, mockViewportSize, centreAfterPixels )!; this.mousePanState = undefined; } this.moveEndHandler?.(internalContext); }); } setMap = (internalContext: InternalContextRefType) => { internalContext.setMapImplement(this); }; setTargetRef(_ref: React.MutableRefObject): void {} targetZoomControl(): void {} updateLayerVisibility( mapContext: LolOpenLayersMapContextType | undefined, internalContext: InternalContextRefType | undefined, layerStatusMap?: Record, layerNames?: string[] ): void { this.mockLayerDefs?.forEach((layerDef) => { const layerName = layerDef.name; if (!layerNames || layerNames.includes(layerName)) { const contextLayerStatus = mapContext ? mapContext.layerStatus(layerName) : layerStatusMap?.[layerName]?.status; if (contextLayerStatus) { const labelLayerName = `${layerName}_labels`; if (this.layerState[labelLayerName]) { this.layerState[labelLayerName].visible = !!contextLayerStatus?.layerLabelsChecked; } this.layerState[layerName].visible = ((internalContext?.zoomed() || this.isVisibleAtStart(layerDef)) && contextLayerStatus.layerVisibility) ?? false; } } }); } updateSource( layerName: string, _layerDef: LolOpenLayersLayerDef | undefined, result: IFeatureSource[] ): boolean { const loadedFeatures = result?.map( (sourceFeature) => new MockFeature(this, layerName, { ...sourceFeature, name: sourceFeature.label ?? sourceFeature.name, }) ) || []; if (this.layerState[layerName]) { this.layerState[layerName].features = loadedFeatures; } else { this.layerState[layerName] = { features: loadedFeatures, }; } return false; } zoomToFit( mapContext: LolOpenLayersMapContextType | undefined, internalContext: InternalContextRefType | undefined, layerStatusMap?: Record ): boolean { const res = this.doZoomToFit(); this.updateLayerVisibility(mapContext, internalContext, layerStatusMap); return res; } private doZoomToFit() { const features = flatten( this.mockLayerDefs ?.filter((l) => (l as LolOpenLayersVectorLayerDef).inInitialZoom) .map((l) => { const sourceData = (l.source as LolOpenLayersFeatureSourceDef)?.data; if (sourceData) return sourceData?.map((fs) => new MockFeature(this, l.name, fs)); return this.layerState[l.name].features; }) ); const featureBounds = compact( features.map((f) => shapeLimits(f?.attributes?.shape)) ); if (!featureBounds) return false; const meanCentres = [ mean(featureBounds.map((fb) => (fb[0] + fb[2]) / 2)), mean(featureBounds.map((fb) => (fb[1] + fb[3]) / 2)), ]; // eslint-disable-next-line @typescript-eslint/no-unused-vars const featuresByDist = sortBy( compact( features.map((f) => { const fb = shapeLimits(f?.attributes?.shape); if (!fb) return null; const dx = (fb[0] + fb[2]) / 2 - meanCentres[0]; const dy = (fb[1] + fb[3]) / 2 - meanCentres[1]; return { id: f.get("id"), name: f.get("name"), dist: Math.sqrt(dx * dx + dy * dy), }; }) ), (r) => -r.dist ); const extent = featureBounds?.reduce( (acc, limits) => [ min(compact([acc[0], limits[0]])) ?? Infinity, min(compact([acc[1], limits[1]])) ?? Infinity, max(compact([acc[2], limits[2]])) ?? -Infinity, max(compact([acc[3], limits[3]])) ?? -Infinity, ], [Infinity, Infinity, -Infinity, -Infinity] ); if ( !extent || extent[0] === Infinity || extent[1] === Infinity || extent[2] === -Infinity || extent[3] === -Infinity ) return false; this.centreX = (extent[0] + extent[2]) / 2; this.centreY = (extent[1] + extent[3]) / 2; const scale = [ (extent[2] - extent[0]) / 1500.0, (extent[3] - extent[1]) / 1000.0, ]; this.mapResolution = max(scale) ?? 1.0; this.zoom = resolutionToZoom(this.mapResolution); return true; } zoomMapByDelta = (delta: number) => { this.zoom = (this.zoom ?? 24) + delta; this.mapResolution = zoomToResolution(this.zoom); }; findMapLayerByName(layerName: string): BaseLayer | undefined { if (layerName.endsWith("_labels")) { const layerDef = this.mockLayerDefs?.find( (l) => `${l.name}_labels` === layerName ); return layerDef ? ({ className: layerName, getClassName: () => layerName, } as unknown as BaseLayer) : undefined; } const layerDef = this.findMockLayerDefByName(layerName); return layerDef ? ({ className: layerDef.name, getClassName: () => layerDef.name, } as unknown as BaseLayer) : undefined; } private findMockLayerDefByName(layerName: string) { return this.mockLayerDefs?.find((l) => l.name === layerName); } getFeaturesAtPixel( pixel: Pixel, hitTolerancePixels: number | undefined ): ClickedFeature[] { const clickedFeatures = flatten( Object.entries(this.layerState).map(([layerName, state]) => { if (!state.visible) return []; if (this.findMockLayerDefByName(layerName)?.disableClicks) return []; return compact( (state.features ?? []).map((feature) => { const location = metresToPixels( this.zoom!, [this.centreX!, this.centreY!], mockViewportSize, shapeCentre(feature.get("shape")) ); if (!location) return null; let distanceFromClick; if (layerName.endsWith("_labels")) { // Approximate distance from an arbitrary 40x25 label box if (Math.abs(location[1] - pixel[1]) > 20) { // out of frame by y distanceFromClick = Math.abs(location[1] - pixel[1]); } else { distanceFromClick = min([ Math.abs(pixel[0] - (location[0] + 25)), Math.abs(location[0] - 25 - pixel[0]), ]) ?? 10000; } } else { distanceFromClick = Math.sqrt( Math.pow(location[0] - pixel[0], 2) + Math.pow(location[1] - pixel[1], 2) ); } return { layerName, feature, location, fromClick: distanceFromClick, }; }) ); }) ); const sortedFeatures = sortBy( clickedFeatures.filter((f) => f.fromClick <= (hitTolerancePixels ?? 5)), (f) => f.fromClick ); return sortedFeatures.map((f) => ({ layer: { getClassName: () => f.layerName } as unknown as Layer, feature: f.feature as unknown as FeatureLike, distance: f.fromClick, })); } getFeaturesAtPixelOrderedByClosestToClick( pixelCoordinates: Pixel, hitTolerancePixels: number = FEATURE_PIXEL_TOLERANCE, includeLayerNames?: string[] ): ClickedFeaturesByLayer { // CONSIDER: this is common to MapImplement const result: ClickedFeaturesByLayer = {}; // This works by calling getFeaturesFromClick for an ever-increasing search radius // adding new featureIds as they are found. This makes sure the closest features are returned first. const layerAlreadyPopulated = new Set(); for (let ht = 1; ht <= hitTolerancePixels; ht++) { const layerNextPopulated = new Set(); this.getFeaturesAtPixel(pixelCoordinates, ht).forEach((f) => { if (!f.layer) return; // We can click features that dont have a layer (?) const layerName = f.layer.getClassName(); if (layerAlreadyPopulated.has(layerName)) return; if (includeLayerNames && !includeLayerNames.includes(layerName)) return; // If feature is not in list for layer, then append it to the end of featureIds const id = f.feature.getId() ?? f.feature.get("id"); let layerFeatures = result[layerName]; layerNextPopulated.add(layerName); if (!layerFeatures) { layerFeatures = { ids: [], features: [], }; result[layerName] = layerFeatures; } if (!layerFeatures.ids.includes(id)) { layerFeatures.ids.push(id); layerFeatures.features.push(f.feature); } }); layerNextPopulated.forEach((l) => layerAlreadyPopulated.add(l)); } return result; } layerChanged(_layerName: string): void {} labelLayerChanged(_layerName: string, _labelLayerChanged?: boolean): void {} layerNames(): string[] { return this.mockLayerDefs?.map((l) => l.name) ?? []; } layerDefs = () => Object.fromEntries( (this.mockLayerDefs ?? []).map((layer: LolOpenLayersLayerDef) => [ layer.name, layer, ]) ); loadChangedFeaturesFrom( layerName: string, layerDef: LolOpenLayersLayerDef | undefined, featureData: IFeatureSource[] | string | GeoImage ): void { if (Array.isArray(featureData)) { this.updateSource(layerName, layerDef, featureData); } } getConfig(): LolOpenLayersMapProps | undefined { return undefined; } getUnclippedFeatures(_layerName: string): IFeatureSource[] { return []; } private isVisibleAtStart(layerDef: LolOpenLayersLayerDef) { return this.withInitialZoom ? (layerDef as LolOpenLayersVectorLayerDef).inInitialZoom : (layerDef.visible ?? true); } getPlacementParams(): PlacementParams | undefined { if (!this.zoom || !this.centreX || !this.centreY) return undefined; const swMetres = pixelsToMetres( this.zoom, [this.centreX, this.centreY], mockViewportSize, [0, 0] )!; const neMetres = pixelsToMetres( this.zoom, [this.centreX, this.centreY], mockViewportSize, mockViewportSize )!; // Convert the map extent corners in the map projection // into offset degrees return createPlacementParams( mockViewportSize, [...swMetres, ...neMetres], this.mapProps?.defaultDataProjection ?? "EPSG:1" ); } } const mockMapInstance = new MockMap(); export const getMockMap = (): MockMap => mockMapInstance;