@mapcomponents/react-maplibre 0.1.69 → 0.1.71

package/src/components/MlFeatureEditor/lib/constants.js

@@ -1,104 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-export const classes = {
-	CONTROL_BASE: 'mapboxgl-ctrl',
-	CONTROL_PREFIX: 'mapboxgl-ctrl-',
-	CONTROL_BUTTON: 'mapbox-gl-draw_ctrl-draw-btn',
-	CONTROL_BUTTON_LINE: 'mapbox-gl-draw_line',
-	CONTROL_BUTTON_POLYGON: 'mapbox-gl-draw_polygon',
-	CONTROL_BUTTON_POINT: 'mapbox-gl-draw_point',
-	CONTROL_BUTTON_TRASH: 'mapbox-gl-draw_trash',
-	CONTROL_BUTTON_COMBINE_FEATURES: 'mapbox-gl-draw_combine',
-	CONTROL_BUTTON_UNCOMBINE_FEATURES: 'mapbox-gl-draw_uncombine',
-	CONTROL_GROUP: 'mapboxgl-ctrl-group',
-	ATTRIBUTION: 'mapboxgl-ctrl-attrib',
-	ACTIVE_BUTTON: 'active',
-	BOX_SELECT: 'mapbox-gl-draw_boxselect'
-};
-
-export const sources = {
-	HOT: 'mapbox-gl-draw-hot',
-	COLD: 'mapbox-gl-draw-cold'
-};
-
-export const cursors = {
-	ADD: 'add',
-	MOVE: 'move',
-	DRAG: 'drag',
-	POINTER: 'pointer',
-	NONE: 'none'
-};
-
-export const types = {
-	POLYGON: 'polygon',
-	LINE: 'line_string',
-	POINT: 'point'
-};
-
-export const geojsonTypes = {
-	FEATURE: 'Feature',
-	POLYGON: 'Polygon',
-	LINE_STRING: 'LineString',
-	POINT: 'Point',
-	FEATURE_COLLECTION: 'FeatureCollection',
-	MULTI_PREFIX: 'Multi',
-	MULTI_POINT: 'MultiPoint',
-	MULTI_LINE_STRING: 'MultiLineString',
-	MULTI_POLYGON: 'MultiPolygon'
-};
-
-export const modes = {
-	DRAW_LINE_STRING: 'draw_line_string',
-	DRAW_POLYGON: 'draw_polygon',
-	DRAW_POINT: 'draw_point',
-	SIMPLE_SELECT: 'simple_select',
-	DIRECT_SELECT: 'direct_select',
-	STATIC: 'static'
-};
-
-export const events = {
-	CREATE: 'draw.create',
-	DELETE: 'draw.delete',
-	UPDATE: 'draw.update',
-	SELECTION_CHANGE: 'draw.selectionchange',
-	MODE_CHANGE: 'draw.modechange',
-	ACTIONABLE: 'draw.actionable',
-	RENDER: 'draw.render',
-	COMBINE_FEATURES: 'draw.combine',
-	UNCOMBINE_FEATURES: 'draw.uncombine'
-};
-
-export const updateActions = {
-	MOVE: 'move',
-	CHANGE_COORDINATES: 'change_coordinates'
-};
-
-export const meta = {
-	FEATURE: 'feature',
-	MIDPOINT: 'midpoint',
-	VERTEX: 'vertex'
-};
-
-export const activeStates = {
-	ACTIVE: 'true',
-	INACTIVE: 'false'
-};
-
-export const interactions = [
-	'scrollZoom',
-	'boxZoom',
-	'dragRotate',
-	'dragPan',
-	'keyboard',
-	'doubleClickZoom',
-	'touchZoomRotate'
-];
-
-export const LAT_MIN = -90;
-export const LAT_RENDERED_MIN = -85;
-export const LAT_MAX = 90;
-export const LAT_RENDERED_MAX = 85;
-export const LNG_MIN = -270;
-export const LNG_MAX = 270;

package/src/components/MlFeatureEditor/lib/constrain_feature_movement.js

@@ -1,72 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import extent from "@mapbox/geojson-extent";
-import * as Constants from "./constants";
-
-const {
-	LAT_MIN,
-	LAT_MAX,
-	LAT_RENDERED_MIN,
-	LAT_RENDERED_MAX,
-	LNG_MIN,
-	LNG_MAX,
-} = Constants;
-
-// Ensure that we do not drag north-south far enough for
-// - any part of any feature to exceed the poles
-// - any feature to be completely lost in the space between the projection's
-//	 edge and the poles, such that it couldn't be re-selected and moved back
-const constrain_feature_movement = function (geojsonFeatures, delta) {
-	// "inner edge" = a feature's latitude closest to the equator
-	let northInnerEdge = LAT_MIN;
-	let southInnerEdge = LAT_MAX;
-	// "outer edge" = a feature's latitude furthest from the equator
-	let northOuterEdge = LAT_MIN;
-	let southOuterEdge = LAT_MAX;
-
-	let westEdge = LNG_MAX;
-	let eastEdge = LNG_MIN;
-
-	geojsonFeatures.forEach((feature) => {
-		const bounds = extent(feature);
-		const featureSouthEdge = bounds[1];
-		const featureNorthEdge = bounds[3];
-		const featureWestEdge = bounds[0];
-		const featureEastEdge = bounds[2];
-		if (featureSouthEdge > northInnerEdge) northInnerEdge = featureSouthEdge;
-		if (featureNorthEdge < southInnerEdge) southInnerEdge = featureNorthEdge;
-		if (featureNorthEdge > northOuterEdge) northOuterEdge = featureNorthEdge;
-		if (featureSouthEdge < southOuterEdge) southOuterEdge = featureSouthEdge;
-		if (featureWestEdge < westEdge) westEdge = featureWestEdge;
-		if (featureEastEdge > eastEdge) eastEdge = featureEastEdge;
-	});
-
-	// These changes are not mutually exclusive: we might hit the inner
-	// edge but also have hit the outer edge and therefore need
-	// another readjustment
-	const constrainedDelta = delta;
-	if (northInnerEdge + constrainedDelta.lat > LAT_RENDERED_MAX) {
-		constrainedDelta.lat = LAT_RENDERED_MAX - northInnerEdge;
-	}
-	if (northOuterEdge + constrainedDelta.lat > LAT_MAX) {
-		constrainedDelta.lat = LAT_MAX - northOuterEdge;
-	}
-	if (southInnerEdge + constrainedDelta.lat < LAT_RENDERED_MIN) {
-		constrainedDelta.lat = LAT_RENDERED_MIN - southInnerEdge;
-	}
-	if (southOuterEdge + constrainedDelta.lat < LAT_MIN) {
-		constrainedDelta.lat = LAT_MIN - southOuterEdge;
-	}
-	if (westEdge + constrainedDelta.lng <= LNG_MIN) {
-		constrainedDelta.lng += Math.ceil(Math.abs(constrainedDelta.lng) / 360) * 360;
-	}
-	if (eastEdge + constrainedDelta.lng >= LNG_MAX) {
-		constrainedDelta.lng -= Math.ceil(Math.abs(constrainedDelta.lng) / 360) * 360;
-	}
-
-	return constrainedDelta;
-};
-
-export default constrain_feature_movement;

package/src/components/MlFeatureEditor/lib/create_midpoint.js

@@ -1,42 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import * as Constants from "./constants";
-
-const create_midpoint = function (parent, startVertex, endVertex) {
-	const startCoord = startVertex.geometry.coordinates;
-	const endCoord = endVertex.geometry.coordinates;
-
-	// If a coordinate exceeds the projection, we can't calculate a midpoint,
-	// so run away
-	if (
-		startCoord[1] > Constants.LAT_RENDERED_MAX ||
-		startCoord[1] < Constants.LAT_RENDERED_MIN ||
-		endCoord[1] > Constants.LAT_RENDERED_MAX ||
-		endCoord[1] < Constants.LAT_RENDERED_MIN
-	) {
-		return null;
-	}
-
-	const mid = {
-		lng: (startCoord[0] + endCoord[0]) / 2,
-		lat: (startCoord[1] + endCoord[1]) / 2,
-	};
-
-	return {
-		type: Constants.geojsonTypes.FEATURE,
-		properties: {
-			meta: Constants.meta.MIDPOINT,
-			parent,
-			lng: mid.lng,
-			lat: mid.lat,
-			coord_path: endVertex.properties.coord_path,
-		},
-		geometry: {
-			type: Constants.geojsonTypes.POINT,
-			coordinates: [mid.lng, mid.lat],
-		},
-	};
-};
-export default create_midpoint;

package/src/components/MlFeatureEditor/lib/create_supplementary_points.js

@@ -1,102 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import createVertex from "./create_vertex";
-import createMidpoint from "./create_midpoint";
-import * as Constants from "./constants";
-
-function createSupplementaryPoints(geojson, options = {}, basePath = null) {
-	const { type, coordinates } = geojson.geometry;
-	const featureId = geojson.properties && geojson.properties.id;
-
-	let supplementaryPoints = [];
-
-	if (type === Constants.geojsonTypes.POINT) {
-		// For points, just create a vertex
-		supplementaryPoints.push(
-			createVertex(featureId, coordinates, basePath, isSelectedPath(basePath))
-		);
-	} else if (type === Constants.geojsonTypes.POLYGON) {
-		// Cycle through a Polygon's rings and
-		// process each line
-		coordinates.forEach((line, lineIndex) => {
-			processLine(
-				line,
-				basePath !== null ? `${basePath}.${lineIndex}` : String(lineIndex)
-			);
-		});
-	} else if (type === Constants.geojsonTypes.LINE_STRING) {
-		processLine(coordinates, basePath);
-	} else if (type.indexOf(Constants.geojsonTypes.MULTI_PREFIX) === 0) {
-		processMultiGeometry();
-	}
-
-	function processLine(line, lineBasePath) {
-		let firstPointString = "";
-		let lastVertex = null;
-		line.forEach((point, pointIndex) => {
-			const pointPath =
-				lineBasePath !== undefined && lineBasePath !== null
-					? `${lineBasePath}.${pointIndex}`
-					: String(pointIndex);
-			const vertex = createVertex(
-				featureId,
-				point,
-				pointPath,
-				isSelectedPath(pointPath)
-			);
-
-			// If we're creating midpoints, check if there was a
-			// vertex before this one. If so, add a midpoint
-			// between that vertex and this one.
-			if (options.midpoints && lastVertex) {
-				const midpoint = createMidpoint(featureId, lastVertex, vertex);
-				if (midpoint) {
-					supplementaryPoints.push(midpoint);
-				}
-			}
-			lastVertex = vertex;
-
-			// A Polygon line's last point is the same as the first point. If we're on the last
-			// point, we want to draw a midpoint before it but not another vertex on it
-			// (since we already a vertex there, from the first point).
-			const stringifiedPoint = JSON.stringify(point);
-			if (firstPointString !== stringifiedPoint) {
-				supplementaryPoints.push(vertex);
-			}
-			if (pointIndex === 0) {
-				firstPointString = stringifiedPoint;
-			}
-		});
-	}
-
-	function isSelectedPath(path) {
-		if (!options.selectedPaths) return false;
-		return options.selectedPaths.indexOf(path) !== -1;
-	}
-
-	// Split a multi-geometry into constituent
-	// geometries, and accumulate the supplementary points
-	// for each of those constituents
-	function processMultiGeometry() {
-		const subType = type.replace(Constants.geojsonTypes.MULTI_PREFIX, "");
-		coordinates.forEach((subCoordinates, index) => {
-			const subFeature = {
-				type: Constants.geojsonTypes.FEATURE,
-				properties: geojson.properties,
-				geometry: {
-					type: subType,
-					coordinates: subCoordinates,
-				},
-			};
-			supplementaryPoints = supplementaryPoints.concat(
-				createSupplementaryPoints(subFeature, options, index)
-			);
-		});
-	}
-
-	return supplementaryPoints;
-}
-
-export default createSupplementaryPoints;

package/src/components/MlFeatureEditor/lib/create_vertex.js

@@ -1,35 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import * as Constants from "./constants";
-
-/**
- * Returns GeoJSON for a Point representing the
- * vertex of another feature.
- *
- * @param {string} parentId
- * @param {Array<number>} coordinates
- * @param {string} path - Dot-separated numbers indicating exactly
- *	 where the point exists within its parent feature's coordinates.
- * @param {boolean} selected
- * @return {GeoJSON} Point
- */
-const create_vertex = function (parentId, coordinates, path, selected) {
-	return {
-		type: Constants.geojsonTypes.FEATURE,
-		properties: {
-			meta: Constants.meta.VERTEX,
-			parent: parentId,
-			coord_path: path,
-			active: selected
-				? Constants.activeStates.ACTIVE
-				: Constants.activeStates.INACTIVE,
-		},
-		geometry: {
-			type: Constants.geojsonTypes.POINT,
-			coordinates,
-		},
-	};
-};
-export default create_vertex;

package/src/components/MlFeatureEditor/lib/double_click_zoom.js

@@ -1,30 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-const doubleClickZoom = {
-	enable(ctx) {
-		setTimeout(() => {
-			// First check we've got a map and some context.
-			if (
-				!ctx.map ||
-				!ctx.map.doubleClickZoom ||
-				!ctx._ctx ||
-				!ctx._ctx.store ||
-				!ctx._ctx.store.getInitialConfigValue
-			)
-				return;
-			// Now check initial state wasn't false (we leave it disabled if so)
-			if (!ctx._ctx.store.getInitialConfigValue("doubleClickZoom")) return;
-			ctx.map.doubleClickZoom.enable();
-		}, 0);
-	},
-	disable(ctx) {
-		setTimeout(() => {
-			if (!ctx.map || !ctx.map.doubleClickZoom) return;
-			// Always disable here, as it's necessary in some cases.
-			ctx.map.doubleClickZoom.disable();
-		}, 0);
-	},
-};
-export default doubleClickZoom;

package/src/components/MlFeatureEditor/lib/euclidean_distance.js

@@ -1,9 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-export default function(a, b) {
-	const x = a.x - b.x;
-	const y = a.y - b.y;
-	return Math.sqrt((x * x) + (y * y));
-}

package/src/components/MlFeatureEditor/lib/features_at.js

@@ -1,52 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import sortFeatures from "./sort_features";
-import mapEventToBoundingBox from "./map_event_to_bounding_box";
-import * as Constants from "./constants";
-import StringSet from "./string_set";
-
-const META_TYPES = [
-	Constants.meta.FEATURE,
-	Constants.meta.MIDPOINT,
-	Constants.meta.VERTEX,
-];
-
-// Requires either event or bbox
-export default {
-	click: featuresAtClick,
-	touch: featuresAtTouch,
-};
-
-function featuresAtClick(event, bbox, ctx) {
-	return featuresAt(event, bbox, ctx, ctx.options.clickBuffer);
-}
-
-function featuresAtTouch(event, bbox, ctx) {
-	return featuresAt(event, bbox, ctx, ctx.options.touchBuffer);
-}
-
-function featuresAt(event, bbox, ctx, buffer) {
-	if (ctx.map === null) return [];
-
-	const box = event ? mapEventToBoundingBox(event, buffer) : bbox;
-
-	const queryParams = {};
-	if (ctx.options.styles) queryParams.layers = ctx.options.styles.map((s) => s.id);
-
-	const features = ctx.map
-		.queryRenderedFeatures(box, queryParams)
-		.filter((feature) => META_TYPES.indexOf(feature.properties.meta) !== -1);
-
-	const featureIds = new StringSet();
-	const uniqueFeatures = [];
-	features.forEach((feature) => {
-		const featureId = feature.properties.id;
-		if (featureIds.has(featureId)) return;
-		featureIds.add(featureId);
-		uniqueFeatures.push(feature);
-	});
-
-	return sortFeatures(uniqueFeatures);
-}

package/src/components/MlFeatureEditor/lib/get_features_and_set_cursor.js

@@ -1,28 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import featuresAt from "./features_at";
-import * as Constants from "./constants";
-
-export default function getFeatureAtAndSetCursors(event, ctx) {
-	const features = featuresAt.click(event, null, ctx);
-	const classes = { mouse: Constants.cursors.NONE };
-
-	if (features[0]) {
-		classes.mouse =
-			features[0].properties.active === Constants.activeStates.ACTIVE
-				? Constants.cursors.MOVE
-				: Constants.cursors.POINTER;
-		classes.feature = features[0].properties.meta;
-	}
-
-	if (ctx.events.currentModeName().indexOf("draw") !== -1) {
-		classes.mouse = Constants.cursors.ADD;
-	}
-
-	ctx.ui.queueMapClasses(classes);
-	ctx.ui.updateMapClasses();
-
-	return features[0];
-}

package/src/components/MlFeatureEditor/lib/is_click.js

@@ -1,22 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import euclideanDistance from './euclidean_distance';
-
-const FINE_TOLERANCE = 4;
-const GROSS_TOLERANCE = 12;
-const INTERVAL = 500;
-
-export default function isClick(start, end, options = {}) {
-	const fineTolerance = (options.fineTolerance != null) ? options.fineTolerance : FINE_TOLERANCE;
-	const grossTolerance = (options.grossTolerance != null) ? options.grossTolerance : GROSS_TOLERANCE;
-	const interval = (options.interval != null) ? options.interval : INTERVAL;
-
-	start.point = start.point || end.point;
-	start.time = start.time || end.time;
-	const moveDistance = euclideanDistance(start.point, end.point);
-
-	return moveDistance < fineTolerance ||
-		(moveDistance < grossTolerance && (end.time - start.time) < interval);
-}

package/src/components/MlFeatureEditor/lib/is_event_at_coordinates.js

@@ -1,10 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-function isEventAtCoordinates(event, coordinates) {
-	if (!event.lngLat) return false;
-	return event.lngLat.lng === coordinates[0] && event.lngLat.lat === coordinates[1];
-}
-
-export default isEventAtCoordinates;

package/src/components/MlFeatureEditor/lib/is_tap.js

@@ -1,19 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import euclideanDistance from './euclidean_distance';
-
-export const TAP_TOLERANCE = 25;
-export const TAP_INTERVAL = 250;
-
-export default function isTap(start, end, options = {}) {
-	const tolerance = (options.tolerance != null) ? options.tolerance : TAP_TOLERANCE;
-	const interval = (options.interval != null) ? options.interval : TAP_INTERVAL;
-
-	start.point = start.point || end.point;
-	start.time = start.time || end.time;
-	const moveDistance = euclideanDistance(start.point, end.point);
-
-	return moveDistance < tolerance && (end.time - start.time) < interval;
-}

package/src/components/MlFeatureEditor/lib/map_event_to_bounding_box.js

@@ -1,18 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-/**
- * Returns a bounding box representing the event's location.
- *
- * @param {Event} mapEvent - Mapbox GL JS map event, with a point properties.
- * @return {Array<Array<number>>} Bounding box.
- */
-function mapEventToBoundingBox(mapEvent, buffer = 0) {
-	return [
-		[mapEvent.point.x - buffer, mapEvent.point.y - buffer],
-		[mapEvent.point.x + buffer, mapEvent.point.y + buffer]
-	];
-}
-
-export default mapEventToBoundingBox;

package/src/components/MlFeatureEditor/lib/mode_handler.js

@@ -1,120 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-
-const ModeHandler = function(mode, DrawContext) {
-
-	const handlers = {
-		drag: [],
-		click: [],
-		mousemove: [],
-		mousedown: [],
-		mouseup: [],
-		mouseout: [],
-		keydown: [],
-		keyup: [],
-		touchstart: [],
-		touchmove: [],
-		touchend: [],
-		tap: []
-	};
-
-	const ctx = {
-		on(event, selector, fn) {
-			if (handlers[event] === undefined) {
-				throw new Error(`Invalid event type: ${event}`);
-			}
-			handlers[event].push({
-				selector,
-				fn
-			});
-		},
-		render(id) {
-			DrawContext.store.featureChanged(id);
-		}
-	};
-
-	const delegate = function (eventName, event) {
-		const handles = handlers[eventName];
-		let iHandle = handles.length;
-		while (iHandle--) {
-			const handle = handles[iHandle];
-			if (handle.selector(event)) {
-				const skipRender = handle.fn.call(ctx, event);
-				if (!skipRender) {
-					DrawContext.store.render();
-				}
-				DrawContext.ui.updateMapClasses();
-
-				// ensure an event is only handled once
-				// we do this to let modes have multiple overlapping selectors
-				// and relay on order of oppertations to filter
-				break;
-			}
-		}
-	};
-
-	mode.start.call(ctx);
-
-	return {
-		render: mode.render,
-		stop() {
-			if (mode.stop) mode.stop();
-		},
-		trash() {
-			if (mode.trash) {
-				mode.trash();
-				DrawContext.store.render();
-			}
-		},
-		combineFeatures() {
-			if (mode.combineFeatures) {
-				mode.combineFeatures();
-			}
-		},
-		uncombineFeatures() {
-			if (mode.uncombineFeatures) {
-				mode.uncombineFeatures();
-			}
-		},
-		drag(event) {
-			delegate('drag', event);
-		},
-		click(event) {
-			delegate('click', event);
-		},
-		mousemove(event) {
-			delegate('mousemove', event);
-		},
-		mousedown(event) {
-			delegate('mousedown', event);
-		},
-		mouseup(event) {
-			delegate('mouseup', event);
-		},
-		mouseout(event) {
-			delegate('mouseout', event);
-		},
-		keydown(event) {
-			delegate('keydown', event);
-		},
-		keyup(event) {
-			delegate('keyup', event);
-		},
-		touchstart(event) {
-			delegate('touchstart', event);
-		},
-		touchmove(event) {
-			delegate('touchmove', event);
-		},
-		touchend(event) {
-			delegate('touchend', event);
-		},
-		tap(event) {
-			delegate('tap', event);
-		}
-	};
-};
-
-export default ModeHandler;

package/src/components/MlFeatureEditor/lib/mouse_event_point.js

@@ -1,23 +0,0 @@
-/**
- * Code from https://github.com/mapbox/mapbox-gl-draw
- * and licensed under ISC
- */
-import Point from '@mapbox/point-geometry';
-
-/**
- * Returns a Point representing a mouse event's position
- * relative to a containing element.
- *
- * @param {MouseEvent} mouseEvent
- * @param {Node} container
- * @returns {Point}
- */
-function mouseEventPoint(mouseEvent, container) {
-	const rect = container.getBoundingClientRect();
-	return new Point(
-		mouseEvent.clientX - rect.left - (container.clientLeft || 0),
-		mouseEvent.clientY - rect.top - (container.clientTop || 0)
-	);
-}
-
-export default mouseEventPoint;