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

package/dist/edit-modes/duplicate-mode.d.ts

@@ -0,0 +1,7 @@
+import { StartDraggingEvent, ModeProps } from './types';
+import { FeatureCollection } from '../geojson-types';
+import { TranslateMode } from './translate-mode';
+export declare class DuplicateMode extends TranslateMode {
+    handleStartDragging(event: StartDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    updateCursor(props: ModeProps<FeatureCollection>): void;
+}

package/dist/edit-modes/duplicate-mode.js

@@ -0,0 +1,17 @@
+import { TranslateMode } from './translate-mode';
+export class DuplicateMode extends TranslateMode {
+    handleStartDragging(event, props) {
+        super.handleStartDragging(event, props);
+        if (this._geometryBeforeTranslate) {
+            props.onEdit(this.getAddManyFeaturesAction(this._geometryBeforeTranslate, props.data));
+        }
+    }
+    updateCursor(props) {
+        if (this._isTranslatable) {
+            props.onUpdateCursor('copy');
+        }
+        else {
+            props.onUpdateCursor(null);
+        }
+    }
+}

package/dist/edit-modes/edit-mode.d.ts

@@ -0,0 +1,11 @@
+import { ClickEvent, PointerMoveEvent, StartDraggingEvent, StopDraggingEvent, DraggingEvent, Tooltip, ModeProps } from './types';
+export interface EditMode<TData, TGuides> {
+    handleClick(event: ClickEvent, props: ModeProps<TData>): void;
+    handlePointerMove(event: PointerMoveEvent, props: ModeProps<TData>): void;
+    handleStartDragging(event: StartDraggingEvent, props: ModeProps<TData>): void;
+    handleStopDragging(event: StopDraggingEvent, props: ModeProps<TData>): void;
+    handleDragging(event: DraggingEvent, props: ModeProps<TData>): void;
+    handleKeyUp(event: KeyboardEvent, props: ModeProps<TData>): void;
+    getGuides(props: ModeProps<TData>): TGuides | undefined;
+    getTooltips(props: ModeProps<TData>): Tooltip[];
+}

package/dist/edit-modes/edit-mode.js

@@ -0,0 +1,2 @@
+/* istanbul ignore file */
+export {};

package/dist/edit-modes/elevation-mode.d.ts

@@ -0,0 +1,13 @@
+import { ModeProps, PointerMoveEvent, StopDraggingEvent } from './types';
+import { Position, FeatureCollection } from '../geojson-types';
+import { ModifyMode } from './modify-mode';
+export declare class ElevationMode extends ModifyMode {
+    makeElevatedEvent(event: PointerMoveEvent | StopDraggingEvent, position: Position, props: ModeProps<FeatureCollection>): Record<string, any>;
+    handlePointerMove(event: PointerMoveEvent, props: ModeProps<FeatureCollection>): void;
+    handleStopDragging(event: StopDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    getCursor(event: PointerMoveEvent): string | null | undefined;
+    static calculateElevationChangeWithViewport(viewport: any, { pointerDownScreenCoords, screenCoords, }: {
+        pointerDownScreenCoords: Position;
+        screenCoords: Position;
+    }): number;
+}

package/dist/edit-modes/elevation-mode.js

@@ -0,0 +1,49 @@
+import { getPickedEditHandle } from './utils';
+import { ModifyMode } from './modify-mode';
+function defaultCalculateElevationChange({ pointerDownScreenCoords, screenCoords, }) {
+    return 10 * (pointerDownScreenCoords[1] - screenCoords[1]);
+}
+export class ElevationMode extends ModifyMode {
+    makeElevatedEvent(event, position, props) {
+        const { minElevation = 0, maxElevation = 20000, calculateElevationChange = defaultCalculateElevationChange, } = props.modeConfig || {};
+        if (!event.pointerDownScreenCoords) {
+            return event;
+        }
+        // $FlowFixMe - really, I know it has something at index 2
+        let elevation = position.length === 3 ? position[2] : 0;
+        // calculateElevationChange is configurable because (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, props) {
+        const editHandle = getPickedEditHandle(event.pointerDownPicks);
+        const position = editHandle ? editHandle.geometry.coordinates : event.mapCoords;
+        // @ts-expect-error return type too wide
+        super.handlePointerMove(this.makeElevatedEvent(event, position, props), props);
+    }
+    handleStopDragging(event, props) {
+        const editHandle = getPickedEditHandle(event.picks);
+        const position = editHandle ? editHandle.geometry.coordinates : event.mapCoords;
+        // @ts-expect-error return type too wide
+        super.handleStopDragging(this.makeElevatedEvent(event, position, props), props);
+    }
+    getCursor(event) {
+        let cursor = super.getCursor(event);
+        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/edit-modes/extend-line-string-mode.d.ts

@@ -0,0 +1,9 @@
+import { LineString, FeatureCollection } from '../geojson-types';
+import { ClickEvent, PointerMoveEvent, ModeProps, GuideFeatureCollection } from './types';
+import { GeoJsonEditMode } from './geojson-edit-mode';
+export declare class ExtendLineStringMode extends GeoJsonEditMode {
+    getSingleSelectedLineString(props: ModeProps<FeatureCollection>): LineString | null | undefined;
+    handleClick(event: ClickEvent, props: ModeProps<FeatureCollection>): void;
+    getGuides(props: ModeProps<FeatureCollection>): GuideFeatureCollection;
+    handlePointerMove(event: PointerMoveEvent, props: ModeProps<FeatureCollection>): void;
+}

package/dist/edit-modes/extend-line-string-mode.js

@@ -0,0 +1,72 @@
+import { GeoJsonEditMode } from './geojson-edit-mode';
+import { ImmutableFeatureCollection } from './immutable-feature-collection';
+export class ExtendLineStringMode extends GeoJsonEditMode {
+    getSingleSelectedLineString(props) {
+        const selectedGeometry = this.getSelectedGeometry(props);
+        if (selectedGeometry && selectedGeometry.type === 'LineString') {
+            return selectedGeometry;
+        }
+        return null;
+    }
+    handleClick(event, props) {
+        const { selectedIndexes } = props;
+        const selectedLineString = this.getSingleSelectedLineString(props);
+        if (!selectedLineString) {
+            console.warn(`ExtendLineStringMode only supported for single LineString selection`); // eslint-disable-line
+            return;
+        }
+        // Extend the LineString
+        let positionIndexes = [selectedLineString.coordinates.length];
+        const modeConfig = props.modeConfig;
+        if (modeConfig && modeConfig.drawAtFront) {
+            positionIndexes = [0];
+        }
+        const featureIndex = selectedIndexes[0];
+        const updatedData = new ImmutableFeatureCollection(props.data)
+            .addPosition(featureIndex, positionIndexes, event.mapCoords)
+            .getObject();
+        props.onEdit({
+            updatedData,
+            editType: 'addPosition',
+            editContext: {
+                featureIndexes: [featureIndex],
+                positionIndexes,
+                position: event.mapCoords,
+            },
+        });
+    }
+    getGuides(props) {
+        const guides = {
+            type: 'FeatureCollection',
+            features: [],
+        };
+        const selectedLineString = this.getSingleSelectedLineString(props);
+        if (!selectedLineString) {
+            return guides;
+        }
+        const mapCoords = props.lastPointerMoveEvent && props.lastPointerMoveEvent.mapCoords;
+        // Draw an extension line starting from one end of the selected LineString to the cursor
+        let startPosition = null;
+        const { modeConfig } = props;
+        if (modeConfig && modeConfig.drawAtFront) {
+            startPosition = selectedLineString.coordinates[0];
+        }
+        else {
+            startPosition = selectedLineString.coordinates[selectedLineString.coordinates.length - 1];
+        }
+        guides.features.push({
+            type: 'Feature',
+            properties: {
+                guideType: 'tentative',
+            },
+            geometry: {
+                type: 'LineString',
+                coordinates: [startPosition, mapCoords],
+            },
+        });
+        return guides;
+    }
+    handlePointerMove(event, props) {
+        props.onUpdateCursor('cell');
+    }
+}

package/dist/edit-modes/extrude-mode.d.ts

@@ -0,0 +1,15 @@
+import { FeatureCollection } from '../geojson-types';
+import { ModeProps, StartDraggingEvent, StopDraggingEvent, DraggingEvent } from './types';
+import { ModifyMode } from './modify-mode';
+export declare class ExtrudeMode extends ModifyMode {
+    isPointAdded: boolean;
+    handleDragging(event: DraggingEvent, props: ModeProps<FeatureCollection>): void;
+    handleStartDragging(event: StartDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    handleStopDragging(event: StopDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    coordinatesSize(positionIndexes: number[] | null | undefined, featureIndex: number, { features }: FeatureCollection): number;
+    getBearing(p1: any, p2: any): number;
+    isOrthogonal(positionIndexes: number[] | null | undefined, featureIndex: number, size: number, features: FeatureCollection): boolean;
+    nextPositionIndexes(positionIndexes: number[] | null | undefined, size: number): number[];
+    prevPositionIndexes(positionIndexes: number[] | null | undefined, size: number): number[];
+    getPointForPositionIndexes(positionIndexes: number[] | null | undefined, featureIndex: number, { features }: FeatureCollection): any;
+}

package/dist/edit-modes/extrude-mode.js

@@ -0,0 +1,186 @@
+import bearing from '@turf/bearing';
+import { generatePointsParallelToLinePoints, getPickedEditHandle, getPickedIntermediateEditHandle, } from './utils';
+import { ModifyMode } from './modify-mode';
+import { ImmutableFeatureCollection } from './immutable-feature-collection';
+export class ExtrudeMode extends ModifyMode {
+    // this mode is busted =(
+    isPointAdded = false;
+    handleDragging(event, props) {
+        const editHandle = getPickedEditHandle(event.pointerDownPicks);
+        if (editHandle) {
+            const { featureIndex } = editHandle.properties;
+            let { positionIndexes } = editHandle.properties;
+            const size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+            positionIndexes = this.isPointAdded
+                ? this.nextPositionIndexes(positionIndexes, size)
+                : positionIndexes;
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+            const p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
+            if (p1 && p2) {
+                // p3 and p4 are end points for moving (extruding) edge
+                const [p3, p4] = generatePointsParallelToLinePoints(p1, p2, event.mapCoords);
+                const updatedData = new ImmutableFeatureCollection(props.data)
+                    .replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size), p4)
+                    .replacePosition(featureIndex, positionIndexes, p3)
+                    .getObject();
+                props.onEdit({
+                    updatedData,
+                    editType: 'extruding',
+                    editContext: {
+                        featureIndexes: [featureIndex],
+                        positionIndexes: this.nextPositionIndexes(positionIndexes, size),
+                        position: p3,
+                    },
+                });
+                event.cancelPan();
+            }
+        }
+    }
+    handleStartDragging(event, props) {
+        const selectedFeatureIndexes = props.selectedIndexes;
+        const editHandle = getPickedIntermediateEditHandle(event.picks);
+        if (selectedFeatureIndexes.length && editHandle) {
+            const { positionIndexes, featureIndex } = editHandle.properties;
+            const size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+            const p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
+            if (p1 && p2) {
+                let updatedData = new ImmutableFeatureCollection(props.data);
+                if (!this.isOrthogonal(positionIndexes, featureIndex, size, props.data)) {
+                    updatedData = updatedData.addPosition(featureIndex, positionIndexes, p2);
+                }
+                if (!this.isOrthogonal(this.prevPositionIndexes(positionIndexes, size), featureIndex, size, props.data)) {
+                    updatedData = updatedData.addPosition(featureIndex, positionIndexes, p1);
+                    this.isPointAdded = true;
+                }
+                props.onEdit({
+                    updatedData: updatedData.getObject(),
+                    editType: 'startExtruding',
+                    editContext: {
+                        featureIndexes: [featureIndex],
+                        positionIndexes,
+                        position: p1,
+                    },
+                });
+            }
+        }
+    }
+    handleStopDragging(event, props) {
+        const selectedFeatureIndexes = props.selectedIndexes;
+        const editHandle = getPickedEditHandle(event.pointerDownPicks);
+        if (selectedFeatureIndexes.length && editHandle) {
+            const { featureIndex } = editHandle.properties;
+            let { positionIndexes } = editHandle.properties;
+            const size = this.coordinatesSize(positionIndexes, featureIndex, props.data);
+            positionIndexes = this.isPointAdded
+                ? this.nextPositionIndexes(positionIndexes, size)
+                : positionIndexes;
+            // p1 and p1 are end points for edge
+            const p1 = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, props.data);
+            const p2 = this.getPointForPositionIndexes(positionIndexes, featureIndex, props.data);
+            if (p1 && p2) {
+                // p3 and p4 are end points for new moved (extruded) edge
+                const [p3, p4] = generatePointsParallelToLinePoints(p1, p2, event.mapCoords);
+                const updatedData = new ImmutableFeatureCollection(props.data)
+                    .replacePosition(featureIndex, this.prevPositionIndexes(positionIndexes, size), p4)
+                    .replacePosition(featureIndex, positionIndexes, p3)
+                    .getObject();
+                props.onEdit({
+                    updatedData,
+                    editType: 'extruded',
+                    editContext: {
+                        featureIndexes: [featureIndex],
+                        positionIndexes,
+                        position: p3,
+                    },
+                });
+            }
+        }
+        this.isPointAdded = false;
+    }
+    coordinatesSize(positionIndexes, featureIndex, { features }) {
+        let size = 0;
+        if (Array.isArray(positionIndexes)) {
+            const feature = 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, features) {
+        if (!Array.isArray(positionIndexes)) {
+            return false;
+        }
+        if (positionIndexes[positionIndexes.length - 1] === size - 1) {
+            positionIndexes[positionIndexes.length - 1] = 0;
+        }
+        const prevPoint = this.getPointForPositionIndexes(this.prevPositionIndexes(positionIndexes, size), featureIndex, features);
+        const nextPoint = this.getPointForPositionIndexes(this.nextPositionIndexes(positionIndexes, size), featureIndex, features);
+        const currentPoint = this.getPointForPositionIndexes(positionIndexes, featureIndex, features);
+        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) {
+        if (!Array.isArray(positionIndexes)) {
+            return [];
+        }
+        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) {
+        if (!Array.isArray(positionIndexes)) {
+            return [];
+        }
+        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, { features }) {
+        let p1;
+        if (Array.isArray(positionIndexes)) {
+            const feature = 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/edit-modes/geojson-edit-mode.d.ts

@@ -0,0 +1,33 @@
+import { EditAction, ClickEvent, PointerMoveEvent, StartDraggingEvent, StopDraggingEvent, DraggingEvent, Pick, Tooltip, ModeProps, GuideFeatureCollection, TentativeFeature } from './types';
+import { FeatureCollection, Feature, Polygon, Geometry, Position } from '../geojson-types';
+import { EditMode } from './edit-mode';
+export type GeoJsonEditAction = EditAction<FeatureCollection>;
+export type GeoJsonEditModeType = EditMode<FeatureCollection, FeatureCollection>;
+export interface GeoJsonEditModeConstructor {
+    new (): GeoJsonEditModeType;
+}
+export declare class GeoJsonEditMode implements EditMode<FeatureCollection, GuideFeatureCollection> {
+    _clickSequence: Position[];
+    getGuides(props: ModeProps<FeatureCollection>): GuideFeatureCollection;
+    getTooltips(props: ModeProps<FeatureCollection>): Tooltip[];
+    getSelectedFeature(props: ModeProps<FeatureCollection>): Feature | null | undefined;
+    getSelectedGeometry(props: ModeProps<FeatureCollection>): Geometry | null | undefined;
+    getSelectedFeaturesAsFeatureCollection(props: ModeProps<FeatureCollection>): FeatureCollection;
+    getClickSequence(): Position[];
+    addClickSequence({ mapCoords }: ClickEvent): void;
+    resetClickSequence(): void;
+    getTentativeGuide(props: ModeProps<FeatureCollection>): TentativeFeature | null | undefined;
+    isSelectionPicked(picks: Pick[], props: ModeProps<FeatureCollection>): boolean;
+    rewindPolygon(feature: Feature): Feature;
+    getAddFeatureAction(featureOrGeometry: Geometry | Feature, features: FeatureCollection): GeoJsonEditAction;
+    getAddManyFeaturesAction({ features: featuresToAdd }: FeatureCollection, features: FeatureCollection): GeoJsonEditAction;
+    getAddFeatureOrBooleanPolygonAction(featureOrGeometry: Polygon | Feature, props: ModeProps<FeatureCollection>): GeoJsonEditAction | null | undefined;
+    createTentativeFeature(props: ModeProps<FeatureCollection>): TentativeFeature | null;
+    handleClick(event: ClickEvent, props: ModeProps<FeatureCollection>): void;
+    handlePointerMove(event: PointerMoveEvent, props: ModeProps<FeatureCollection>): void;
+    handleStartDragging(event: StartDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    handleStopDragging(event: StopDraggingEvent, props: ModeProps<FeatureCollection>): void;
+    handleDragging(event: DraggingEvent, props: ModeProps<FeatureCollection>): void;
+    handleKeyUp(event: KeyboardEvent, props: ModeProps<FeatureCollection>): void;
+}
+export declare function getIntermediatePosition(position1: Position, position2: Position): Position;

package/dist/edit-modes/geojson-edit-mode.js

@@ -0,0 +1,208 @@
+import turfUnion from '@turf/union';
+import turfDifference from '@turf/difference';
+import turfIntersect from '@turf/intersect';
+import rewind from '@turf/rewind';
+import { getPickedEditHandles, getNonGuidePicks } from './utils';
+import { ImmutableFeatureCollection } from './immutable-feature-collection';
+const DEFAULT_GUIDES = {
+    type: 'FeatureCollection',
+    features: [],
+};
+const DEFAULT_TOOLTIPS = [];
+export class GeoJsonEditMode {
+    _clickSequence = [];
+    getGuides(props) {
+        return DEFAULT_GUIDES;
+    }
+    getTooltips(props) {
+        return DEFAULT_TOOLTIPS;
+    }
+    getSelectedFeature(props) {
+        if (props.selectedIndexes.length === 1) {
+            return props.data.features[props.selectedIndexes[0]];
+        }
+        return null;
+    }
+    getSelectedGeometry(props) {
+        const feature = this.getSelectedFeature(props);
+        if (feature) {
+            return feature.geometry;
+        }
+        return null;
+    }
+    getSelectedFeaturesAsFeatureCollection(props) {
+        const { features } = props.data;
+        const selectedFeatures = props.selectedIndexes.map((selectedIndex) => features[selectedIndex]);
+        return {
+            type: 'FeatureCollection',
+            features: selectedFeatures,
+        };
+    }
+    getClickSequence() {
+        return this._clickSequence;
+    }
+    addClickSequence({ mapCoords }) {
+        this._clickSequence.push(mapCoords);
+    }
+    resetClickSequence() {
+        this._clickSequence = [];
+    }
+    getTentativeGuide(props) {
+        const guides = this.getGuides(props);
+        return guides.features.find((f) => f.properties && f.properties.guideType === 'tentative');
+    }
+    isSelectionPicked(picks, props) {
+        if (!picks.length)
+            return false;
+        const pickedFeatures = getNonGuidePicks(picks).map(({ index }) => index);
+        const pickedHandles = getPickedEditHandles(picks).map(({ properties }) => properties.featureIndex);
+        const pickedIndexes = new Set([...pickedFeatures, ...pickedHandles]);
+        return props.selectedIndexes.some((index) => pickedIndexes.has(index));
+    }
+    rewindPolygon(feature) {
+        const { geometry } = feature;
+        const isPolygonal = geometry.type === 'Polygon' || geometry.type === 'MultiPolygon';
+        if (isPolygonal) {
+            // @ts-expect-error turf type too wide
+            return rewind(feature);
+        }
+        return feature;
+    }
+    getAddFeatureAction(featureOrGeometry, features) {
+        // Unsure why flow can't deal with Geometry type, but there I fixed it
+        const featureOrGeometryAsAny = featureOrGeometry;
+        const feature = featureOrGeometryAsAny.type === 'Feature'
+            ? featureOrGeometryAsAny
+            : {
+                type: 'Feature',
+                properties: {},
+                geometry: featureOrGeometryAsAny,
+            };
+        const rewindFeature = this.rewindPolygon(feature);
+        const updatedData = new ImmutableFeatureCollection(features)
+            .addFeature(rewindFeature)
+            .getObject();
+        return {
+            updatedData,
+            editType: 'addFeature',
+            editContext: {
+                featureIndexes: [updatedData.features.length - 1],
+            },
+        };
+    }
+    getAddManyFeaturesAction({ features: featuresToAdd }, features) {
+        let updatedData = new ImmutableFeatureCollection(features);
+        const initialIndex = updatedData.getObject().features.length;
+        const updatedIndexes = [];
+        for (const feature of featuresToAdd) {
+            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',
+            editContext: {
+                featureIndexes: updatedIndexes,
+            },
+        };
+    }
+    getAddFeatureOrBooleanPolygonAction(featureOrGeometry, props) {
+        const featureOrGeometryAsAny = featureOrGeometry;
+        const selectedFeature = this.getSelectedFeature(props);
+        const { modeConfig } = props;
+        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 = featureOrGeometryAsAny.type === 'Feature'
+                ? featureOrGeometryAsAny
+                : {
+                    type: 'Feature',
+                    geometry: featureOrGeometryAsAny,
+                };
+            let updatedGeometry;
+            if (modeConfig.booleanOperation === 'union') {
+                // @ts-expect-error selectedFeature type too wide
+                updatedGeometry = turfUnion(selectedFeature, feature);
+            }
+            else if (modeConfig.booleanOperation === 'difference') {
+                // @ts-expect-error selectedFeature type too wide
+                updatedGeometry = turfDifference(selectedFeature, feature);
+            }
+            else if (modeConfig.booleanOperation === 'intersection') {
+                // @ts-expect-error selectedFeature type too wide
+                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 = props.selectedIndexes[0];
+            const updatedData = new ImmutableFeatureCollection(props.data)
+                .replaceGeometry(featureIndex, updatedGeometry.geometry)
+                .getObject();
+            const editAction = {
+                updatedData,
+                editType: 'unionGeometry',
+                editContext: {
+                    featureIndexes: [featureIndex],
+                },
+            };
+            return editAction;
+        }
+        return this.getAddFeatureAction(featureOrGeometry, props.data);
+    }
+    createTentativeFeature(props) {
+        return null;
+    }
+    handleClick(event, props) { }
+    handlePointerMove(event, props) {
+        const tentativeFeature = this.createTentativeFeature(props);
+        if (tentativeFeature) {
+            props.onEdit({
+                updatedData: props.data,
+                editType: 'updateTentativeFeature',
+                editContext: {
+                    feature: tentativeFeature,
+                },
+            });
+        }
+    }
+    handleStartDragging(event, props) { }
+    handleStopDragging(event, props) { }
+    handleDragging(event, props) { }
+    handleKeyUp(event, props) {
+        if (event.key === 'Escape') {
+            this.resetClickSequence();
+            props.onEdit({
+                // Because the new drawing feature is dropped, so the data will keep as the same.
+                updatedData: props.data,
+                editType: 'cancelFeature',
+                editContext: {},
+            });
+        }
+    }
+}
+export function getIntermediatePosition(position1, position2) {
+    const intermediatePosition = [
+        (position1[0] + position2[0]) / 2.0,
+        (position1[1] + position2[1]) / 2.0,
+    ];
+    return intermediatePosition;
+}