@mapsight/lib-ol 4.0.3 → 4.1.0

package/src/js/feature/cluster.ts

@@ -1,86 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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;
-}

package/src/js/index.ts

@@ -1,62 +0,0 @@
-import type {Coordinate} from "ol/coordinate";
-import type {Type as GeometryType} from "ol/geom/Geometry";
-import type Image from "ol/style/Image";
-import type Style from "ol/style/Style";
-
-import type {Derivation} from "./geometry/deriveGeometriesFromBase";
-
-export type StyleLiteral = {
-	[styleKey: string]: number | boolean | string | Style | null;
-} & {
-	image?: Image | null;
-	anchor?: Array<number>;
-	size?: Array<number>;
-	imgSize?: Array<number>;
-	offset?: Array<number>;
-	color?: [number, number, number, number];
-	lineDash?: Array<number>;
-};
-
-export type UnitStyleValue = `${string}px` | `${string}%` | null;
-export type BoolishStyleValue =
-	| boolean
-	| 1
-	| 0
-	| "1"
-	| "0"
-	| "true"
-	| "false"
-	| null;
-
-export type NumberArrayStyleValue = Array<string | number> | string;
-export type NoneAble<T> = "unset" | "none" | T;
-
-export type StyleType = "circle" | "icon" | "stroke" | "fill" | "text";
-
-export type StyleValues = Record<string, {value: string | number}>;
-export type NoneAbleStyleValues = {value?: "none" | "unset"} | StyleValues;
-
-export type StyleDeclaration =
-	| NoneAbleStyleValues
-	| Partial<Record<StyleType, NoneAbleStyleValues>>;
-
-export type RootStyleDeclaration = {
-	display?: {value: "none"};
-	image?: {type: {value: "icon" | "circle"}};
-	geometry?: {value: GeometryType | Derivation};
-	zIndex?: {value: number};
-} & Partial<Record<StyleType, StyleDeclaration>>;
-
-export type GroupedRootStyleDeclaration = Record<string, RootStyleDeclaration>;
-
-export type Padding = [number, number, number, number];
-
-export type Resolution = number;
-
-export type Vertex = [Coordinate, number];
-
-export type VERTICES_FILTER = "all" | "first" | "start" | "last" | "end";
-
-export type INTERMEDIATE_FILTER = "all" | "intermediate";
-
-export type RING_FILTER = "all" | "inner" | "outer";

package/src/js/map/animateDuringTransition.ts

@@ -1,58 +0,0 @@
-/* From Modernizr */
-import type OlMap from "ol/Map";
-
-export type AnimateFunction = (deltaT: number) => void | boolean;
-
-function hasTransitionEndEvent() {
-	const el = document.createElement("fakeelement");
-	return el.style.transition !== undefined;
-}
-
-function animationLoop(render: AnimateFunction) {
-	let running = true;
-	let lastFrame = +new Date();
-
-	function loop(now: number) {
-		// stop the loop if render returned false
-		if (running) {
-			window.requestAnimationFrame(loop);
-			const deltaT = now - lastFrame;
-			if (deltaT < 160) {
-				running = render(deltaT) || running;
-			}
-			lastFrame = now;
-		}
-	}
-
-	loop(lastFrame);
-}
-
-export default function animateDuringTransition(
-	map: OlMap,
-	render: AnimateFunction,
-	maxTime = 10000,
-) {
-	const hasTransitionEvent = hasTransitionEndEvent();
-	if (!hasTransitionEvent || !window.requestAnimationFrame) {
-		return false;
-	}
-
-	const targetElement = map.getTargetElement();
-	if (!targetElement) {
-		return false;
-	}
-
-	let isTransitionRunning = true;
-	const maxTimeTimeout = setTimeout(endAnimation, maxTime);
-
-	function endAnimation() {
-		isTransitionRunning = false;
-		clearTimeout(maxTimeTimeout);
-		targetElement.removeEventListener("transitionend", endAnimation);
-	}
-
-	animationLoop((deltaT) => render(deltaT) !== false && isTransitionRunning);
-	targetElement.addEventListener("transitionend", endAnimation);
-
-	return true;
-}