@deck.gl-community/editable-layers 9.0.0-alpha.1 → 9.0.2

package/src/mode-handlers/split-polygon-handler.ts

@@ -1,16 +1,20 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import booleanPointInPolygon from '@turf/boolean-point-in-polygon';
 import turfDifference from '@turf/difference';
 import turfBuffer from '@turf/buffer';
 import lineIntersect from '@turf/line-intersect';
-import { lineString } from '@turf/helpers';
+import {lineString} from '@turf/helpers';
 import turfBearing from '@turf/bearing';
 import turfDistance from '@turf/distance';
 import turfDestination from '@turf/destination';
 import turfPolygonToLine from '@turf/polygon-to-line';
-import nearestPointOnLine, { NearestPointOnLine } from '@turf/nearest-point-on-line';
-import { generatePointsParallelToLinePoints } from '../utils';
-import { EditAction, ModeHandler } from './mode-handler';
-import { ClickEvent, PointerMoveEvent } from '../edit-modes/types';
+import nearestPointOnLine, {NearestPointOnLine} from '@turf/nearest-point-on-line';
+import {generatePointsParallelToLinePoints} from '../utils/utils';
+import {EditAction, ModeHandler} from './mode-handler';
+import {ClickEvent, PointerMoveEvent} from '../edit-modes/types';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class SplitPolygonHandler extends ModeHandler {
@@ -42,9 +46,9 @@ export class SplitPolygonHandler extends ModeHandler {
       if (closestPoint) {
         // closest point is used as 90degree entry to the polygon
         const lastBearing = turfBearing(firstPoint, closestPoint);
-        const currentDistance = turfDistance(firstPoint, mapCoords, { units: 'meters' });
+        const currentDistance = turfDistance(firstPoint, mapCoords, {units: 'meters'});
         return turfDestination(firstPoint, currentDistance, lastBearing, {
-          units: 'meters',
+          units: 'meters'
         }).geometry.coordinates;
       }
       return mapCoords;
@@ -65,7 +69,7 @@ export class SplitPolygonHandler extends ModeHandler {
   handleClick(event: ClickEvent): EditAction | null | undefined {
     super.handleClick({
       ...event,
-      mapCoords: this.calculateMapCoords(this.getClickSequence(), event.mapCoords),
+      mapCoords: this.calculateMapCoords(this.getClickSequence(), event.mapCoords)
     });
     const editAction: EditAction | null | undefined = null;
     const tentativeFeature = this.getTentativeFeature();
@@ -80,7 +84,7 @@ export class SplitPolygonHandler extends ModeHandler {
     }
     const pt = {
       type: 'Point',
-      coordinates: clickSequence[clickSequence.length - 1],
+      coordinates: clickSequence[clickSequence.length - 1]
     };
     // @ts-expect-error turf type diff
     const isPointInPolygon = booleanPointInPolygon(pt, selectedGeometry);
@@ -98,12 +102,12 @@ export class SplitPolygonHandler extends ModeHandler {
     return editAction;
   }
 
-  handlePointerMove({ mapCoords }: PointerMoveEvent): {
+  handlePointerMove({mapCoords}: PointerMoveEvent): {
     editAction: EditAction | null | undefined;
     cancelMapPan: boolean;
   } {
     const clickSequence = this.getClickSequence();
-    const result = { editAction: null, cancelMapPan: false };
+    const result = {editAction: null, cancelMapPan: false};
 
     if (clickSequence.length === 0) {
       // nothing to do yet
@@ -114,8 +118,8 @@ export class SplitPolygonHandler extends ModeHandler {
       type: 'Feature',
       geometry: {
         type: 'LineString',
-        coordinates: [...clickSequence, this.calculateMapCoords(clickSequence, mapCoords)],
-      },
+        coordinates: [...clickSequence, this.calculateMapCoords(clickSequence, mapCoords)]
+      }
     });
 
     return result;
@@ -128,13 +132,13 @@ export class SplitPolygonHandler extends ModeHandler {
     const modeConfig = this.getModeConfig() || {};
 
     // Default gap in between the polygon
-    let { gap = 0.1, units = 'centimeters' } = modeConfig;
+    let {gap = 0.1, units = 'centimeters'} = modeConfig;
     if (gap === 0) {
       gap = 0.1;
       units = 'centimeters';
     }
     // @ts-expect-error turf type diff
-    const buffer = turfBuffer(tentativeFeature, gap, { units });
+    const buffer = turfBuffer(tentativeFeature, gap, {units});
     // @ts-expect-error turf type diff
     const updatedGeometry = turfDifference(selectedGeometry, buffer);
     this._setTentativeFeature(null);
@@ -144,7 +148,7 @@ export class SplitPolygonHandler extends ModeHandler {
       return null;
     }
 
-    const { type, coordinates } = updatedGeometry.geometry;
+    const {type, coordinates} = updatedGeometry.geometry;
     let updatedCoordinates: any[] = []; // TODO
     if (type === 'Polygon') {
       // Update the coordinates as per Multipolygon
@@ -162,14 +166,14 @@ export class SplitPolygonHandler extends ModeHandler {
     // Update the type to Mulitpolygon
     const updatedData = this.getImmutableFeatureCollection().replaceGeometry(featureIndex, {
       type: 'MultiPolygon',
-      coordinates: updatedCoordinates,
+      coordinates: updatedCoordinates
     });
 
     const editAction: EditAction = {
       updatedData: updatedData.getObject(),
       editType: 'split',
       featureIndexes: [featureIndex],
-      editContext: null,
+      editContext: null
     };
 
     return editAction;

package/src/mode-handlers/three-click-polygon-handler.ts

@@ -1,5 +1,9 @@
-import { ClickEvent } from '../edit-modes/types';
-import { ModeHandler, EditAction } from './mode-handler';
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ClickEvent} from '../edit-modes/types';
+import {ModeHandler, EditAction} from './mode-handler';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class ThreeClickPolygonHandler extends ModeHandler {

package/src/mode-handlers/translate-handler.ts

@@ -1,10 +1,14 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import turfBearing from '@turf/bearing';
 import turfDistance from '@turf/distance';
 import turfTransformTranslate from '@turf/transform-translate';
-import { point } from '@turf/helpers';
-import { FeatureCollection, Position } from '../geojson-types';
-import { PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
-import { EditAction, ModeHandler } from './mode-handler';
+import {point} from '@turf/helpers';
+import {FeatureCollection, Position} from '../utils/geojson-types';
+import {PointerMoveEvent, StartDraggingEvent, StopDraggingEvent} from '../edit-modes/types';
+import {EditAction, ModeHandler} from './mode-handler';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class TranslateHandler extends ModeHandler {
@@ -22,7 +26,7 @@ export class TranslateHandler extends ModeHandler {
 
     if (!this._isTranslatable || !event.pointerDownMapCoords) {
       // Nothing to do
-      return { editAction: null, cancelMapPan: false };
+      return {editAction: null, cancelMapPan: false};
     }
 
     if (event.isDragging && this._geometryBeforeTranslate) {
@@ -34,7 +38,7 @@ export class TranslateHandler extends ModeHandler {
       );
     }
 
-    return { editAction, cancelMapPan: true };
+    return {editAction, cancelMapPan: true};
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
@@ -62,7 +66,7 @@ export class TranslateHandler extends ModeHandler {
     return editAction;
   }
 
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     if (this._isTranslatable) {
       return 'move';
     }
@@ -104,7 +108,7 @@ export class TranslateHandler extends ModeHandler {
       updatedData: updatedData.getObject(),
       editType,
       featureIndexes: selectedIndexes,
-      editContext: null,
+      editContext: null
     };
   }
 }

package/src/mode-handlers/two-click-polygon-handler.ts

@@ -1,5 +1,9 @@
-import { ClickEvent } from '../edit-modes/types';
-import { ModeHandler, EditAction } from './mode-handler';
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ClickEvent} from '../edit-modes/types';
+import {ModeHandler, EditAction} from './mode-handler';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class TwoClickPolygonHandler extends ModeHandler {

package/src/mode-handlers/view-handler.ts

@@ -1,9 +1,13 @@
-import { Position } from '../geojson-types';
-import { EditHandle, ModeHandler } from './mode-handler';
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Position} from '../utils/geojson-types';
+import {EditHandle, ModeHandler} from './mode-handler';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class ViewHandler extends ModeHandler {
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     return isDragging ? 'grabbing' : 'grab';
   }
 

package/src/shaderlib/color/color.ts

@@ -1,10 +1,14 @@
-// TODO - this module is a WIP
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '@luma.gl/shadertools';
 
 /* eslint-disable camelcase */
 const INITIAL_STATE: Record<string, number> = {
   color_uOpacity: 1.0,
   color_uDesaturate: 0.0,
-  color_uBrightness: 1.0,
+  color_uBrightness: 1.0
 };
 
 function getUniforms(opts = INITIAL_STATE) {
@@ -48,9 +52,10 @@ vec4 color_filterColor(vec4 color) {
 }
 `;
 
-export default {
+/** Shader module that implements desaturation. @note still WIP */
+export const color = {
   name: 'color',
   vs,
   fs,
-  getUniforms,
-};
+  getUniforms
+} as const satisfies ShaderModule;

package/src/shaderlib/utils/utils.ts

@@ -1,3 +1,7 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // TODO - this module is a WIP
 
 /* eslint-disable camelcase */
@@ -25,9 +29,9 @@ vec2 project_clipspace_to_projective_uv(vec4 position) {
 
 const fs = vs;
 
-export default {
+export const utils = {
   name: 'outline',
   vs,
   fs,
-  getUniforms,
+  getUniforms
 };

package/src/{curve-utils.ts → utils/curve-utils.ts}

@@ -1,7 +1,11 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import hermite from 'cubic-hermite-spline';
 import turfDistance from '@turf/distance';
-import { lineString } from '@turf/helpers';
-import type { Feature, MultiLineString, LineString, Position } from '@turf/helpers';
+import {lineString} from '@turf/helpers';
+import type {Feature, MultiLineString, LineString, Position} from '@turf/helpers';
 
 const INTERPOLATION_INTERVAL = 0.005;
 const INTERPOLATION_THRESHOLD = 0.001;
@@ -21,7 +25,7 @@ export function generateCurveFromControlPoints(
   let prev: Position[] | null = null;
   let totalDistance = 0;
 
-  const { coordinates: coords } = line.geometry;
+  const {coordinates: coords} = line.geometry;
 
   for (let i = 0; i < coords.length; i++) {
     const cur = coords[i];
@@ -37,14 +41,14 @@ export function generateCurveFromControlPoints(
   const tangents: number[][] = [];
 
   // first tangent
-  // @ts-ignore
+  // @ts-expect-error TODO
   tangents.push(calculateSingleTangent(coords[0], coords[1], knots[1] - knots[0]));
 
   // second to before last
   for (let i = 1; i < coords.length - 1; i++) {
-    // @ts-ignore
+    // @ts-expect-error TODO
     const A = calculateSingleTangent(coords[i], coords[i + 1], knots[i + 1] - knots[i]);
-    // @ts-ignore
+    // @ts-expect-error TODO
     const B = calculateSingleTangent(coords[i - 1], coords[i], knots[i] - knots[i - 1]);
     const x = (A[0] + B[0]) / 2.0;
     const y = (A[1] + B[1]) / 2.0;
@@ -54,7 +58,7 @@ export function generateCurveFromControlPoints(
   // last tangent
   const last = coords.length - 1;
   tangents.push(
-    // @ts-ignore
+    // @ts-expect-error TODO
     calculateSingleTangent(coords[last - 1], coords[last], knots[last] - knots[last - 1])
   );
 

package/src/{geojson-types.ts → utils/geojson-types.ts}

@@ -1,6 +1,21 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // Geometry types
 
-export type Position = [number, number] | [number, number, number];
+import type {
+  Point,
+  LineString,
+  Polygon,
+  MultiPoint,
+  MultiLineString,
+  MultiPolygon,
+  Position
+} from 'geojson';
+
+export {Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, Position};
+
 export type PointCoordinates = Position;
 export type LineStringCoordinates = Position[];
 export type PolygonCoordinates = Position[][];
@@ -16,36 +31,6 @@ export type AnyCoordinates =
   | MultiLineStringCoordinates
   | MultiPolygonCoordinates;
 
-export type Point = {
-  type: 'Point';
-  coordinates: PointCoordinates;
-};
-
-export type LineString = {
-  type: 'LineString';
-  coordinates: LineStringCoordinates;
-};
-
-export type Polygon = {
-  type: 'Polygon';
-  coordinates: PolygonCoordinates;
-};
-
-export type MultiPoint = {
-  type: 'MultiPoint';
-  coordinates: MultiPointCoordinates;
-};
-
-export type MultiLineString = {
-  type: 'MultiLineString';
-  coordinates: MultiLineStringCoordinates;
-};
-
-export type MultiPolygon = {
-  type: 'MultiPolygon';
-  coordinates: MultiPolygonCoordinates;
-};
-
 export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
 
 export type Polygonal = Polygon | MultiPolygon;

package/src/{memoize.ts → utils/memoize.ts}

@@ -1,3 +1,7 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // port from @deck.gl/core
 function isEqual(a: any, b: any) {
   if (a === b) {
@@ -26,7 +30,7 @@ function isEqual(a: any, b: any) {
  * https://en.wikipedia.org/wiki/Memoization
  * @param {function} compute - the function to be memoized
  */
-export default function memoize(compute: Function) {
+export function memoize(compute: Function) {
   let cachedArgs = {};
   let cachedResult;
 

package/src/{translateFromCenter.ts → utils/translate-from-center.ts}

@@ -1,3 +1,7 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import turfCenter from '@turf/center';
 import turfRhumbBearing from '@turf/rhumb-bearing';
 import turfRhumbDistance from '@turf/rhumb-distance';
@@ -5,10 +9,10 @@ import turfRhumbDestination from '@turf/rhumb-destination';
 import type {
   Position as TurfPosition,
   Feature as TurfFeature,
-  Geometry as TurfGeometry,
+  Geometry as TurfGeometry
 } from '@turf/helpers';
-import { mapCoords } from './edit-modes/utils';
-import type { AnyCoordinates, Position } from './';
+import {mapCoords} from '../edit-modes/utils';
+import type {AnyCoordinates, Position} from './geojson-types';
 
 // This function takes feature's center, moves it,
 // and builds new feature around it keeping the proportions
@@ -38,7 +42,7 @@ export function translateFromCenter(
         distance,
         direction
       ).geometry.coordinates;
-      return movedPosition as Position;
+      return movedPosition;
     }
   );
 

package/src/{types.ts → utils/types.ts}

@@ -1,3 +1,7 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 export type LayerMouseEventResult = {
   eventConsumed?: boolean;
   eventSoftConsumed?: boolean;

package/src/{utils.ts → utils/utils.ts}

@@ -1,14 +1,18 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import destination from '@turf/destination';
 import bearing from '@turf/bearing';
 import pointToLineDistance from '@turf/point-to-line-distance';
-import { point } from '@turf/helpers';
+import {point} from '@turf/helpers';
 import WebMercatorViewport from 'viewport-mercator-project';
-import { FeatureOf, FeatureWithProps, LineString, Point, Position } from './geojson-types';
-import { Viewport } from './types';
+import {FeatureOf, FeatureWithProps, LineString, Point, Position} from './geojson-types';
+import {Viewport} from './types';
 
 // TODO edit-modes: delete and use edit-modes/utils instead
 
-export type NearestPointType = FeatureWithProps<Point, { dist: number; index: number }>;
+export type NearestPointType = FeatureWithProps<Point, {dist: number; index: number}>;
 
 export function toDeckColor(
   color?: [number, number, number, number] | number,
@@ -69,7 +73,7 @@ export function generatePointsParallelToLinePoints(
 ): Position[] {
   const lineString: LineString = {
     type: 'LineString',
-    coordinates: [p1, p2],
+    coordinates: [p1, p2]
   };
   const pt = point(mapCoords);
   const ddistance = pointToLineDistance(pt, lineString);
@@ -140,11 +144,11 @@ export function nearestPointOnProjectedLine(
       minPointInfo = {
         index,
         x0: (B * (B * x - A * y) - A * C) / div,
-        y0: (A * (-B * x + A * y) - B * C) / div,
+        y0: (A * (-B * x + A * y) - B * C) / div
       };
     }
   });
-  const { index, x0, y0 } = minPointInfo as any;
+  const {index, x0, y0} = minPointInfo as any;
   const [x1, y1, z1 = 0] = projectedCoords[index - 1];
   const [x2, y2, z2 = 0] = projectedCoords[index];
 
@@ -158,14 +162,13 @@ export function nearestPointOnProjectedLine(
     type: 'Feature',
     geometry: {
       type: 'Point',
-      // @ts-expect-error Position type diff
-      coordinates: wmViewport.unproject([x0, y0, z0]),
+      coordinates: wmViewport.unproject([x0, y0, z0])
     },
     properties: {
       // TODO: calculate the distance in proper units
       dist: minDistance,
-      index: index - 1,
-    },
+      index: index - 1
+    }
   };
 }
 

package/dist/editable-layers/path-marker-layer/arrow-2d-geometry.d.ts

@@ -1,4 +0,0 @@
-import { Geometry } from '@luma.gl/engine';
-export default class Arrow2DGeometry extends Geometry {
-    constructor(opts?: {});
-}

package/dist/editable-layers/path-marker-layer/arrow-2d-geometry.js

@@ -1,55 +0,0 @@
-import { Geometry } from '@luma.gl/engine';
-export default class Arrow2DGeometry extends Geometry {
-    constructor(opts = {}) {
-        super(Object.assign({}, opts, {
-            attributes: getArrowAttributes(opts),
-            topology: 'triangle-list'
-        }));
-    }
-}
-function getArrowAttributes({ length = 1, headSize = 0.2, tailWidth = 0.05, tailStart = 0.05 }) {
-    const texCoords = [
-        // HEAD
-        0.5,
-        1.0,
-        0,
-        0.5 - headSize / 2,
-        1.0 - headSize,
-        0,
-        0.5 + headSize / 2,
-        1.0 - headSize,
-        0,
-        0.5 - tailWidth / 2,
-        tailStart,
-        0,
-        0.5 + tailWidth / 2,
-        1.0 - headSize,
-        0,
-        0.5 + tailWidth / 2,
-        tailStart,
-        0,
-        0.5 - tailWidth / 2,
-        tailStart,
-        0,
-        0.5 - tailWidth / 2,
-        1.0 - headSize,
-        0,
-        0.5 + tailWidth / 2,
-        1.0 - headSize,
-        0,
-    ];
-    const normals = [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1];
-    // Center and scale
-    const positions = new Array(texCoords.length);
-    for (let i = 0; i < texCoords.length / 3; i++) {
-        const i3 = i * 3;
-        positions[i3 + 0] = (texCoords[i3 + 0] - 0.5) * length;
-        positions[i3 + 1] = (texCoords[i3 + 1] - 0.5) * length;
-        positions[i3 + 2] = 0;
-    }
-    return {
-        positions: { size: 3, value: new Float32Array(positions) },
-        normals: { size: 3, value: new Float32Array(normals) },
-        texCoords: { size: 2, value: new Float32Array(texCoords) },
-    };
-}

package/dist/editable-layers/path-marker-layer/create-path-markers.d.ts

@@ -1,16 +0,0 @@
-import { Position } from '../../geojson-types';
-import { Color } from '../../types';
-export interface PathMarker {
-    position: Position;
-    angle: number;
-    color: Color;
-    object: unknown;
-}
-export default function createPathMarkers({ data, getPath, getDirection, getColor, getMarkerPercentages, projectFlat, }: {
-    data: any;
-    getPath?: (x: any, context: any) => any;
-    getDirection?: (x: any) => any;
-    getColor?: (x: any) => number[];
-    getMarkerPercentages?: (x: any, info: any) => number[];
-    projectFlat: any;
-}): PathMarker[];

package/dist/editable-layers/path-marker-layer/create-path-markers.js

@@ -1,75 +0,0 @@
-import { Vector2 } from '@math.gl/core';
-function getLineLength(vPoints) {
-    // calculate total length
-    let lineLength = 0;
-    for (let i = 0; i < vPoints.length - 1; i++) {
-        lineLength += vPoints[i].distance(vPoints[i + 1]);
-    }
-    return lineLength;
-}
-const DEFAULT_COLOR = [0, 0, 0, 255];
-const DEFAULT_DIRECTION = { forward: true, backward: false };
-export default function createPathMarkers({ data, getPath = (x, context) => x.path, getDirection = (x) => x.direction, getColor = (x) => DEFAULT_COLOR, getMarkerPercentages = (x, info) => [0.5], projectFlat, }) {
-    const markers = [];
-    for (const object of data) {
-        const path = getPath(object, null);
-        const direction = getDirection(object) || DEFAULT_DIRECTION;
-        const color = getColor(object);
-        const vPoints = path.map((p) => new Vector2(p));
-        const vPointsReverse = vPoints.slice(0).reverse();
-        // calculate total length
-        const lineLength = getLineLength(vPoints);
-        // Ask for where to put markers
-        const percentages = getMarkerPercentages(object, { lineLength });
-        // Create the markers
-        for (const percentage of percentages) {
-            if (direction.forward) {
-                const marker = createMarkerAlongPath({
-                    path: vPoints,
-                    percentage,
-                    lineLength,
-                    color,
-                    object,
-                    projectFlat,
-                });
-                markers.push(marker);
-            }
-            if (direction.backward) {
-                const marker = createMarkerAlongPath({
-                    path: vPointsReverse,
-                    percentage,
-                    lineLength,
-                    color,
-                    object,
-                    projectFlat,
-                });
-                markers.push(marker);
-            }
-        }
-    }
-    return markers;
-}
-function createMarkerAlongPath({ path, percentage, lineLength, color, object, projectFlat }) {
-    const distanceAlong = lineLength * percentage;
-    let currentDistance = 0;
-    let previousDistance = 0;
-    let i = 0;
-    for (i = 0; i < path.length - 1; i++) {
-        currentDistance += path[i].distance(path[i + 1]);
-        if (currentDistance > distanceAlong) {
-            break;
-        }
-        previousDistance = currentDistance;
-    }
-    // If reached the end of the loop without exiting early,
-    // undo the final increment to avoid a null-pointer exception
-    if (i === path.length - 1) {
-        i -= 1;
-    }
-    const vDirection = path[i + 1].clone().subtract(path[i]).normalize();
-    const along = distanceAlong - previousDistance;
-    const vCenter = vDirection.clone().multiply(new Vector2(along, along)).add(path[i]);
-    const vDirection2 = new Vector2(projectFlat(path[i + 1])).subtract(projectFlat(path[i]));
-    const angle = (vDirection2.verticalAngle() * 180) / Math.PI;
-    return { position: [vCenter.x, vCenter.y, 0], angle, color, object };
-}