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

package/dist/mode-handlers/duplicate-handler.d.ts

@@ -0,0 +1,9 @@
+import { StartDraggingEvent } from '../edit-modes/types';
+import { EditAction } from './mode-handler';
+import { TranslateHandler } from './translate-handler';
+export declare class DuplicateHandler extends TranslateHandler {
+    handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined;
+    getCursor({ isDragging }: {
+        isDragging: boolean;
+    }): string;
+}

package/dist/mode-handlers/duplicate-handler.js

@@ -0,0 +1,19 @@
+import { TranslateHandler } from './translate-handler';
+// TODO edit-modes: delete handlers once EditMode fully implemented
+export class DuplicateHandler extends TranslateHandler {
+    handleStartDragging(event) {
+        if (!this._isTranslatable) {
+            return null;
+        }
+        this._geometryBeforeTranslate = this.getSelectedFeaturesAsFeatureCollection();
+        return this._geometryBeforeTranslate
+            ? this.getAddManyFeaturesAction(this._geometryBeforeTranslate)
+            : null;
+    }
+    getCursor({ isDragging }) {
+        if (this._isTranslatable) {
+            return 'copy';
+        }
+        return isDragging ? 'grabbing' : 'grab';
+    }
+}

package/dist/mode-handlers/elevation-handler.d.ts

@@ -0,0 +1,19 @@
+import { Position } from '../geojson-types';
+import { PointerMoveEvent, StopDraggingEvent } from '../edit-modes/types';
+import { EditAction } from './mode-handler';
+import { ModifyHandler } from './modify-handler';
+export declare class ElevationHandler extends ModifyHandler {
+    makeElevatedEvent<T extends PointerMoveEvent | StopDraggingEvent>(event: T, position: Position): T;
+    handlePointerMove(event: PointerMoveEvent): {
+        editAction: EditAction | null | undefined;
+        cancelMapPan: boolean;
+    };
+    handleStopDragging(event: StopDraggingEvent): EditAction | null | undefined;
+    getCursor(params: {
+        isDragging: boolean;
+    }): string;
+    static calculateElevationChangeWithViewport(viewport: any, { pointerDownScreenCoords, screenCoords, }: {
+        pointerDownScreenCoords: Position;
+        screenCoords: Position;
+    }): number;
+}

package/dist/mode-handlers/elevation-handler.js

@@ -0,0 +1,48 @@
+import { getPickedEditHandle } from './mode-handler';
+import { ModifyHandler } from './modify-handler';
+function defaultCalculateElevationChange({ pointerDownScreenCoords, screenCoords, }) {
+    return 10 * (pointerDownScreenCoords[1] - screenCoords[1]);
+}
+// TODO edit-modes: delete handlers once EditMode fully implemented
+export class ElevationHandler extends ModifyHandler {
+    makeElevatedEvent(event, position) {
+        if (!event.pointerDownScreenCoords) {
+            return event;
+        }
+        const { minElevation = 0, maxElevation = 20000, calculateElevationChange = defaultCalculateElevationChange, } = this._modeConfig || {};
+        // $FlowFixMe - really, I know it has something at index 2
+        let elevation = position.length === 3 ? position[2] : 0;
+        // calculateElevationChange is configurable becase (at this time) modes are not aware of the viewport
+        elevation += calculateElevationChange({
+            pointerDownScreenCoords: event.pointerDownScreenCoords,
+            screenCoords: event.screenCoords,
+        });
+        elevation = Math.min(elevation, maxElevation);
+        elevation = Math.max(elevation, minElevation);
+        return Object.assign({}, event, {
+            mapCoords: [position[0], position[1], elevation],
+        });
+    }
+    handlePointerMove(event) {
+        const editHandle = getPickedEditHandle(event.pointerDownPicks);
+        const position = editHandle ? editHandle.position : event.mapCoords;
+        return super.handlePointerMove(this.makeElevatedEvent(event, position));
+    }
+    handleStopDragging(event) {
+        const editHandle = getPickedEditHandle(event.picks);
+        const position = editHandle ? editHandle.position : event.mapCoords;
+        return super.handleStopDragging(this.makeElevatedEvent(event, position));
+    }
+    getCursor(params) {
+        let cursor = super.getCursor(params);
+        if (cursor === 'cell') {
+            cursor = 'ns-resize';
+        }
+        return cursor;
+    }
+    static calculateElevationChangeWithViewport(viewport, { pointerDownScreenCoords, screenCoords, }) {
+        // Source: https://gis.stackexchange.com/a/127949/111804
+        const metersPerPixel = (156543.03392 * Math.cos((viewport.latitude * Math.PI) / 180)) / Math.pow(2, viewport.zoom);
+        return (metersPerPixel * (pointerDownScreenCoords[1] - screenCoords[1])) / 2;
+    }
+}

package/dist/mode-handlers/extrude-handler.d.ts

@@ -0,0 +1,18 @@
+import { PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
+import { EditAction } from './mode-handler';
+import { ModifyHandler } from './modify-handler';
+export declare class ExtrudeHandler extends ModifyHandler {
+    isPointAdded: boolean;
+    handlePointerMove(event: PointerMoveEvent): {
+        editAction: EditAction | null | undefined;
+        cancelMapPan: boolean;
+    };
+    handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined;
+    handleStopDragging(event: StopDraggingEvent): EditAction | null | undefined;
+    coordinatesSize(positionIndexes: number[], featureIndex: number): number;
+    getBearing(p1: any, p2: any): number;
+    isOrthogonal(positionIndexes: number[], featureIndex: number, size: number): boolean;
+    nextPositionIndexes(positionIndexes: number[], size: number): number[];
+    prevPositionIndexes(positionIndexes: number[], size: number): number[];
+    getPointForPositionIndexes(positionIndexes: number[], featureIndex: number): any;
+}

package/dist/mode-handlers/extrude-handler.js

@@ -0,0 +1,176 @@
+import bearing from '@turf/bearing';
+import { generatePointsParallelToLinePoints } from '../utils';
+import { getPickedEditHandle } from './mode-handler';
+import { ModifyHandler } from './modify-handler';
+// TODO edit-modes: delete handlers once EditMode fully implemented
+export class ExtrudeHandler extends ModifyHandler {
+    isPointAdded = false;
+    handlePointerMove(event) {
+        this._lastPointerMovePicks = event.picks;
+        let editAction = null;
+        const editHandle = getPickedEditHandle(event.pointerDownPicks);
+        if (event.isDragging && editHandle) {
+            const size = this.coordinatesSize(editHandle.positionIndexes, editHandle.featureIndex);
+            const positionIndexes = this.isPointAdded
+                ? this.nextPositionIndexes(editHandle.positionIndexes, size)
+                : editHandle.positionIndexes;
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), editHandle.featureIndex);
+            const p2 = this.getPointForPositionIndexes(positionIndexes, editHandle.featureIndex);
+            if (p1 && p2) {
+                // p3 and p4 are end points for moving (extruding) edge
+                const [p3, p4] = generatePointsParallelToLinePoints(p1, p2, event.mapCoords);
+                const updatedData = this.getImmutableFeatureCollection()
+                    .replacePosition(editHandle.featureIndex, this.prevPositionIndexes(positionIndexes, size), p4)
+                    .replacePosition(editHandle.featureIndex, positionIndexes, p3)
+                    .getObject();
+                editAction = {
+                    updatedData,
+                    editType: 'extruding',
+                    featureIndexes: [editHandle.featureIndex],
+                    editContext: {
+                        positionIndexes: this.nextPositionIndexes(editHandle.positionIndexes, size),
+                        position: p3,
+                    },
+                };
+            }
+        }
+        // Cancel map panning if pointer went down on an edit handle
+        const cancelMapPan = Boolean(editHandle);
+        return { editAction, cancelMapPan };
+    }
+    handleStartDragging(event) {
+        let editAction = null;
+        const selectedFeatureIndexes = this.getSelectedFeatureIndexes();
+        const editHandle = getPickedEditHandle(event.picks);
+        if (selectedFeatureIndexes.length && editHandle && editHandle.type === 'intermediate') {
+            const size = this.coordinatesSize(editHandle.positionIndexes, editHandle.featureIndex);
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(editHandle.positionIndexes, size), editHandle.featureIndex);
+            const p2 = this.getPointForPositionIndexes(editHandle.positionIndexes, editHandle.featureIndex);
+            if (p1 && p2) {
+                let updatedData = this.getImmutableFeatureCollection();
+                if (!this.isOrthogonal(editHandle.positionIndexes, editHandle.featureIndex, size)) {
+                    updatedData = updatedData.addPosition(editHandle.featureIndex, editHandle.positionIndexes, p2);
+                }
+                if (!this.isOrthogonal(this.prevPositionIndexes(editHandle.positionIndexes, size), editHandle.featureIndex, size)) {
+                    updatedData = updatedData.addPosition(editHandle.featureIndex, editHandle.positionIndexes, p1);
+                    this.isPointAdded = true;
+                }
+                editAction = {
+                    updatedData: updatedData.getObject(),
+                    editType: 'startExtruding',
+                    featureIndexes: [editHandle.featureIndex],
+                    editContext: {
+                        positionIndexes: editHandle.positionIndexes,
+                        position: p1,
+                    },
+                };
+            }
+        }
+        return editAction;
+    }
+    handleStopDragging(event) {
+        let editAction = null;
+        const selectedFeatureIndexes = this.getSelectedFeatureIndexes();
+        const editHandle = getPickedEditHandle(event.picks);
+        if (selectedFeatureIndexes.length && editHandle) {
+            const size = this.coordinatesSize(editHandle.positionIndexes, editHandle.featureIndex);
+            const positionIndexes = this.isPointAdded
+                ? this.nextPositionIndexes(editHandle.positionIndexes, size)
+                : editHandle.positionIndexes;
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), editHandle.featureIndex);
+            const p2 = this.getPointForPositionIndexes(positionIndexes, editHandle.featureIndex);
+            if (p1 && p2) {
+                // p3 and p4 are end points for new moved (extruded) edge
+                const [p3, p4] = generatePointsParallelToLinePoints(p1, p2, event.mapCoords);
+                const updatedData = this.getImmutableFeatureCollection()
+                    .replacePosition(editHandle.featureIndex, this.prevPositionIndexes(positionIndexes, size), p4)
+                    .replacePosition(editHandle.featureIndex, positionIndexes, p3)
+                    .getObject();
+                editAction = {
+                    updatedData,
+                    editType: 'extruded',
+                    featureIndexes: [editHandle.featureIndex],
+                    editContext: {
+                        positionIndexes: editHandle.positionIndexes,
+                        position: p3,
+                    },
+                };
+            }
+        }
+        this.isPointAdded = false;
+        return editAction;
+    }
+    coordinatesSize(positionIndexes, featureIndex) {
+        let size = 0;
+        const feature = this.getImmutableFeatureCollection().getObject().features[featureIndex];
+        const coordinates = feature.geometry.coordinates;
+        // for Multi polygons, length will be 3
+        if (positionIndexes.length === 3) {
+            const [a, b] = positionIndexes;
+            if (coordinates.length && coordinates[a].length) {
+                size = coordinates[a][b].length;
+            }
+        }
+        else {
+            const [b] = positionIndexes;
+            if (coordinates.length && coordinates[b].length) {
+                size = coordinates[b].length;
+            }
+        }
+        return size;
+    }
+    getBearing(p1, p2) {
+        const angle = bearing(p1, p2);
+        if (angle < 0) {
+            return Math.floor(360 + angle);
+        }
+        return Math.floor(angle);
+    }
+    isOrthogonal(positionIndexes, featureIndex, size) {
+        if (positionIndexes[positionIndexes.length - 1] === size - 1) {
+            positionIndexes[positionIndexes.length - 1] = 0;
+        }
+        const prevPoint = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex);
+        const nextPoint = this.getPointForPositionIndexes(this.nextPositionIndexes(positionIndexes, size), featureIndex);
+        const currentPoint = this.getPointForPositionIndexes(positionIndexes, featureIndex);
+        const prevAngle = this.getBearing(currentPoint, prevPoint);
+        const nextAngle = this.getBearing(currentPoint, nextPoint);
+        return [89, 90, 91, 269, 270, 271].includes(Math.abs(prevAngle - nextAngle));
+    }
+    nextPositionIndexes(positionIndexes, size) {
+        const next = [...positionIndexes];
+        if (next.length) {
+            next[next.length - 1] = next[next.length - 1] === size - 1 ? 0 : next[next.length - 1] + 1;
+        }
+        return next;
+    }
+    prevPositionIndexes(positionIndexes, size) {
+        const prev = [...positionIndexes];
+        if (prev.length) {
+            prev[prev.length - 1] = prev[prev.length - 1] === 0 ? size - 2 : prev[prev.length - 1] - 1;
+        }
+        return prev;
+    }
+    getPointForPositionIndexes(positionIndexes, featureIndex) {
+        let p1;
+        const feature = this.getImmutableFeatureCollection().getObject().features[featureIndex];
+        const coordinates = feature.geometry.coordinates;
+        // for Multi polygons, length will be 3
+        if (positionIndexes.length === 3) {
+            const [a, b, c] = positionIndexes;
+            if (coordinates.length && coordinates[a].length) {
+                p1 = coordinates[a][b][c];
+            }
+        }
+        else {
+            const [b, c] = positionIndexes;
+            if (coordinates.length && coordinates[b].length) {
+                p1 = coordinates[b][c];
+            }
+        }
+        return p1;
+    }
+}

package/dist/mode-handlers/mode-handler.d.ts

@@ -0,0 +1,61 @@
+import { FeatureCollection, Feature, Polygon, Geometry, Position } from '../geojson-types';
+import { ClickEvent, Pick, PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
+import { ImmutableFeatureCollection } from '../edit-modes/immutable-feature-collection';
+export type EditHandleType = 'existing' | 'intermediate' | 'snap';
+export type EditHandle = {
+    position: Position;
+    positionIndexes: number[];
+    featureIndex: number;
+    type: EditHandleType;
+};
+export type EditAction = {
+    updatedData: FeatureCollection;
+    editType: string;
+    featureIndexes: number[];
+    editContext: any;
+};
+export declare class ModeHandler {
+    featureCollection: ImmutableFeatureCollection;
+    _tentativeFeature: Feature | null | undefined;
+    _modeConfig: any;
+    _selectedFeatureIndexes: number[];
+    _clickSequence: Position[];
+    constructor(featureCollection?: FeatureCollection);
+    getFeatureCollection(): FeatureCollection;
+    getImmutableFeatureCollection(): ImmutableFeatureCollection;
+    getSelectedFeature(): Feature | null | undefined;
+    getSelectedGeometry(): Geometry | null | undefined;
+    getSelectedFeaturesAsFeatureCollection(): FeatureCollection;
+    setFeatureCollection(featureCollection: FeatureCollection): void;
+    getModeConfig(): any;
+    setModeConfig(modeConfig: any): void;
+    getSelectedFeatureIndexes(): number[];
+    setSelectedFeatureIndexes(indexes: number[]): void;
+    getClickSequence(): Position[];
+    resetClickSequence(): void;
+    getTentativeFeature(): Feature | null | undefined;
+    _setTentativeFeature(tentativeFeature: Feature | null | undefined): void;
+    /**
+     * Returns a flat array of positions for the given feature along with their indexes into the feature's geometry's coordinates.
+     *
+     * @param featureIndex The index of the feature to get edit handles
+     */
+    getEditHandles(picks?: Array<Record<string, any>>, mapCoords?: Position): EditHandle[];
+    getCursor({ isDragging }: {
+        isDragging: boolean;
+    }): string;
+    isSelectionPicked(picks: Pick[]): boolean;
+    getAddFeatureAction(geometry: Geometry): EditAction;
+    getAddManyFeaturesAction(featureCollection: FeatureCollection): EditAction;
+    getAddFeatureOrBooleanPolygonAction(geometry: Polygon): EditAction | null | undefined;
+    handleClick(event: ClickEvent): EditAction | null | undefined;
+    handlePointerMove(event: PointerMoveEvent): {
+        editAction: EditAction | null | undefined;
+        cancelMapPan: boolean;
+    };
+    handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined;
+    handleStopDragging(event: StopDraggingEvent): EditAction | null | undefined;
+}
+export declare function getPickedEditHandle(picks: any[] | null | undefined): EditHandle | null | undefined;
+export declare function getIntermediatePosition(position1: Position, position2: Position): Position;
+export declare function getEditHandlesForGeometry(geometry: Geometry, featureIndex: number, editHandleType?: EditHandleType): EditHandle[];

package/dist/mode-handlers/mode-handler.js

@@ -0,0 +1,286 @@
+// 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 { ImmutableFeatureCollection } from '../edit-modes/immutable-feature-collection';
+export class ModeHandler {
+    // TODO: add underscore
+    featureCollection = undefined;
+    _tentativeFeature;
+    _modeConfig = null;
+    _selectedFeatureIndexes = [];
+    _clickSequence = [];
+    constructor(featureCollection) {
+        if (featureCollection) {
+            this.setFeatureCollection(featureCollection);
+        }
+    }
+    getFeatureCollection() {
+        return this.featureCollection.getObject();
+    }
+    getImmutableFeatureCollection() {
+        return this.featureCollection;
+    }
+    getSelectedFeature() {
+        if (this._selectedFeatureIndexes.length === 1) {
+            return this.featureCollection.getObject().features[this._selectedFeatureIndexes[0]];
+        }
+        return null;
+    }
+    getSelectedGeometry() {
+        const feature = this.getSelectedFeature();
+        if (feature) {
+            return feature.geometry;
+        }
+        return null;
+    }
+    getSelectedFeaturesAsFeatureCollection() {
+        const { features } = this.featureCollection.getObject();
+        const selectedFeatures = this.getSelectedFeatureIndexes().map((selectedIndex) => features[selectedIndex]);
+        return {
+            type: 'FeatureCollection',
+            features: selectedFeatures,
+        };
+    }
+    setFeatureCollection(featureCollection) {
+        this.featureCollection = new ImmutableFeatureCollection(featureCollection);
+    }
+    getModeConfig() {
+        return this._modeConfig;
+    }
+    setModeConfig(modeConfig) {
+        if (this._modeConfig === modeConfig) {
+            return;
+        }
+        this._modeConfig = modeConfig;
+        this._setTentativeFeature(null);
+    }
+    getSelectedFeatureIndexes() {
+        return this._selectedFeatureIndexes;
+    }
+    setSelectedFeatureIndexes(indexes) {
+        if (this._selectedFeatureIndexes === indexes) {
+            return;
+        }
+        this._selectedFeatureIndexes = indexes;
+        this._setTentativeFeature(null);
+    }
+    getClickSequence() {
+        return this._clickSequence;
+    }
+    resetClickSequence() {
+        this._clickSequence = [];
+    }
+    getTentativeFeature() {
+        return this._tentativeFeature;
+    }
+    // TODO: remove the underscore
+    _setTentativeFeature(tentativeFeature) {
+        this._tentativeFeature = tentativeFeature;
+        if (!tentativeFeature) {
+            // Reset the click sequence
+            this._clickSequence = [];
+        }
+    }
+    /**
+     * Returns a flat array of positions for the given feature along with their indexes into the feature's geometry's coordinates.
+     *
+     * @param featureIndex The index of the feature to get edit handles
+     */
+    getEditHandles(picks, mapCoords) {
+        return [];
+    }
+    getCursor({ isDragging }) {
+        return 'cell';
+    }
+    isSelectionPicked(picks) {
+        if (!picks.length)
+            return false;
+        const pickedIndexes = picks.map(({ index }) => index);
+        const selectedFeatureIndexes = this.getSelectedFeatureIndexes();
+        return selectedFeatureIndexes.some((index) => pickedIndexes.includes(index));
+    }
+    getAddFeatureAction(geometry) {
+        // Unsure why flow can't deal with Geometry type, but there I fixed it
+        const geometryAsAny = geometry;
+        const updatedData = this.getImmutableFeatureCollection()
+            .addFeature({
+            type: 'Feature',
+            properties: {},
+            geometry: geometryAsAny,
+        })
+            .getObject();
+        return {
+            updatedData,
+            editType: 'addFeature',
+            featureIndexes: [updatedData.features.length - 1],
+            editContext: {
+                featureIndexes: [updatedData.features.length - 1],
+            },
+        };
+    }
+    getAddManyFeaturesAction(featureCollection) {
+        const features = featureCollection.features;
+        let updatedData = this.getImmutableFeatureCollection();
+        const initialIndex = updatedData.getObject().features.length;
+        const updatedIndexes = [];
+        for (const feature of features) {
+            const { properties, geometry } = feature;
+            const geometryAsAny = geometry;
+            updatedData = updatedData.addFeature({
+                type: 'Feature',
+                properties,
+                geometry: geometryAsAny,
+            });
+            updatedIndexes.push(initialIndex + updatedIndexes.length);
+        }
+        return {
+            updatedData: updatedData.getObject(),
+            editType: 'addFeature',
+            featureIndexes: updatedIndexes,
+            editContext: {
+                featureIndexes: updatedIndexes,
+            },
+        };
+    }
+    getAddFeatureOrBooleanPolygonAction(geometry) {
+        const selectedFeature = this.getSelectedFeature();
+        const modeConfig = this.getModeConfig();
+        if (modeConfig && modeConfig.booleanOperation) {
+            if (!selectedFeature ||
+                (selectedFeature.geometry.type !== 'Polygon' &&
+                    selectedFeature.geometry.type !== 'MultiPolygon')) {
+                // eslint-disable-next-line no-console,no-undef
+                console.warn('booleanOperation only supported for single Polygon or MultiPolygon selection');
+                return null;
+            }
+            const feature = {
+                type: 'Feature',
+                geometry,
+            };
+            let updatedGeometry;
+            if (modeConfig.booleanOperation === 'union') {
+                // @ts-expect-error turf types diff
+                updatedGeometry = turfUnion(selectedFeature, feature);
+            }
+            else if (modeConfig.booleanOperation === 'difference') {
+                // @ts-expect-error turf type diff
+                updatedGeometry = turfDifference(selectedFeature, feature);
+            }
+            else if (modeConfig.booleanOperation === 'intersection') {
+                // @ts-expect-error turf type diff
+                updatedGeometry = turfIntersect(selectedFeature, feature);
+            }
+            else {
+                // eslint-disable-next-line no-console,no-undef
+                console.warn(`Invalid booleanOperation ${modeConfig.booleanOperation}`);
+                return null;
+            }
+            if (!updatedGeometry) {
+                // eslint-disable-next-line no-console,no-undef
+                console.warn('Canceling edit. Boolean operation erased entire polygon.');
+                return null;
+            }
+            const featureIndex = this.getSelectedFeatureIndexes()[0];
+            const updatedData = this.getImmutableFeatureCollection()
+                .replaceGeometry(featureIndex, updatedGeometry.geometry)
+                .getObject();
+            const editAction = {
+                updatedData,
+                editType: 'unionGeometry',
+                featureIndexes: [featureIndex],
+                editContext: {
+                    featureIndexes: [featureIndex],
+                },
+            };
+            return editAction;
+        }
+        return this.getAddFeatureAction(geometry);
+    }
+    handleClick(event) {
+        this._clickSequence.push(event.mapCoords);
+        return null;
+    }
+    handlePointerMove(event) {
+        return { editAction: null, cancelMapPan: false };
+    }
+    handleStartDragging(event) {
+        return null;
+    }
+    handleStopDragging(event) {
+        return null;
+    }
+}
+export function getPickedEditHandle(picks) {
+    const info = picks && picks.find((pick) => pick.isEditingHandle);
+    if (info) {
+        return info.object;
+    }
+    return null;
+}
+export function getIntermediatePosition(position1, position2) {
+    const intermediatePosition = [
+        (position1[0] + position2[0]) / 2.0,
+        (position1[1] + position2[1]) / 2.0,
+    ];
+    return intermediatePosition;
+}
+export function getEditHandlesForGeometry(geometry, featureIndex, editHandleType = 'existing') {
+    let handles = [];
+    switch (geometry.type) {
+        case 'Point':
+            // positions are not nested
+            handles = [
+                {
+                    position: geometry.coordinates,
+                    positionIndexes: [],
+                    featureIndex,
+                    type: editHandleType,
+                },
+            ];
+            break;
+        case 'MultiPoint':
+        case 'LineString':
+            // positions are nested 1 level
+            handles = handles.concat(getEditHandlesForCoordinates(geometry.coordinates, [], featureIndex, editHandleType));
+            break;
+        case 'Polygon':
+        case 'MultiLineString':
+            // positions are nested 2 levels
+            for (let a = 0; a < geometry.coordinates.length; a++) {
+                handles = handles.concat(getEditHandlesForCoordinates(geometry.coordinates[a], [a], featureIndex, editHandleType));
+                if (geometry.type === 'Polygon') {
+                    // Don't repeat the first/last handle for Polygons
+                    handles = handles.slice(0, -1);
+                }
+            }
+            break;
+        case 'MultiPolygon':
+            // positions are nested 3 levels
+            for (let a = 0; a < geometry.coordinates.length; a++) {
+                for (let b = 0; b < geometry.coordinates[a].length; b++) {
+                    handles = handles.concat(getEditHandlesForCoordinates(geometry.coordinates[a][b], [a, b], featureIndex, editHandleType));
+                    // Don't repeat the first/last handle for Polygons
+                    handles = handles.slice(0, -1);
+                }
+            }
+            break;
+        default:
+            // @ts-expect-error unexpected case
+            throw Error(`Unhandled geometry type: ${geometry.type}`);
+    }
+    return handles;
+}
+function getEditHandlesForCoordinates(coordinates, positionIndexPrefix, featureIndex, editHandleType = 'existing') {
+    const editHandles = [];
+    for (let i = 0; i < coordinates.length; i++) {
+        const position = coordinates[i];
+        editHandles.push({
+            position,
+            positionIndexes: [...positionIndexPrefix, i],
+            featureIndex,
+            type: editHandleType,
+        });
+    }
+    return editHandles;
+}

package/dist/mode-handlers/modify-handler.d.ts

@@ -0,0 +1,19 @@
+import { Position, FeatureOf, Point, LineString } from '../geojson-types';
+import { NearestPointType } from '../utils';
+import { ClickEvent, PointerMoveEvent, StartDraggingEvent, StopDraggingEvent } from '../edit-modes/types';
+import { EditAction, EditHandle, ModeHandler } from './mode-handler';
+export declare class ModifyHandler extends ModeHandler {
+    _lastPointerMovePicks: any;
+    getEditHandles(picks?: Array<Record<string, any>>, mapCoords?: Position): EditHandle[];
+    nearestPointOnLine(line: FeatureOf<LineString>, inPoint: FeatureOf<Point>): NearestPointType;
+    handleClick(event: ClickEvent): EditAction | null | undefined;
+    handlePointerMove(event: PointerMoveEvent): {
+        editAction: EditAction | null | undefined;
+        cancelMapPan: boolean;
+    };
+    handleStartDragging(event: StartDraggingEvent): EditAction | null | undefined;
+    handleStopDragging(event: StopDraggingEvent): EditAction | null | undefined;
+    getCursor({ isDragging }: {
+        isDragging: boolean;
+    }): string;
+}