@mapsight/lib-ol 4.0.0

package/src/js/feature/animator.ts

@@ -0,0 +1,91 @@
+// EXAMPLE:
+//
+//var animator = FeatureAnimator(ol, map, function (feature, vectorContext, time) {
+//	switch (feature.getGeometry().getType()) {
+//		case 'Polygon':
+//			var strokeStyle = new ol.style.Stroke({
+//				color: 'red',
+//				width: 4 * ol.easing.easeOut(time)
+//			});
+//			var fillStyle = new ol.style.Fill({
+//				color: 'yellow'
+//			});
+//
+//			vectorContext.setFillStrokeStyle(fillStyle, strokeStyle);
+//			vectorContext.drawPolygonGeometry(feature.getGeometry().clone(), null);
+//
+//			break;
+//		default:
+//	}
+//});
+//
+//if (!ol.has.TOUCH) {
+//	FeatureHitDetector(
+//		map,
+//		function (feature) {
+//			animator.start(feature);
+//			map.render();
+//			$map.addClass('feature-is-hit');
+//		},
+//		function (feature) {
+//			animator.stop();
+//			map.render();
+//			$map.removeClass('feature-is-hit');
+//		}
+//	);
+//}
+import type Feature from "ol/Feature";
+import type OlMap from "ol/Map";
+import {unByKey} from "ol/Observable";
+import type {EventsKey} from "ol/events";
+import {getVectorContext} from "ol/render";
+import type RenderEvent from "ol/render/Event";
+import type VectorContext from "ol/render/VectorContext";
+
+export type AnimationFunction = (
+	feature: Feature,
+	vectorContext: VectorContext,
+	progress: number,
+) => void;
+
+export default function animator(
+	map: OlMap,
+	animationFunction: AnimationFunction,
+	duration = 2000,
+) {
+	let listenerKey: EventsKey;
+	let isStopped = true;
+
+	function start(feature: Feature) {
+		const startTime = new Date().getTime();
+
+		function animate(event: RenderEvent) {
+			if (isStopped || !event.frameState) {
+				return;
+			}
+
+			const vectorContext = getVectorContext(event);
+
+			const elapsedTime = event.frameState.time - startTime;
+			animationFunction(feature, vectorContext, elapsedTime / duration);
+
+			if (elapsedTime > duration) {
+				stop();
+			} else {
+				event.frameState.animate = true; // tell OL3 to continue postcompose animation
+			}
+		}
+
+		isStopped = false;
+		listenerKey = map.on("postcompose", animate);
+	}
+
+	function stop() {
+		if (!isStopped) {
+			isStopped = true;
+			unByKey(listenerKey);
+		}
+	}
+
+	return {start: start, stop: stop};
+}

package/src/js/feature/cluster.ts

@@ -0,0 +1,86 @@
+import Feature from "ol/Feature";
+import type {Coordinate} from "ol/coordinate";
+import type {Extent} from "ol/extent";
+import {buffer, createEmpty, createOrUpdateFromCoordinate} from "ol/extent";
+import Point from "ol/geom/Point";
+
+import {isNonNullable} from "@mapsight/lib-js/nonNullable";
+
+import getCentroidForFeatures from "../features/getCentroidForFeatures";
+import type {Resolution} from "../index";
+import getCentroid from "./getCentroid";
+import getUid from "./getUid";
+
+export type CreateClusterFeatureFunction = (
+	centroid: Coordinate,
+	features: Array<Feature>,
+) => Array<Feature> | Feature;
+
+const defaultCreateClusterFeature: CreateClusterFeatureFunction = (
+	centroid: Coordinate,
+	features: Array<Feature>,
+) => {
+	const clusterFeature = new Feature(new Point(centroid));
+	clusterFeature.set("features", features);
+	return clusterFeature;
+};
+
+const defaultDistance = 20;
+
+export default function cluster(
+	features: Array<Feature>,
+	resolution: Resolution,
+	getFeaturesInExtent: (extent: Extent) => Array<Feature>,
+	distance = defaultDistance,
+	createClusterFeature: CreateClusterFeatureFunction = defaultCreateClusterFeature,
+	mapFeatureToCoordinate = getCentroid,
+): Array<Feature> {
+	if (resolution === undefined) {
+		return features;
+	}
+
+	const mapDistance = distance * resolution;
+	const extent = createEmpty();
+	const isClusteredMap: Record<string, boolean> = {};
+	const markClustered = (feature: Feature) => {
+		isClusteredMap[getUid(feature)] = true;
+	};
+	const isAlreadyClustered = (feature: Feature) =>
+		getUid(feature) in isClusteredMap;
+	const isNotAlreadyClustered = (feature: Feature) =>
+		!isAlreadyClustered(feature);
+
+	return features
+		.flatMap((feature) => {
+			if (isAlreadyClustered(feature)) {
+				return undefined;
+			}
+
+			const coordinate = mapFeatureToCoordinate(feature);
+			const canCluster =
+				coordinate &&
+				coordinate.length >= 2 &&
+				coordinate[0] &&
+				coordinate[1];
+
+			if (canCluster) {
+				// reuse extent to reduce object creation
+				createOrUpdateFromCoordinate(coordinate, extent);
+				buffer(extent, mapDistance, extent);
+
+				const neighbors = getFeaturesInExtent(extent).filter(
+					isNotAlreadyClustered,
+				);
+				if (neighbors.length >= 2) {
+					neighbors.forEach(markClustered);
+					return createClusterFeature(
+						getCentroidForFeatures(neighbors),
+						neighbors,
+					);
+				}
+			}
+
+			return feature;
+		})
+		.filter(isNonNullable);
+}

package/src/js/feature/detectFeatureHits.ts

@@ -0,0 +1,57 @@
+import type {FeatureLike} from "ol/Feature";
+import type OlMap from "ol/Map";
+import type MapBrowserEvent from "ol/MapBrowserEvent";
+import type Layer from "ol/layer/Layer";
+
+type Options = {
+	layers?: Array<Layer>;
+	onEnter?: (feature: FeatureLike) => void;
+	onLeave?: (feature: FeatureLike) => void;
+};
+
+export default function detectFeatureHits(map: OlMap, options: Options = {}) {
+	let previousFeature: FeatureLike | null = null;
+
+	const {layers, onEnter, onLeave} = options;
+	const layerFilter =
+		layers && layers.length
+			? (layer: Layer) => layers.indexOf(layer) > -1
+			: undefined;
+
+	function onFeatureHit(feature: FeatureLike, layer: Layer) {
+		if (!layer || feature === previousFeature) {
+			return;
+		}
+
+		if (previousFeature) {
+			onLeave?.(previousFeature);
+		}
+
+		previousFeature = feature;
+		onEnter?.(feature);
+	}
+
+	function onPointerMove(e: MapBrowserEvent) {
+		if (e.dragging) {
+			return;
+		}
+		const pixel = map.getEventPixel(e.originalEvent);
+
+		let foundFeature = false;
+		map.forEachFeatureAtPixel(
+			pixel,
+			(feature, layer) => {
+				foundFeature = true;
+				onFeatureHit(feature, layer);
+			},
+			{layerFilter: layerFilter},
+		);
+
+		if (!foundFeature && previousFeature) {
+			onLeave?.(previousFeature);
+			previousFeature = null;
+		}
+	}
+
+	map.on("pointermove", onPointerMove);
+}

package/src/js/feature/ensureId.ts

@@ -0,0 +1,9 @@
+import type Feature from "ol/Feature";
+
+import getUid from "./getUid";
+
+export default function ensureId(feature: Feature): void {
+	if (!feature.getId()) {
+		feature.setId(getUid(feature));
+	}
+}

package/src/js/feature/getCentroid.ts

@@ -0,0 +1,18 @@
+import type Feature from "ol/Feature";
+import Point from "ol/geom/Point";
+
+import getExtentCentroid from "../extent/getCentroid";
+
+export default function getCentroid(feature: Feature) {
+	const geometry = feature.getGeometry();
+
+	if (!geometry) {
+		return null;
+	}
+
+	if (geometry instanceof Point) {
+		return geometry.getCoordinates();
+	}
+
+	return getExtentCentroid(geometry.getExtent());
+}

package/src/js/feature/getExtent.ts

@@ -0,0 +1,10 @@
+import type Feature from "ol/Feature";
+
+export default function getExtent(feature: Feature) {
+	const geometry = feature.getGeometry();
+	if (!geometry) {
+		return null;
+	}
+
+	return geometry.getExtent();
+}

package/src/js/feature/getLayer.ts

@@ -0,0 +1,39 @@
+import type Feature from "ol/Feature";
+import type OlMap from "ol/Map";
+import type BaseLayer from "ol/layer/Base";
+import LayerGroup from "ol/layer/Group";
+import Layer from "ol/layer/Layer";
+import type Source from "ol/source/Source";
+import type VectorFeatureSource from "ol/source/Vector";
+
+export default function getLayer(map: OlMap, feature: Feature) {
+	let featureLayer: null | Layer = null;
+
+	function checkLayerForFeature(layer: BaseLayer): boolean {
+		if (layer instanceof LayerGroup) {
+			return layer.getLayers().getArray().some(checkLayerForFeature);
+		}
+
+		if (layer instanceof Layer) {
+			const source = layer.getSource() as
+				| VectorFeatureSource
+				| Source
+				| null;
+
+			if (
+				source &&
+				"getFeatures" in source &&
+				source.getFeatures().some((a) => a === feature)
+			) {
+				featureLayer = layer;
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	map.getLayers().getArray().some(checkLayerForFeature);
+
+	return featureLayer;
+}

package/src/js/feature/getUid.ts

@@ -0,0 +1,6 @@
+import type Feature from "ol/Feature";
+import {getUid as olGetUid} from "ol/util";
+
+export default function getUid(feature: Feature) {
+	return olGetUid(feature).toString();
+}

package/src/js/features/getCentroidForFeatures.ts

@@ -0,0 +1,10 @@
+import type Feature from "ol/Feature";
+
+import * as nonNull from "@mapsight/lib-js/nonNullable";
+
+import middleCoordinate from "../coordinates/middleCoordinate";
+import getCentroid from "../feature/getCentroid";
+
+export default function getCentroidForFeatures(features: Array<Feature>) {
+	return middleCoordinate(features.map(getCentroid).filter(nonNull.is));
+}

package/src/js/features/getExtentForFeatures.ts

@@ -0,0 +1,10 @@
+import type Feature from "ol/Feature";
+
+import * as nonNull from "@mapsight/lib-js/nonNullable";
+
+import combineExtents from "../extents/combineExtents";
+import getExtent from "../feature/getExtent";
+
+export default function getExtentForFeatures(features: Array<Feature>) {
+	return combineExtents(features.map(getExtent).filter(nonNull.is));
+}

package/src/js/geometry/deriveGeometriesFromBase.ts

@@ -0,0 +1,122 @@
+import type {Type as GeometryType} from "ol/geom/Geometry";
+import type Geometry from "ol/geom/Geometry";
+import LineString from "ol/geom/LineString";
+import Point from "ol/geom/Point";
+import Polygon from "ol/geom/Polygon";
+
+import type {INTERMEDIATE_FILTER, RING_FILTER, VERTICES_FILTER} from "../index";
+import getLSSegmentVertices from "./getLineStringSegmentVerticesWithRotation";
+import getPolygonSegmentVertices from "./getPolygonRingSegmentVerticesWithRotation";
+
+export type GeometryWithMeta = [Geometry, {rotation?: number}];
+
+const deriveLSVertexGeometries = (
+	b: LineString,
+	v?: VERTICES_FILTER,
+	i?: INTERMEDIATE_FILTER,
+) =>
+	getLSSegmentVertices(b, v, i).map(
+		([c, r]): GeometryWithMeta => [new Point(c), {rotation: r}],
+	);
+const derivePolygonVertexGeometries = (
+	b: Polygon,
+	v?: VERTICES_FILTER,
+	i?: INTERMEDIATE_FILTER,
+	j?: RING_FILTER,
+) =>
+	getPolygonSegmentVertices(b, v, i, j).map(
+		([c, r]): GeometryWithMeta => [new Point(c), {rotation: r}],
+	);
+
+export type Derivation =
+	| "vertex"
+	| "vertices"
+	| "firstVertex"
+	| "firstVertices"
+	| "lastVertex"
+	| "lastVertices"
+	| "segmentStart"
+	| "segmentStarts"
+	| "intermediateSegmentStart"
+	| "intermediateSegmentStarts"
+	| "segmentEnd"
+	| "segmentEnds"
+	| "intermediateSegmentEnd"
+	| "intermediateSegmentEnds";
+
+export default function deriveGeometriesFromBase(
+	base: Geometry,
+	derivation: Derivation | GeometryType | null = null,
+): Array<GeometryWithMeta> {
+	// early return for common case
+	if (derivation === null) {
+		return [[base, {}]];
+	}
+
+	if (base instanceof LineString) {
+		switch (derivation) {
+			case "vertex":
+			case "vertices":
+				return deriveLSVertexGeometries(base);
+			case "firstVertex":
+			case "firstVertices":
+				return deriveLSVertexGeometries(base, "first");
+			case "lastVertex":
+			case "lastVertices":
+				return deriveLSVertexGeometries(base, "last");
+			case "segmentStart":
+			case "segmentStarts":
+				return deriveLSVertexGeometries(base, "start");
+			case "intermediateSegmentStart":
+			case "intermediateSegmentStarts":
+				return deriveLSVertexGeometries(base, "start", "intermediate");
+			case "segmentEnd":
+			case "segmentEnds":
+				return deriveLSVertexGeometries(base, "end");
+			case "intermediateSegmentEnd":
+			case "intermediateSegmentEnds":
+				return deriveLSVertexGeometries(base, "end", "intermediate");
+			default:
+		}
+	} else if (base instanceof Polygon) {
+		// TODO: discriminate outer and inner ring
+		switch (derivation) {
+			case "vertex":
+			case "vertices":
+				return derivePolygonVertexGeometries(base);
+			case "firstVertex":
+			case "firstVertices":
+				return derivePolygonVertexGeometries(base, "first");
+			case "lastVertex":
+			case "lastVertices":
+				return derivePolygonVertexGeometries(base, "last");
+			case "segmentStart":
+			case "segmentStarts":
+				return derivePolygonVertexGeometries(base, "start");
+			case "intermediateSegmentStart":
+			case "intermediateSegmentStarts":
+				return derivePolygonVertexGeometries(
+					base,
+					"start",
+					"intermediate",
+				);
+			case "segmentEnd":
+			case "segmentEnds":
+				return derivePolygonVertexGeometries(base, "end");
+			case "intermediateSegmentEnd":
+			case "intermediateSegmentEnds":
+				return derivePolygonVertexGeometries(
+					base,
+					"end",
+					"intermediate",
+				);
+			default:
+		}
+	}
+
+	console.error(
+		"Could not derive " + derivation + " from base geometry " + base,
+	);
+
+	return [[base, {}]];
+}

package/src/js/geometry/getDominantGeometryType.ts

@@ -0,0 +1,40 @@
+import type {Type as GeometryType} from "ol/geom/Geometry";
+import type Geometry from "ol/geom/Geometry";
+import GeometryCollection from "ol/geom/GeometryCollection";
+
+import {isNonNullable} from "@mapsight/lib-js/nonNullable";
+
+const GEOMETRY_TYPE_DOMINANCE: Record<GeometryType, number> = {
+	GeometryCollection: 0,
+	Circle: 1,
+	Point: 1,
+	LineString: 2,
+	LinearRing: 2,
+	MultiPoint: 2,
+	Polygon: 3,
+	MultiLineString: 3,
+	MultiPolygon: 4,
+};
+
+function getGeometryTypeDominance(geometryType: GeometryType) {
+	return GEOMETRY_TYPE_DOMINANCE[geometryType] ?? 0;
+}
+
+export default function getDominantGeometryType(
+	geometry: Geometry,
+): undefined | GeometryType {
+	if (geometry instanceof GeometryCollection) {
+		const types = geometry
+			.getGeometries()
+			.map(getDominantGeometryType)
+			.filter(isNonNullable);
+		types.sort(
+			(a, b) =>
+				// TODO: use compare helper
+				getGeometryTypeDominance(b) - getGeometryTypeDominance(a),
+		);
+		return types[0];
+	}
+
+	return geometry.getType();
+}

package/src/js/geometry/getLineStringSegmentVerticesWithRotation.ts

@@ -0,0 +1,48 @@
+import type LineString from "ol/geom/LineString";
+
+import {ensureNonNullable} from "@mapsight/lib-js/nonNullable";
+
+import equals from "../coordinates/equals";
+import type {INTERMEDIATE_FILTER, VERTICES_FILTER, Vertex} from "../index";
+
+export default function getLineStringSegmentVerticesWithRotation(
+	lineStringGeometry: LineString,
+	verticesFilter: VERTICES_FILTER = "all",
+	intermediateFilter: INTERMEDIATE_FILTER = "all",
+) {
+	const verticesWithRotation: Array<Vertex> = [];
+	const first = lineStringGeometry.getFirstCoordinate();
+	const last = lineStringGeometry.getLastCoordinate();
+
+	lineStringGeometry.forEachSegment(function processSegment(start, end) {
+		const dx = ensureNonNullable(end[0]) - ensureNonNullable(start[0]);
+		const dy = ensureNonNullable(end[1]) - ensureNonNullable(start[1]);
+		const rotation = -Math.round(Math.atan2(dy, dx) * 100) / 100;
+
+		if (
+			verticesFilter === "first"
+				? equals(start, first)
+				: (verticesFilter === "start" || verticesFilter === "all") &&
+					!(
+						intermediateFilter === "intermediate" &&
+						equals(start, first)
+					)
+		) {
+			verticesWithRotation.push([[...start], rotation]);
+		}
+
+		if (
+			verticesFilter === "last"
+				? equals(end, last)
+				: (verticesFilter === "end" || verticesFilter === "all") &&
+					!(
+						intermediateFilter === "intermediate" &&
+						equals(end, last)
+					)
+		) {
+			verticesWithRotation.push([[...end], rotation]);
+		}
+	});
+
+	return verticesWithRotation;
+}

package/src/js/geometry/getPolygonRingSegmentVerticesWithRotation.ts

@@ -0,0 +1,90 @@
+import type LinearRing from "ol/geom/LinearRing";
+import type Polygon from "ol/geom/Polygon";
+
+import {ensureNonNullable} from "@mapsight/lib-js/nonNullable";
+
+import type {
+	INTERMEDIATE_FILTER,
+	RING_FILTER,
+	VERTICES_FILTER,
+	Vertex,
+} from "../index";
+
+function getLinearRingSegmentVerticesWithRotation(
+	linearRing: LinearRing,
+	verticesFilter: VERTICES_FILTER,
+	intermediateFilter: INTERMEDIATE_FILTER,
+) {
+	const verticesWithRotation: Array<Vertex> = [];
+	const ringCoords = linearRing.getCoordinates();
+
+	ringCoords.forEach((start, i) => {
+		const end = ringCoords[i + 1];
+		if (!end) {
+			return;
+		}
+
+		const isFirst = i === 0;
+		const isLast = ringCoords[i + 2] === undefined;
+
+		const dx = ensureNonNullable(end[0]) - ensureNonNullable(start[0]);
+		const dy = ensureNonNullable(end[1]) - ensureNonNullable(start[1]);
+		const rotation = -Math.round(Math.atan2(dy, dx) * 100) / 100;
+
+		if (
+			verticesFilter === "first"
+				? isFirst
+				: (verticesFilter === "start" || verticesFilter === "all") &&
+					!(intermediateFilter === "intermediate" && isFirst)
+		) {
+			verticesWithRotation.push([[...start], rotation]);
+		}
+
+		if (
+			verticesFilter === "last"
+				? isLast
+				: (verticesFilter === "end" || verticesFilter === "all") &&
+					!(intermediateFilter === "intermediate" && isLast)
+		) {
+			verticesWithRotation.push([[...end], rotation]);
+		}
+	});
+
+	return verticesWithRotation;
+}
+
+export default function getPolygonRingSegmentVerticesWithRotation(
+	polygonGeometry: Polygon,
+	verticesFilter: VERTICES_FILTER = "all",
+	intermediateFilter: INTERMEDIATE_FILTER = "all",
+	ringFilter: RING_FILTER = "all",
+) {
+	let verticesWithRotation: Array<Vertex> = [];
+
+	if (ringFilter === "all" || ringFilter === "outer") {
+		const outerRing = polygonGeometry.getLinearRing(0);
+		if (outerRing) {
+			verticesWithRotation = getLinearRingSegmentVerticesWithRotation(
+				outerRing,
+				verticesFilter,
+				intermediateFilter,
+			);
+		}
+	}
+
+	if (ringFilter === "all" || ringFilter === "inner") {
+		const innerRing = polygonGeometry.getLinearRing(1);
+		if (innerRing) {
+			verticesWithRotation = [
+				...verticesWithRotation,
+				...getLinearRingSegmentVerticesWithRotation(
+					innerRing,
+					verticesFilter,
+					intermediateFilter,
+				),
+			];
+		}
+	}
+
+	return verticesWithRotation;
+}