import { LolOpenLayersViewDef } from "../viewDefinition/LolOpenLayersViewDef"; import { ReactElement, ReactNode, useContext, useEffect, useRef, useState, } from "react"; import { getMapImplement } from "./MapImplement"; import { AutoLabelPlacementType, ClickedFeature, InternalContext, InternalContextType, LolOpenLayersMapContext, } from "../context/LolOpenLayersMapContext"; import proj4 from "proj4"; import { LolOpenLayersFeatureSourceDef } from "../sourceDefinition/LolOpenLayersFeatureSourceDef"; import { LayerType, LolOpenLayersLayerDef, LolOpenLayersLayerGroupDef, } from "../layerDefinition/LolOpenLayersLayerDef"; import { LuiMiniSpinner } from "@linzjs/lui"; import "./LolOpenLayersMap.scss"; import { QueryClient, QueryObserver } from "@tanstack/react-query"; import { IFeatureSource } from "../sourceDefinition/LolOpenLayersSourceDef"; import { compact, flatten, uniq } from "lodash-es"; import { FeatureModeEnum, useLolOpenLayersFeatureClickEvent, } from "../events/LolOpenLayersFeatureClickEvent"; import { getMockMap } from "../testSupport/mock/MockMap"; import { LolOpenLayersVectorLayerDef } from "../layerDefinition/LolOpenLayersVectorLayerDef"; import { featureId } from "../utils/FeatureUtil"; import { LolOpenLayersDrawInteraction, LolOpenLayersModifyInteraction, LolOpenLayersSnapInteraction, } from "../interactionDefinition/LolOpenLayersInteractionDef"; import { FeatureLike } from "ol/Feature"; import log from "../utils/Log"; import { baseLayerName } from "../utils/LayerUtil"; import { projectionSetup } from "./ProjectionSetup"; export interface IShape { /** a GeoJSON object */ shape?: Record | null; } /** * Properties for {@link LolOpenLayersMap} */ export interface LolOpenLayersMapProps { /** children will be inserted into the DOM after the `map` div */ children?: ReactNode; /** Defines the view with initial viewport coordinates, projection and scale */ view: LolOpenLayersViewDef; /** Defines the Tile, VectorTile and Vector layers that make up the map */ layers: LolOpenLayersLayerDef[]; /** Group layers into a collection that are handled together in Openlayers, * see https://openlayers.org/en/latest/apidoc/module-ol_layer_Group-LayerGroup.html */ layerGroup?: LolOpenLayersLayerGroupDef; /** Indicated if the map component should manage the loading indicator */ useLoadingIndicator?: boolean; /** Use the QueryClient of the parent - required if using queries*/ queryClient?: QueryClient; /** Buffer the default zoom to bufferfactor, e.g. 1.1 leaves a 10% margin, default is 1.05 **/ bufferFactor?: number; /** Interactions for draw **/ drawInteraction?: LolOpenLayersDrawInteraction; /** Interactions for snap **/ snapInteraction?: LolOpenLayersSnapInteraction; /** Interactions for modify **/ modifyInteraction?: LolOpenLayersModifyInteraction; /** For testing, mock the map rather than using Openlayers **/ mock?: boolean; /** Enable an openlayers Overlay which can have its element accessed (to set contents, etc) * with mapContext.getOverlayRef * https://openlayers.org/en/latest/apidoc/module-ol_Overlay-Overlay.html */ withOverlay?: boolean; /** Show default zoom control or not */ withDefaultZoom?: boolean; /** disable zoom on double click */ disableDoubleClickZoom?: boolean; /** Map z index */ mapZIndex?: number; /** enable auto placement */ enableAutoPlacement?: boolean; /** configuration for absolute or offset label placements */ autoLabelPlacementType?: AutoLabelPlacementType; /** Show only placed labels, hide unplaced */ showOnlyPlacedLabels?: boolean; /** Function to set custom feature selection priority */ sortFeaturesBySelectionPriority?: ( features: ClickedFeature[] ) => ClickedFeature[]; /** The default data projection, defaulted to EPSG:1 for offset degrees * EPSG:4326 for regular WGS84 (can also be used for NZTM) */ defaultDataProjection?: string; } /** * React wrapper for the openlayers https://openlayers.org/en/latest/apidoc/ library * to render interactive maps * * @param props The React properties */ export const LolOpenLayersMap = ( props: LolOpenLayersMapProps ): ReactElement => { const initialZoomLayers = () => props.layers.filter( (l) => (l as LolOpenLayersVectorLayerDef).inInitialZoom && (l.visible ?? true) ); const [loadedLayers, setLoadedLayers] = useState(); const [loading, setLoading] = useState(true); const [loadingZoomLayers, setLoadingZoomLayers] = useState(true); const [loadedZoomLayers, setLoadedZoomLayers] = useState( initialZoomLayers() .filter((l) => (l.source as LolOpenLayersFeatureSourceDef)?.data) .map((l) => l.name) ); const [populateDone, setPopulateDone] = useState(false); const [initialZoomDone, setInitialZoomDone] = useState(false); const [ctrlKeyDown, setCtrlKeyDown] = useState(false); const setupHandlersRef = useRef(true); const mapRef = useRef(null); const mapContext = useContext(LolOpenLayersMapContext); const internalContext = useContext(InternalContext); if (!mapContext && props.enableAutoPlacement) { throw new Error( "LolOpenLayersMap: a MapContext must be defined when `enableAutoPlacement` set" ); } const layerIndexForFeature = (clickedFeature: ClickedFeature) => props.layers.findIndex( (layer) => layer.name === clickedFeature.layer.getClassName() ); // Previously, ∃ code in landonline-survey that expected only [name,type] to be unique // But there were no name clashes, so we make name unique on its own // for all client applications const layerNames = props.layers.map((l) => l.name); if (uniq(layerNames).length !== props.layers.length) { throw new Error("LolOpenLayersMap: layer names must be unique"); } const mapImplement = props.mock ? getMockMap() : getMapImplement(); projectionSetup(); const toggleFeatureSelected = ( internalContext: InternalContextType, clickedFeature: ClickedFeature ) => { const layerName = baseLayerName(clickedFeature.layer); const layerSelectedFeatures = mapContext.featureSelect(layerName); const clickedId = (clickedFeature.feature.getId() as number) | (clickedFeature.feature.get("id") as number); let newLayerSelectedFeatures: (number | FeatureLike)[] = []; const existingSelectedFeature = layerSelectedFeatures?.find( (f) => featureId(f) === clickedId ); if (existingSelectedFeature) { newLayerSelectedFeatures = layerSelectedFeatures.filter( (f) => featureId(f) !== clickedId ); } else { if (ctrlKeyDown) { newLayerSelectedFeatures = [ ...layerSelectedFeatures, clickedFeature.feature, ]; } else { newLayerSelectedFeatures.push(clickedFeature.feature); } } mapContext.setFeatureSelect(layerName, newLayerSelectedFeatures); const layerSelection = props.layers .filter((l) => (l as LolOpenLayersVectorLayerDef).togglable) .map((l) => { // We can define selected features in layerSelectedFeatures by id or as complete features // in the former case, ensure we don't pass through features const features = l.name === layerName ? Array.from(newLayerSelectedFeatures) : mapContext.featureSelect(l.name); const ids = features.map((f) => featureId(f) as number); return { layerName: l.name, ids, features: compact( features.map((f) => { if (typeof f === "number") { return null; } return { ...f.getProperties(), id: featureId(f), } as IFeatureSource; }) ), }; }); log.debug( `layerSelection=${JSON.stringify( layerSelection )}, internalContext=${JSON.stringify(internalContext)}` ); internalContext.ref()?.onSelect?.(layerSelection); }; // Initialize the state from layers on start useEffect(() => { if (loadingZoomLayers) { props.layers.forEach((layerDef) => { mapContext.setLayerStatus(layerDef.name, { layerToggle: (layerDef as LolOpenLayersVectorLayerDef)?.togglable, layerVisibility: !loadingZoomLayers, layerLabelsChecked: !loadingZoomLayers, layerBadgesChecked: !loadingZoomLayers, showLabelsOnMap: !loadingZoomLayers, showBadgesOnMap: !loadingZoomLayers, layerOpacity: layerDef.opacity ?? 1, ...mapContext.layerStatus(layerDef.name), }); }); } else { props.layers.forEach((layerDef) => { mapContext.setLayerStatus(layerDef.name, { layerToggle: (layerDef as LolOpenLayersVectorLayerDef)?.togglable, layerVisibility: layerDef.visible ?? true, layerLabelsChecked: layerDef.visible ?? true, layerBadgesChecked: layerDef.visible ?? true, showLabelsOnMap: layerDef.visible ?? true, showBadgesOnMap: layerDef.visible ?? true, layerOpacity: layerDef.opacity ?? 1, ...mapContext.layerStatus(layerDef.name), }); }); } }, [loadingZoomLayers]); const findLayerDefByName = (layerName: string) => props.layers.find( (l) => l.name === layerName || `${l.name}_labels` === layerName ); useEffect(() => { if (internalContext.ref()) { log.debug(`setEnableAutoPlacement - ${props.enableAutoPlacement}`); mapImplement.setMap(internalContext.ref()!); internalContext .ref() ?.setEnableAutoPlacement(props.enableAutoPlacement === true); internalContext .ref() ?.setShowOnlyPlacedLabels(props.showOnlyPlacedLabels === true); internalContext .ref() ?.setAutoLabelPlacementType( props?.autoLabelPlacementType ?? AutoLabelPlacementType.OFFSET ); } }, [internalContext.ref(), props.enableAutoPlacement]); useEffect(() => { if (initialZoomDone) { if (log.getLevel() <= log.levels.TRACE) { const layerVisDebug = props.layers.map( (layerDef) => `${layerDef.name} <= ${ mapContext.layerStatus(layerDef.name).layerVisibility }` ); log.debug(`InitialZoomDone, updateLayerVisibility ${layerVisDebug}`); } mapImplement.updateLayerVisibility(mapContext, internalContext.ref()); } }, [mapContext, internalContext.ref(), initialZoomDone]); useEffect(() => { if (!populateDone) return; const unsubscribeObservers: (() => void)[] = []; props.layers.forEach((layerDef) => { if (layerDef.type === LayerType.VECTOR) { const layerName = layerDef.name; if (!loadedLayers?.includes(layerName)) { log.debug(`load layer: ${layerName}`); setLoadedLayers([...(loadedLayers || []), layerName]); const layerDef = findLayerDefByName(layerName); const layerSource = layerDef?.source as | LolOpenLayersFeatureSourceDef | undefined; if (layerSource?.projection) { if (!proj4.defs(layerSource.projection)) { const projMessage = `Layer ${layerName} uses undefined projection ${layerSource.projection}`; mapContext.errorMessages.push(projMessage); throw Error(projMessage); } } if (layerSource?.queryKey && layerSource.queryFun) { log.debug(`Load query for layer ${layerName}`); if (!props.queryClient) { const message = `Layer ${layerName} uses a query but no valid queryClient passed to LolOpenlayersMap`; mapContext.errorMessages.push(message); throw Error(message); } const queryObserver = new QueryObserver( props.queryClient, { queryKey: layerSource?.queryKey, queryFn: layerSource.queryFun, refetchOnWindowFocus: layerSource.refetchOnWindowFocus ?? true, } ); unsubscribeObservers.push( queryObserver.subscribe((result) => { if (result?.data) { const showData = (layerDef as LolOpenLayersVectorLayerDef)?.featureFilter?.( result.data ) ?? result.data; log.debug( `from subscribe ${layerName} add features ${JSON.stringify( result?.data )}` ); mapImplement.updateSource(layerName, layerDef, showData); //mapContext.clearFeaturesChanged(layerName); if ((layerDef as LolOpenLayersVectorLayerDef).labelStyle) { const labelLayerName = layerName + "_labels"; mapImplement.updateSource( labelLayerName, layerDef, showData ); //mapContext.clearFeaturesChanged(labelLayerName); } // Flag that we have loaded a layer, so that when all // are loaded we can zoom if (!initialZoomDone) { setLoadedZoomLayers((wasLoadedZoomLayers) => uniq([...wasLoadedZoomLayers, layerName]) ); } } }) ); } } } return () => { unsubscribeObservers.forEach((o) => o()); }; }); }, [loadedLayers, populateDone, initialZoomDone]); useEffect(() => { if (initialZoomDone) return; // We test that all the visible zoom layers have loaded before zooming // The `loadedZoomLayers` is initialized to all the visible layers with data, and then // the query observer adds the rest const wantedZoomLayers = initialZoomLayers().filter( (l) => l.visible ?? true ); log.debug( `call zoomToFit: wantedZoomLayers=${wantedZoomLayers.map( (l) => l.name )} loadedZoomLayers=${loadedZoomLayers}` ); if (populateDone && loadedZoomLayers.length >= wantedZoomLayers.length) { log.debug("initialZoomDone := true"); mapImplement.zoomToFit(mapContext, internalContext.ref()); internalContext.ref()?.setZoomed(); setInitialZoomDone(true); setLoadingZoomLayers(false); } else { setLoadingZoomLayers(true); } }, [populateDone, loadedZoomLayers, initialZoomDone, mapContext?.loading]); // We dogfood our own click event to implement feature selection with the correct state // this sorts by layer so as to avoid always selecting the vector (or parcel) useLolOpenLayersFeatureClickEvent( (features, _, initInternalContext) => { const toggleableLayers = props.layers .filter((l) => (l as LolOpenLayersVectorLayerDef).togglable !== false) .map((l) => l.name); const clickedFeatures = flatten([features]) // arrayify the features .filter((cf) => { const cn = cf.layer.getClassName(); return ( toggleableLayers.includes(cn) || toggleableLayers.includes(cn.replace("_labels", "")) ); }); // Filter out non-toggleable layers if (!clickedFeatures.length) return true; let sortByPriority = props.sortFeaturesBySelectionPriority; if (!sortByPriority) { // If there is no custom selection priority set, we just follow layer index. sortByPriority = (features: ClickedFeature[]) => { return features.sort((fa, fb) => { const la = layerIndexForFeature(fa); const lb = layerIndexForFeature(fb); return la - lb; }); }; } let featuresSortedByPriority = sortByPriority(clickedFeatures); log.debug( `LolOpenLayersMap - click event featuresSortedByPriority=${featuresSortedByPriority.map( (f) => [ f.layer.getClassName(), f.feature.getId() ?? f.feature.get("id"), ] )}` ); // NOTE: If multiple features from same layer are selected (such as new and existing parcels), // we will select the one with the smaller id const chosenClickedFeature = featuresSortedByPriority[0]; toggleFeatureSelected(initInternalContext, chosenClickedFeature); return true; }, { type: FeatureModeEnum.MULTIPLE } ); useEffect(() => { mapImplement.populateOpenlayersMap( props, mapContext, internalContext, (v) => { log.debug(`setLoading ${v} by populate`); setLoading(v); } ); mapImplement.setTargetRef(mapRef); setLoadedLayers([]); /** Add default zoom control */ if (props.withDefaultZoom) { mapImplement.targetZoomControl(); } // mapImplement.zoomToFit(); setPopulateDone(true); return () => setPopulateDone(false); }, [props.withDefaultZoom]); useEffect(() => { if (!loadingZoomLayers) { props.layers.forEach((layerDef) => { const layerName = layerDef.name; const visibility = layerDef?.visible ?? true; const zIndex = layerDef?.zIndex; const opacity = layerDef?.opacity; mapContext.setLayerStatus(layerName, { ...mapContext.layerStatus(layerName), layerZIndex: zIndex, layerOpacity: opacity, layerVisibility: visibility, layerLabelsChecked: visibility, layerBadgesChecked: visibility, showLabelsOnMap: visibility, showBadgesOnMap: visibility, }); }); } }, [loadingZoomLayers]); useEffect(() => { const keydownHandler = (event: KeyboardEvent) => { if (event.key === "Control") { setCtrlKeyDown(true); } }; const keyupHandler = (event: KeyboardEvent) => { if (event.key === "Control") { setCtrlKeyDown(false); } }; log.debug("set keyboard handlers"); window.addEventListener("keydown", keydownHandler); window.addEventListener("keyup", keyupHandler); return () => { log.debug(`remove keyboard handlers`); window.removeEventListener("keydown", keydownHandler); window.removeEventListener("keyup", keyupHandler); }; }, []); useEffect(() => { // console.warn( // `DEBUG: setupHandlers effect setter setupHandlersRef.current=${ // setupHandlersRef.current // } internalContext.ref()=${!!internalContext.ref()}` // ); if (setupHandlersRef.current && internalContext.ref()) { log.debug(`DEBUG: setupHandlers`); mapImplement.handleMoveStart(internalContext); mapImplement.handleMoveEnd(mapContext, internalContext); if (internalContext.ref()?.onClick) { mapImplement.handleClick(internalContext); } /** * map draw event */ mapImplement.handleDrawStart(internalContext); mapImplement.handleDrawEnd(internalContext); mapImplement.handleSnap(); /** Map modify event */ mapImplement.handleModifyStart(internalContext); mapImplement.handleModifyEnd(internalContext); mapImplement.handleRightClick(internalContext); mapImplement.handleLoading(internalContext, (v) => { if (loading !== v) { log.debug(`DEBUG: setLoading ${v} by mapImplement`); setLoading(v); } }); mapImplement.handleError((event) => { console.error(event); mapContext.errorMessages.push( "LolOpenLayersMap: Received an unexpected error" ); }); setupHandlersRef.current = false; } return () => { if (!setupHandlersRef.current) { mapImplement.unHandleAll(); setupHandlersRef.current = true; } }; }, []); //This is used to keep the map selections and panel selections in sync and is very important. useEffect(() => { const highlightInLayers = props.layers.filter( (layerDef) => (layerDef as LolOpenLayersVectorLayerDef).highlightInLayer ); const allSelectedFeaturesByPanel = highlightInLayers.map((layerDef) => { return { layerName: layerDef.name, selectedFeatures: mapContext .featureSelect(layerDef.name) .map((f) => featureId(f)), }; }); mapImplement.copySelectionsToHighlightLayer( allSelectedFeaturesByPanel, mapContext ); }, [mapContext]); // @ts-ignore const mapElements = ( <>
{props.useLoadingIndicator && loading && (
)} {props.children} ); if (props.mock) return (
{mapElements}
); return mapElements; };