@mapcomponents/react-maplibre 0.1.56 → 0.1.58

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

@@ -5,68 +5,68 @@
 import * as Constants from "./constants";
 
 export function isOfMetaType(type) {
-  return function (e) {
-    const featureTarget = e.featureTarget;
-    if (!featureTarget) return false;
-    if (!featureTarget.properties) return false;
-    return featureTarget.properties.meta === type;
-  };
+	return function (e) {
+		const featureTarget = e.featureTarget;
+		if (!featureTarget) return false;
+		if (!featureTarget.properties) return false;
+		return featureTarget.properties.meta === type;
+	};
 }
 
 export function isShiftMousedown(e) {
-  if (!e.originalEvent) return false;
-  if (!e.originalEvent.shiftKey) return false;
-  return e.originalEvent.button === 0;
+	if (!e.originalEvent) return false;
+	if (!e.originalEvent.shiftKey) return false;
+	return e.originalEvent.button === 0;
 }
 
 export function isActiveFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return (
-    e.featureTarget.properties.active === Constants.activeStates.ACTIVE &&
-    e.featureTarget.properties.meta === Constants.meta.FEATURE
-  );
+	if (!e.featureTarget) return false;
+	if (!e.featureTarget.properties) return false;
+	return (
+		e.featureTarget.properties.active === Constants.activeStates.ACTIVE &&
+		e.featureTarget.properties.meta === Constants.meta.FEATURE
+	);
 }
 
 export function isInactiveFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return (
-    e.featureTarget.properties.active === Constants.activeStates.INACTIVE &&
-    e.featureTarget.properties.meta === Constants.meta.FEATURE
-  );
+	if (!e.featureTarget) return false;
+	if (!e.featureTarget.properties) return false;
+	return (
+		e.featureTarget.properties.active === Constants.activeStates.INACTIVE &&
+		e.featureTarget.properties.meta === Constants.meta.FEATURE
+	);
 }
 
 export function noTarget(e) {
-  return e.featureTarget === undefined;
+	return e.featureTarget === undefined;
 }
 
 export function isFeature(e) {
-  if (!e.featureTarget) return false;
-  if (!e.featureTarget.properties) return false;
-  return e.featureTarget.properties.meta === Constants.meta.FEATURE;
+	if (!e.featureTarget) return false;
+	if (!e.featureTarget.properties) return false;
+	return e.featureTarget.properties.meta === Constants.meta.FEATURE;
 }
 
 export function isVertex(e) {
-  const featureTarget = e.featureTarget;
-  if (!featureTarget) return false;
-  if (!featureTarget.properties) return false;
-  return featureTarget.properties.meta === Constants.meta.VERTEX;
+	const featureTarget = e.featureTarget;
+	if (!featureTarget) return false;
+	if (!featureTarget.properties) return false;
+	return featureTarget.properties.meta === Constants.meta.VERTEX;
 }
 
 export function isShiftDown(e) {
-  if (!e.originalEvent) return false;
-  return e.originalEvent.shiftKey === true;
+	if (!e.originalEvent) return false;
+	return e.originalEvent.shiftKey === true;
 }
 
 export function isEscapeKey(e) {
-  return e.keyCode === 27;
+	return e.keyCode === 27;
 }
 
 export function isEnterKey(e) {
-  return e.keyCode === 13;
+	return e.keyCode === 13;
 }
 
 export function isTrue() {
-  return true;
+	return true;
 }

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

@@ -3,97 +3,97 @@
  * 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'
+	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'
+	HOT: 'mapbox-gl-draw-hot',
+	COLD: 'mapbox-gl-draw-cold'
 };
 
 export const cursors = {
-  ADD: 'add',
-  MOVE: 'move',
-  DRAG: 'drag',
-  POINTER: 'pointer',
-  NONE: 'none'
+	ADD: 'add',
+	MOVE: 'move',
+	DRAG: 'drag',
+	POINTER: 'pointer',
+	NONE: 'none'
 };
 
 export const types = {
-  POLYGON: 'polygon',
-  LINE: 'line_string',
-  POINT: 'point'
+	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'
+	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'
+	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'
+	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'
+	MOVE: 'move',
+	CHANGE_COORDINATES: 'change_coordinates'
 };
 
 export const meta = {
-  FEATURE: 'feature',
-  MIDPOINT: 'midpoint',
-  VERTEX: 'vertex'
+	FEATURE: 'feature',
+	MIDPOINT: 'midpoint',
+	VERTEX: 'vertex'
 };
 
 export const activeStates = {
-  ACTIVE: 'true',
-  INACTIVE: 'false'
+	ACTIVE: 'true',
+	INACTIVE: 'false'
 };
 
 export const interactions = [
-  'scrollZoom',
-  'boxZoom',
-  'dragRotate',
-  'dragPan',
-  'keyboard',
-  'doubleClickZoom',
-  'touchZoomRotate'
+	'scrollZoom',
+	'boxZoom',
+	'dragRotate',
+	'dragPan',
+	'keyboard',
+	'doubleClickZoom',
+	'touchZoomRotate'
 ];
 
 export const LAT_MIN = -90;

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

@@ -6,67 +6,67 @@ 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,
+	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
+//	 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;
+	// "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;
+	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;
-  });
+	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;
-  }
+	// 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;
+	return constrainedDelta;
 };
 
 export default constrain_feature_movement;

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

@@ -5,38 +5,38 @@
 import * as Constants from "./constants";
 
 const create_midpoint = function (parent, startVertex, endVertex) {
-  const startCoord = startVertex.geometry.coordinates;
-  const endCoord = endVertex.geometry.coordinates;
+	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;
-  }
+	// 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,
-  };
+	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],
-    },
-  };
+	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

@@ -7,96 +7,96 @@ 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;
+	const { type, coordinates } = geojson.geometry;
+	const featureId = geojson.properties && geojson.properties.id;
 
-  let supplementaryPoints = [];
+	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();
-  }
+	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)
-      );
+	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;
+			// 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;
-      }
-    });
-  }
+			// 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;
-  }
+	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)
-      );
-    });
-  }
+	// 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;
+	return supplementaryPoints;
 }
 
 export default createSupplementaryPoints;