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

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

@@ -1,25 +1,23 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // TODO edit-modes: delete handlers once EditMode fully implemented
 
 import turfUnion from '@turf/union';
 import turfDifference from '@turf/difference';
 import turfIntersect from '@turf/intersect';
 
-import {
-  FeatureCollection,
-  Feature,
-  Polygon,
-  Geometry,
-  Position,
-} from '../geojson-types';
+import {FeatureCollection, Feature, Polygon, Geometry, Position} from '../utils/geojson-types';
 
 import {
   ClickEvent,
   Pick,
   PointerMoveEvent,
   StartDraggingEvent,
-  StopDraggingEvent,
+  StopDraggingEvent
 } from '../edit-modes/types';
-import { ImmutableFeatureCollection } from '../edit-modes/immutable-feature-collection';
+import {ImmutableFeatureCollection} from '../edit-modes/immutable-feature-collection';
 
 export type EditHandleType = 'existing' | 'intermediate' | 'snap';
 
@@ -75,13 +73,13 @@ export class ModeHandler {
   }
 
   getSelectedFeaturesAsFeatureCollection(): FeatureCollection {
-    const { features } = this.featureCollection.getObject();
+    const {features} = this.featureCollection.getObject();
     const selectedFeatures = this.getSelectedFeatureIndexes().map(
       (selectedIndex) => features[selectedIndex]
     );
     return {
       type: 'FeatureCollection',
-      features: selectedFeatures,
+      features: selectedFeatures
     };
   }
 
@@ -145,13 +143,13 @@ export class ModeHandler {
     return [];
   }
 
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     return 'cell';
   }
 
   isSelectionPicked(picks: Pick[]): boolean {
     if (!picks.length) return false;
-    const pickedIndexes = picks.map(({ index }) => index);
+    const pickedIndexes = picks.map(({index}) => index);
     const selectedFeatureIndexes = this.getSelectedFeatureIndexes();
     return selectedFeatureIndexes.some((index) => pickedIndexes.includes(index));
   }
@@ -164,7 +162,7 @@ export class ModeHandler {
       .addFeature({
         type: 'Feature',
         properties: {},
-        geometry: geometryAsAny,
+        geometry: geometryAsAny
       })
       .getObject();
 
@@ -173,8 +171,8 @@ export class ModeHandler {
       editType: 'addFeature',
       featureIndexes: [updatedData.features.length - 1],
       editContext: {
-        featureIndexes: [updatedData.features.length - 1],
-      },
+        featureIndexes: [updatedData.features.length - 1]
+      }
     };
   }
 
@@ -184,12 +182,12 @@ export class ModeHandler {
     const initialIndex = updatedData.getObject().features.length;
     const updatedIndexes: number[] = [];
     for (const feature of features) {
-      const { properties, geometry } = feature;
+      const {properties, geometry} = feature;
       const geometryAsAny: any = geometry;
       updatedData = updatedData.addFeature({
         type: 'Feature',
         properties,
-        geometry: geometryAsAny,
+        geometry: geometryAsAny
       });
       updatedIndexes.push(initialIndex + updatedIndexes.length);
     }
@@ -199,8 +197,8 @@ export class ModeHandler {
       editType: 'addFeature',
       featureIndexes: updatedIndexes,
       editContext: {
-        featureIndexes: updatedIndexes,
-      },
+        featureIndexes: updatedIndexes
+      }
     };
   }
 
@@ -222,7 +220,7 @@ export class ModeHandler {
 
       const feature = {
         type: 'Feature',
-        geometry,
+        geometry
       };
 
       let updatedGeometry;
@@ -258,8 +256,8 @@ export class ModeHandler {
         editType: 'unionGeometry',
         featureIndexes: [featureIndex],
         editContext: {
-          featureIndexes: [featureIndex],
-        },
+          featureIndexes: [featureIndex]
+        }
       };
 
       return editAction;
@@ -277,7 +275,7 @@ export class ModeHandler {
     editAction: EditAction | null | undefined;
     cancelMapPan: boolean;
   } {
-    return { editAction: null, cancelMapPan: false };
+    return {editAction: null, cancelMapPan: false};
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
@@ -302,7 +300,7 @@ export function getPickedEditHandle(
 export function getIntermediatePosition(position1: Position, position2: Position): Position {
   const intermediatePosition: Position = [
     (position1[0] + position2[0]) / 2.0,
-    (position1[1] + position2[1]) / 2.0,
+    (position1[1] + position2[1]) / 2.0
   ];
 
   return intermediatePosition;
@@ -323,8 +321,8 @@ export function getEditHandlesForGeometry(
           position: geometry.coordinates,
           positionIndexes: [],
           featureIndex,
-          type: editHandleType,
-        },
+          type: editHandleType
+        }
       ];
       break;
     case 'MultiPoint':
@@ -387,7 +385,7 @@ function getEditHandlesForCoordinates(
       position,
       positionIndexes: [...positionIndexPrefix, i],
       featureIndex,
-      type: editHandleType,
+      type: editHandleType
     });
   }
   return editHandles;

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

@@ -1,23 +1,27 @@
+// deck.gl-community
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import nearestPointOnLine from '@turf/nearest-point-on-line';
-import { point, lineString as toLineString } from '@turf/helpers';
-import { Position, FeatureOf, Point, LineString } from '../geojson-types';
+import {point, lineString as toLineString} from '@turf/helpers';
+import {Position, FeatureOf, Point, LineString} from '../utils/geojson-types';
 import {
   recursivelyTraverseNestedArrays,
   nearestPointOnProjectedLine,
-  NearestPointType,
-} from '../utils';
+  NearestPointType
+} from '../utils/utils';
 import {
   ClickEvent,
   PointerMoveEvent,
   StartDraggingEvent,
-  StopDraggingEvent,
+  StopDraggingEvent
 } from '../edit-modes/types';
 import {
   EditAction,
   EditHandle,
   ModeHandler,
   getPickedEditHandle,
-  getEditHandlesForGeometry,
+  getEditHandlesForGeometry
 } from './mode-handler';
 
 // TODO edit-modes: delete handlers once EditMode fully implemented
@@ -26,11 +30,11 @@ export class ModifyHandler extends ModeHandler {
 
   getEditHandles(picks?: Array<Record<string, any>>, mapCoords?: Position): EditHandle[] {
     let handles: EditHandle[] = [];
-    const { features } = this.featureCollection.getObject();
+    const {features} = this.featureCollection.getObject();
 
     for (const index of this.getSelectedFeatureIndexes()) {
       if (index < features.length) {
-        const { geometry } = features[index];
+        const {geometry} = features[index];
         handles.push(...getEditHandlesForGeometry(geometry, index));
       } else {
         console.warn(`selectedFeatureIndexes out of range ${index}`); // eslint-disable-line no-console,no-undef
@@ -78,8 +82,8 @@ export class ModifyHandler extends ModeHandler {
         // tack on the lone intermediate point to the set of handles
         if (intermediatePoint) {
           const {
-            geometry: { coordinates: position },
-            properties: { index },
+            geometry: {coordinates: position},
+            properties: {index}
           } = intermediatePoint;
           handles = [
             ...handles,
@@ -87,8 +91,8 @@ export class ModifyHandler extends ModeHandler {
               position,
               positionIndexes: [...positionIndexPrefix, index + 1],
               featureIndex: featureAsPick.index,
-              type: 'intermediate',
-            },
+              type: 'intermediate'
+            }
           ];
         }
       }
@@ -99,7 +103,7 @@ export class ModifyHandler extends ModeHandler {
 
   // turf.js does not support elevation for nearestPointOnLine
   nearestPointOnLine(line: FeatureOf<LineString>, inPoint: FeatureOf<Point>): NearestPointType {
-    const { coordinates } = line.geometry;
+    const {coordinates} = line.geometry;
     if (coordinates.some((coord) => coord.length > 2)) {
       const modeConfig = this.getModeConfig();
       if (modeConfig && modeConfig.viewport) {
@@ -138,8 +142,8 @@ export class ModifyHandler extends ModeHandler {
             featureIndexes: [clickedEditHandle.featureIndex],
             editContext: {
               positionIndexes: clickedEditHandle.positionIndexes,
-              position: clickedEditHandle.position,
-            },
+              position: clickedEditHandle.position
+            }
           };
         }
       } else if (clickedEditHandle.type === 'intermediate') {
@@ -158,8 +162,8 @@ export class ModifyHandler extends ModeHandler {
             featureIndexes: [clickedEditHandle.featureIndex],
             editContext: {
               positionIndexes: clickedEditHandle.positionIndexes,
-              position: clickedEditHandle.position,
-            },
+              position: clickedEditHandle.position
+            }
           };
         }
       }
@@ -188,15 +192,15 @@ export class ModifyHandler extends ModeHandler {
         featureIndexes: [editHandle.featureIndex],
         editContext: {
           positionIndexes: editHandle.positionIndexes,
-          position: event.mapCoords,
-        },
+          position: event.mapCoords
+        }
       };
     }
 
     // Cancel map panning if pointer went down on an edit handle
     const cancelMapPan = Boolean(editHandle);
 
-    return { editAction, cancelMapPan };
+    return {editAction, cancelMapPan};
   }
 
   handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined {
@@ -216,8 +220,8 @@ export class ModifyHandler extends ModeHandler {
         featureIndexes: [editHandle.featureIndex],
         editContext: {
           positionIndexes: editHandle.positionIndexes,
-          position: event.mapCoords,
-        },
+          position: event.mapCoords
+        }
       };
     }
 
@@ -240,15 +244,15 @@ export class ModifyHandler extends ModeHandler {
         featureIndexes: [editHandle.featureIndex],
         editContext: {
           positionIndexes: editHandle.positionIndexes,
-          position: event.mapCoords,
-        },
+          position: event.mapCoords
+        }
       };
     }
 
     return editAction;
   }
 
-  getCursor({ isDragging }: { isDragging: boolean }): string {
+  getCursor({isDragging}: {isDragging: boolean}): string {
     const picks = this._lastPointerMovePicks;
 
     if (picks && picks.length > 0) {

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