@mapcomponents/react-maplibre 0.1.57 → 0.1.58

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

@@ -11,25 +11,25 @@ import * as Constants from "./constants";
  * @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.
+ *	 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,
-    },
-  };
+	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

@@ -3,28 +3,28 @@
  * 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);
-  },
+	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

@@ -3,7 +3,7 @@
  * 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));
+	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

@@ -8,45 +8,45 @@ import * as Constants from "./constants";
 import StringSet from "./string_set";
 
 const META_TYPES = [
-  Constants.meta.FEATURE,
-  Constants.meta.MIDPOINT,
-  Constants.meta.VERTEX,
+	Constants.meta.FEATURE,
+	Constants.meta.MIDPOINT,
+	Constants.meta.VERTEX,
 ];
 
 // Requires either event or bbox
 export default {
-  click: featuresAtClick,
-  touch: featuresAtTouch,
+	click: featuresAtClick,
+	touch: featuresAtTouch,
 };
 
 function featuresAtClick(event, bbox, ctx) {
-  return featuresAt(event, bbox, ctx, ctx.options.clickBuffer);
+	return featuresAt(event, bbox, ctx, ctx.options.clickBuffer);
 }
 
 function featuresAtTouch(event, bbox, ctx) {
-  return featuresAt(event, bbox, ctx, ctx.options.touchBuffer);
+	return featuresAt(event, bbox, ctx, ctx.options.touchBuffer);
 }
 
 function featuresAt(event, bbox, ctx, buffer) {
-  if (ctx.map === null) return [];
+	if (ctx.map === null) return [];
 
-  const box = event ? mapEventToBoundingBox(event, buffer) : bbox;
+	const box = event ? mapEventToBoundingBox(event, buffer) : bbox;
 
-  const queryParams = {};
-  if (ctx.options.styles) queryParams.layers = ctx.options.styles.map((s) => s.id);
+	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 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);
-  });
+	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);
+	return sortFeatures(uniqueFeatures);
 }

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

@@ -6,23 +6,23 @@ 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 };
+	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 (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;
-  }
+	if (ctx.events.currentModeName().indexOf("draw") !== -1) {
+		classes.mouse = Constants.cursors.ADD;
+	}
 
-  ctx.ui.queueMapClasses(classes);
-  ctx.ui.updateMapClasses();
+	ctx.ui.queueMapClasses(classes);
+	ctx.ui.updateMapClasses();
 
-  return features[0];
+	return features[0];
 }

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

@@ -9,14 +9,14 @@ 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;
+	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);
+	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);
+	return moveDistance < fineTolerance ||
+		(moveDistance < grossTolerance && (end.time - start.time) < interval);
 }

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

@@ -3,8 +3,8 @@
  * and licensed under ISC
  */
 function isEventAtCoordinates(event, coordinates) {
-  if (!event.lngLat) return false;
-  return event.lngLat.lng === coordinates[0] && event.lngLat.lat === coordinates[1];
+	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

@@ -8,12 +8,12 @@ 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;
+	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);
+	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;
+	return moveDistance < tolerance && (end.time - start.time) < interval;
 }

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

@@ -9,10 +9,10 @@
  * @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]
-  ];
+	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

@@ -5,116 +5,116 @@
 
 const ModeHandler = function(mode, DrawContext) {
 
-  const handlers = {
-    drag: [],
-    click: [],
-    mousemove: [],
-    mousedown: [],
-    mouseup: [],
-    mouseout: [],
-    keydown: [],
-    keyup: [],
-    touchstart: [],
-    touchmove: [],
-    touchend: [],
-    tap: []
-  };
+	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 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();
+	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;
-      }
-    }
-  };
+				// 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);
+	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);
-    }
-  };
+	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

@@ -13,11 +13,11 @@ import Point from '@mapbox/point-geometry';
  * @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)
-  );
+	const rect = container.getBoundingClientRect();
+	return new Point(
+		mouseEvent.clientX - rect.left - (container.clientLeft || 0),
+		mouseEvent.clientY - rect.top - (container.clientTop || 0)
+	);
 }
 
 export default mouseEventPoint;

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

@@ -6,42 +6,42 @@ import constrainFeatureMovement from "./constrain_feature_movement";
 import * as Constants from "./constants";
 
 var move_features = function (features, delta) {
-  const constrainedDelta = constrainFeatureMovement(
-    features.map((feature) => feature.toGeoJSON()),
-    delta
-  );
+	const constrainedDelta = constrainFeatureMovement(
+		features.map((feature) => feature.toGeoJSON()),
+		delta
+	);
 
-  features.forEach((feature) => {
-    const currentCoordinates = feature.getCoordinates();
+	features.forEach((feature) => {
+		const currentCoordinates = feature.getCoordinates();
 
-    const moveCoordinate = (coord) => {
-      const point = {
-        lng: coord[0] + constrainedDelta.lng,
-        lat: coord[1] + constrainedDelta.lat,
-      };
-      return [point.lng, point.lat];
-    };
-    const moveRing = (ring) => ring.map((coord) => moveCoordinate(coord));
-    const moveMultiPolygon = (multi) => multi.map((ring) => moveRing(ring));
+		const moveCoordinate = (coord) => {
+			const point = {
+				lng: coord[0] + constrainedDelta.lng,
+				lat: coord[1] + constrainedDelta.lat,
+			};
+			return [point.lng, point.lat];
+		};
+		const moveRing = (ring) => ring.map((coord) => moveCoordinate(coord));
+		const moveMultiPolygon = (multi) => multi.map((ring) => moveRing(ring));
 
-    let nextCoordinates;
-    if (feature.type === Constants.geojsonTypes.POINT) {
-      nextCoordinates = moveCoordinate(currentCoordinates);
-    } else if (
-      feature.type === Constants.geojsonTypes.LINE_STRING ||
-      feature.type === Constants.geojsonTypes.MULTI_POINT
-    ) {
-      nextCoordinates = currentCoordinates.map(moveCoordinate);
-    } else if (
-      feature.type === Constants.geojsonTypes.POLYGON ||
-      feature.type === Constants.geojsonTypes.MULTI_LINE_STRING
-    ) {
-      nextCoordinates = currentCoordinates.map(moveRing);
-    } else if (feature.type === Constants.geojsonTypes.MULTI_POLYGON) {
-      nextCoordinates = currentCoordinates.map(moveMultiPolygon);
-    }
+		let nextCoordinates;
+		if (feature.type === Constants.geojsonTypes.POINT) {
+			nextCoordinates = moveCoordinate(currentCoordinates);
+		} else if (
+			feature.type === Constants.geojsonTypes.LINE_STRING ||
+			feature.type === Constants.geojsonTypes.MULTI_POINT
+		) {
+			nextCoordinates = currentCoordinates.map(moveCoordinate);
+		} else if (
+			feature.type === Constants.geojsonTypes.POLYGON ||
+			feature.type === Constants.geojsonTypes.MULTI_LINE_STRING
+		) {
+			nextCoordinates = currentCoordinates.map(moveRing);
+		} else if (feature.type === Constants.geojsonTypes.MULTI_POLYGON) {
+			nextCoordinates = currentCoordinates.map(moveMultiPolygon);
+		}
 
-    feature.incomingCoords(nextCoordinates);
-  });
+		feature.incomingCoords(nextCoordinates);
+	});
 };
 export default move_features;