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

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

@@ -1,9 +1,13 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import turfCentroid from '@turf/centroid';
 import turfBearing from '@turf/bearing';
 import turfTransformRotate from '@turf/transform-rotate';
-import { FeatureCollection, Position } from '../geojson-types';
-import { PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
-import { EditAction, ModeHandler } from './mode-handler';
+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 RotateHandler extends ModeHandler {
@@ -20,19 +24,15 @@ export class RotateHandler extends ModeHandler {
 
     if (!this._isRotatable || !event.pointerDownMapCoords) {
       // Nothing to do
-      return { editAction: null, cancelMapPan: false };
+      return {editAction: null, cancelMapPan: false};
     }
 
     if (event.isDragging && this._geometryBeingRotated) {
       // Rotate the geometry
-      editAction = this.getRotateAction(
-        event.pointerDownMapCoords,
-        event.mapCoords,
-        'rotating'
-      );
+      editAction = this.getRotateAction(event.pointerDownMapCoords, event.mapCoords, 'rotating');
     }
 
-    return { editAction, cancelMapPan: true };
+    return {editAction, cancelMapPan: true};
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
@@ -49,18 +49,14 @@ export class RotateHandler extends ModeHandler {
 
     if (this._geometryBeingRotated) {
       // Rotate the geometry
-      editAction = this.getRotateAction(
-        event.pointerDownMapCoords,
-        event.mapCoords,
-        'rotated'
-      );
+      editAction = this.getRotateAction(event.pointerDownMapCoords, event.mapCoords, 'rotated');
       this._geometryBeingRotated = null;
     }
 
     return editAction;
   }
 
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     if (this._isRotatable) {
       // TODO: look at doing SVG cursors to get a better "rotate" cursor
       return 'move';
@@ -95,7 +91,7 @@ export class RotateHandler extends ModeHandler {
       updatedData: updatedData.getObject(),
       editType,
       featureIndexes: selectedIndexes,
-      editContext: null,
+      editContext: null
     };
   }
 }

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

@@ -1,9 +1,13 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import turfCentroid from '@turf/centroid';
 import turfDistance from '@turf/distance';
 import turfTransformScale from '@turf/transform-scale';
-import { FeatureCollection, Position } from '../geojson-types';
-import { PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
-import { EditAction, ModeHandler } from './mode-handler';
+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 ScaleHandler extends ModeHandler {
@@ -20,19 +24,15 @@ export class ScaleHandler extends ModeHandler {
 
     if (!this._isScalable || !event.pointerDownMapCoords) {
       // Nothing to do
-      return { editAction: null, cancelMapPan: false };
+      return {editAction: null, cancelMapPan: false};
     }
 
     if (event.isDragging && this._geometryBeingScaled) {
       // Scale the geometry
-      editAction = this.getScaleAction(
-        event.pointerDownMapCoords,
-        event.mapCoords,
-        'scaling'
-      );
+      editAction = this.getScaleAction(event.pointerDownMapCoords, event.mapCoords, 'scaling');
     }
 
-    return { editAction, cancelMapPan: true };
+    return {editAction, cancelMapPan: true};
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
@@ -56,7 +56,7 @@ export class ScaleHandler extends ModeHandler {
     return editAction;
   }
 
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     if (this._isScalable) {
       // TODO: look at doing SVG cursors to get a better "scale" cursor
       return 'move';
@@ -76,7 +76,7 @@ export class ScaleHandler extends ModeHandler {
       this._geometryBeingScaled,
       factor,
       {
-        origin: centroid,
+        origin: centroid
       }
     );
 
@@ -93,7 +93,7 @@ export class ScaleHandler extends ModeHandler {
       updatedData: updatedData.getObject(),
       editType,
       featureIndexes: selectedIndexes,
-      editContext: null,
+      editContext: null
     };
   }
 }

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

@@ -1,14 +1,18 @@
-import { Feature, FeatureCollection, Position } from '../geojson-types';
-import { PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Feature, FeatureCollection, Position} from '../utils/geojson-types';
+import {PointerMoveEvent, StartDraggingEvent, StopDraggingEvent} from '../edit-modes/types';
 import {
   EditHandle,
   EditAction,
   ModeHandler,
   getPickedEditHandle,
-  getEditHandlesForGeometry,
+  getEditHandlesForGeometry
 } from './mode-handler';
 
-type HandlePicks = { pickedHandle?: EditHandle; potentialSnapHandle?: EditHandle };
+type HandlePicks = {pickedHandle?: EditHandle; potentialSnapHandle?: EditHandle};
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
 export class SnappableHandler extends ModeHandler {
@@ -38,39 +42,39 @@ export class SnappableHandler extends ModeHandler {
     // @ts-expect-error narrow event type
     return Object.assign({}, event, {
       mapCoords: snapPoint,
-      pointerDownMapCoords: this._startDragSnapHandlePosition,
+      pointerDownMapCoords: this._startDragSnapHandlePosition
     });
   }
 
   _getEditHandlePicks(event: PointerMoveEvent): HandlePicks {
-    const { picks } = event;
+    const {picks} = event;
 
     const potentialSnapHandle = picks.find(
       (pick) => pick.object && pick.object.type === 'intermediate'
     );
-    const handles = { potentialSnapHandle: potentialSnapHandle && potentialSnapHandle.object };
+    const handles = {potentialSnapHandle: potentialSnapHandle && potentialSnapHandle.object};
 
     const pickedHandle = getPickedEditHandle(event.pointerDownPicks);
     if (pickedHandle) {
-      return { ...handles, pickedHandle };
+      return {...handles, pickedHandle};
     }
 
     return handles;
   }
 
   _updatePickedHandlePosition(editAction: EditAction) {
-    const { pickedHandle = {} as EditHandle } = this._editHandlePicks || {};
+    const {pickedHandle = {} as EditHandle} = this._editHandlePicks || {};
 
     if (pickedHandle && editAction) {
-      const { featureIndexes, updatedData } = editAction;
+      const {featureIndexes, updatedData} = editAction;
 
       for (let i = 0; i < featureIndexes.length; i++) {
         const selectedIndex = featureIndexes[i];
         const updatedFeature = updatedData.features[selectedIndex];
 
-        const { positionIndexes, featureIndex } = pickedHandle;
+        const {positionIndexes, featureIndex} = pickedHandle;
         if (selectedIndex >= 0 && featureIndex === selectedIndex) {
-          const { coordinates } = updatedFeature.geometry;
+          const {coordinates} = updatedFeature.geometry;
           pickedHandle.position = positionIndexes.reduce(
             (a: any[], b: number) => a[b],
             coordinates
@@ -85,12 +89,12 @@ export class SnappableHandler extends ModeHandler {
   // that live in the current layer. Otherwise, this method will simply return the
   // features from the current layer
   _getSnapTargets(): Feature[] {
-    let { additionalSnapTargets } = this.getModeConfig() || {};
+    let {additionalSnapTargets} = this.getModeConfig() || {};
     additionalSnapTargets = additionalSnapTargets || [];
 
     const features = [
       ...this._handler.featureCollection.getObject().features,
-      ...additionalSnapTargets,
+      ...additionalSnapTargets
     ];
     return features;
   }
@@ -105,7 +109,7 @@ export class SnappableHandler extends ModeHandler {
         i < features.length && !this._handler.getSelectedFeatureIndexes().includes(i);
 
       if (isCurrentIndexFeatureNotSelected) {
-        const { geometry } = features[i];
+        const {geometry} = features[i];
         handles.push(...getEditHandlesForGeometry(geometry, i, 'intermediate'));
       }
     }
@@ -116,21 +120,21 @@ export class SnappableHandler extends ModeHandler {
   // selected feature. If a snap handle has been picked, display said snap handle
   // along with all snappable points on all non-selected features.
   getEditHandles(picks?: Array<Record<string, any>>, mapCoords?: Position): any[] {
-    const { enableSnapping } = this._modeConfig || {};
+    const {enableSnapping} = this._modeConfig || {};
     const handles = this._handler.getEditHandles(picks, mapCoords);
 
     if (!enableSnapping) return handles;
-    const { pickedHandle } = this._editHandlePicks || {};
+    const {pickedHandle} = this._editHandlePicks || {};
 
     if (pickedHandle) {
       handles.push(...this._getNonPickedIntermediateHandles(), pickedHandle);
       return handles;
     }
 
-    const { features } = this._handler.featureCollection.getObject();
+    const {features} = this._handler.featureCollection.getObject();
     for (const index of this._handler.getSelectedFeatureIndexes()) {
       if (index < features.length) {
-        const { geometry } = features[index];
+        const {geometry} = features[index];
         handles.push(...getEditHandlesForGeometry(geometry, index, 'snap'));
       }
     }
@@ -139,7 +143,7 @@ export class SnappableHandler extends ModeHandler {
   }
 
   _getSnapAwareEvent(event: Record<string, any>): Record<string, any> {
-    const { potentialSnapHandle } = this._editHandlePicks || {};
+    const {potentialSnapHandle} = this._editHandlePicks || {};
 
     return potentialSnapHandle && potentialSnapHandle.position
       ? this._getSnappedMouseEvent(event, potentialSnapHandle.position)
@@ -147,7 +151,7 @@ export class SnappableHandler extends ModeHandler {
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
-    this._startDragSnapHandlePosition = (getPickedEditHandle(event.picks) || {}).position as Position;
+    this._startDragSnapHandlePosition = (getPickedEditHandle(event.picks) || {}).position;
     return this._handler.handleStartDragging(event);
   }
 
@@ -159,7 +163,7 @@ export class SnappableHandler extends ModeHandler {
     return modeActionSummary;
   }
 
-  getCursor(event: { isDragging: boolean }): string {
+  getCursor(event: {isDragging: boolean}): string {
     return this._handler.getCursor(event);
   }
 
@@ -167,14 +171,14 @@ export class SnappableHandler extends ModeHandler {
     editAction: EditAction | null | undefined;
     cancelMapPan: boolean;
   } {
-    const { enableSnapping } = this._handler.getModeConfig() || {};
+    const {enableSnapping} = this._handler.getModeConfig() || {};
 
     if (enableSnapping) {
       this._editHandlePicks = this._getEditHandlePicks(event);
     }
     // @ts-expect-error narrow event type
     const modeActionSummary = this._handler.handlePointerMove(this._getSnapAwareEvent(event));
-    const { editAction } = modeActionSummary;
+    const {editAction} = modeActionSummary;
     if (editAction) {
       this._updatePickedHandlePosition(editAction);
     }

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])
   );