terra-draw 1.0.0 → 1.2.0

package/README.md

@@ -1,7 +1,36 @@
-# Terra Draw
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./assets/logo-dark-mode.png">
+  <source media="(prefers-color-scheme: light)" srcset="./assets/logo.png">
+  <img alt="Terra Draw logo" src="./assets/logo.png" width="400px">
+</picture>
 
-This package is the core package for Terra Draw. You can read more context about what Terra Draw is in [the root level README](../../README.md) and more information on how to get started in the [GUIDES section of the Terra Draw monorepo](../../guides/1.GETTING_STARTED.md).
+<p></p>
 
-## License 
+![Terra Draw CI Badge](https://github.com/JamesLMilner/terra-draw/actions/workflows/ci.yml/badge.svg)
+[![npm version](https://badge.fury.io/js/terra-draw.svg)](https://badge.fury.io/js/terra-draw)
 
-[MIT](../../LICENSE)
+Frictionless map drawing across mapping libraries.
+
+Terra Draw centralizes map drawing logic and provides a host of out-of-the-box drawing modes that work across different JavaScript mapping libraries. It also allows you to bring your own modes!
+
+### Supported Mapping Libraries
+
+Terra Draw works with your mapping library of choice via adapters. Please pick the adapter for the mapping library you are working with:
+
+* [terra-draw-maplibre-gl-js-adapter](https://www.npmjs.com/package/terra-draw-maplibre-gl-js-adapter)
+* [terra-draw-leaflet-adapter](https://www.npmjs.com/package/terra-draw-leaflet-adapter)
+* [terra-draw-google-maps-adapter](https://www.npmjs.com/package/terra-draw-googl-emaps-adapter)
+* [terra-draw-mapbox-gl-js-adapter](https://www.npmjs.com/package/terra-draw-mapbox-gl-js-adapter)
+* [terra-draw-google-maps-adapter](https://www.npmjs.com/package/terra-draw-google-maps-adapter)
+* [terra-draw-arcgis-adapter](https://www.npmjs.com/package/terra-draw-arcgis-adapter)
+
+### Getting Started
+
+* [Getting started guide](https://github.com/JamesLMilner/terra-draw/blob/main/guides/1.GETTING_STARTED.md)
+* [API Docs](https://terradraw.io/#/api)
+* [Repository](https://www.github.com/JamesLMilner/terra-draw)
+* [Website](https://www.terradraw.io)
+
+### License
+
+MIT

package/dist/common.d.ts

@@ -114,6 +114,7 @@ export declare const SELECT_PROPERTIES: {
     readonly SELECTION_POINT: "selectionPoint";
 };
 export declare const COMMON_PROPERTIES: {
+    EDITED: string;
     CLOSING_POINT: string;
     SNAPPING_POINT: string;
 };

package/dist/geometry/boolean/right-hand-rule.d.ts

@@ -0,0 +1,7 @@
+import { Polygon } from "geojson";
+/**
+ * Checks if a GeoJSON Polygon follows the right-hand rule.
+ * @param polygon - The GeoJSON Polygon to check.
+ * @returns {boolean} - True if the polygon follows the right-hand rule (counterclockwise outer ring), otherwise false.
+ */
+export declare function followsRightHandRule(polygon: Polygon): boolean;

package/dist/geometry/boolean/right-hand-rule.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/geometry/ensure-right-hand-rule.d.ts

@@ -0,0 +1,2 @@
+import { Polygon } from "geojson";
+export declare function ensureRightHandRule(polygon: Polygon): undefined | Polygon;

package/dist/geometry/ensure-right-hand-rule.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/geometry/point-on-line.d.ts

@@ -2,4 +2,5 @@ import { Position } from "geojson";
 export declare function nearestPointOnLine(inputCoordinate: Position, lines: [Position, Position][]): {
     coordinate: Position;
     distance: number;
+    lineIndex: number;
 } | undefined;

package/dist/geometry/web-mercator-point-on-line.d.ts

@@ -7,5 +7,6 @@ import { Position } from "geojson";
  */
 export declare function webMercatorNearestPointOnLine(inputCoordinate: Position, lines: [Position, Position][]): {
     coordinate: Position;
+    lineIndex: number;
     distance: number;
 } | undefined;

package/dist/modes/angled-rectangle/angled-rectangle.mode.d.ts

@@ -21,13 +21,14 @@ interface TerraDrawPolygonModeOptions<T extends CustomStyling> extends BaseModeO
     cursors?: Cursors;
 }
 export declare class TerraDrawAngledRectangleMode extends TerraDrawBaseDrawMode<PolygonStyling> {
-    mode: string;
+    mode: "angled-rectangle";
     private currentCoordinate;
     private currentId;
     private keyEvents;
     private cursors;
     private mouseMove;
     constructor(options?: TerraDrawPolygonModeOptions<PolygonStyling>);
+    updateOptions(options?: TerraDrawPolygonModeOptions<PolygonStyling>): void;
     private close;
     /** @internal */
     start(): void;

package/dist/modes/base.mode.d.ts

@@ -8,32 +8,33 @@ export declare enum ModeTypes {
     Static = "static",
     Render = "render"
 }
-export type BaseModeOptions<T extends CustomStyling> = {
-    styles?: Partial<T>;
+export type BaseModeOptions<Styling extends CustomStyling> = {
+    styles?: Partial<Styling>;
     pointerDistance?: number;
     validation?: Validation;
     projection?: Projection;
 };
-export declare abstract class TerraDrawBaseDrawMode<T extends CustomStyling> {
+export declare abstract class TerraDrawBaseDrawMode<Styling extends CustomStyling> {
     protected _state: TerraDrawModeState;
     get state(): TerraDrawModeState;
     set state(_: TerraDrawModeState);
-    protected _styles: Partial<T>;
-    get styles(): Partial<T>;
-    set styles(styling: Partial<T>);
+    protected _styles: Partial<Styling>;
+    get styles(): Partial<Styling>;
+    set styles(styling: Partial<Styling>);
     protected behaviors: TerraDrawModeBehavior[];
     protected validate: Validation | undefined;
     protected pointerDistance: number;
     protected coordinatePrecision: number;
     protected onStyleChange: StoreChangeHandler;
     protected store: GeoJSONStore;
+    protected projection: Projection;
     protected setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
     protected unproject: TerraDrawModeRegisterConfig["unproject"];
     protected project: TerraDrawModeRegisterConfig["project"];
     protected setCursor: TerraDrawModeRegisterConfig["setCursor"];
     protected registerBehaviors(behaviorConfig: BehaviorConfig): void;
-    protected projection: Projection;
-    constructor(options?: BaseModeOptions<T>);
+    constructor(options?: BaseModeOptions<Styling>, willCallUpdateOptionsInParentClass?: boolean);
+    updateOptions(options?: BaseModeOptions<Styling>): void;
     type: ModeTypes;
     mode: string;
     protected setDrawing(): void;
@@ -61,7 +62,7 @@ export declare abstract class TerraDrawBaseDrawMode<T extends CustomStyling> {
     protected getNumericStylingValue(value: number | ((feature: GeoJSONStoreFeatures) => number) | undefined, defaultValue: number, feature: GeoJSONStoreFeatures): number;
     private getStylingValue;
 }
-export declare abstract class TerraDrawBaseSelectMode<T extends CustomStyling> extends TerraDrawBaseDrawMode<T> {
+export declare abstract class TerraDrawBaseSelectMode<Styling extends CustomStyling> extends TerraDrawBaseDrawMode<Styling> {
     type: ModeTypes;
     abstract selectFeature(featureId: FeatureId): void;
     abstract deselectFeature(featureId: FeatureId): void;

package/dist/modes/circle/circle.mode.d.ts

@@ -21,7 +21,7 @@ interface TerraDrawCircleModeOptions<T extends CustomStyling> extends BaseModeOp
     projection?: Projection;
 }
 export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode<CirclePolygonStyling> {
-    mode: string;
+    mode: "circle";
     private center;
     private clickCount;
     private currentCircleId;
@@ -38,6 +38,7 @@ export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode<CirclePol
      * @param options.pointerDistance - Distance in pixels to consider a pointer close to a vertex
      */
     constructor(options?: TerraDrawCircleModeOptions<CirclePolygonStyling>);
+    updateOptions(options?: TerraDrawCircleModeOptions<CirclePolygonStyling>): void;
     private close;
     /** @internal */
     start(): void;

package/dist/modes/coordinate-snapping.behavior.d.ts

@@ -1,6 +1,6 @@
 import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
 import { TerraDrawMouseEvent } from "../common";
-import { Position } from "geojson";
+import { Feature, Position } from "geojson";
 import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
 import { FeatureId } from "../store/store";
 import { PixelDistanceBehavior } from "./pixel-distance.behavior";
@@ -12,5 +12,10 @@ export declare class CoordinateSnappingBehavior extends TerraDrawModeBehavior {
     /** Returns the nearest snappable coordinate - on first click there is no currentId so no need to provide */
     getSnappableCoordinateFirstClick: (event: TerraDrawMouseEvent) => Position | undefined;
     getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId: FeatureId) => Position | undefined;
-    private getSnappable;
+    getSnappable(event: TerraDrawMouseEvent, filter?: (feature: Feature) => boolean): {
+        coordinate: undefined | Position;
+        minDist: number;
+        featureId: undefined | FeatureId;
+        featureCoordinateIndex: undefined | number;
+    };
 }

package/dist/modes/freehand/freehand.mode.d.ts

@@ -28,7 +28,7 @@ interface TerraDrawFreehandModeOptions<T extends CustomStyling> extends BaseMode
     cursors?: Cursors;
 }
 export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode<FreehandPolygonStyling> {
-    mode: string;
+    mode: "freehand";
     private startingClick;
     private currentId;
     private closingPointId;
@@ -41,6 +41,7 @@ export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode<Freehan
     private hasLeftStartingPoint;
     private preventNewFeature;
     constructor(options?: TerraDrawFreehandModeOptions<FreehandPolygonStyling>);
+    updateOptions(options?: TerraDrawFreehandModeOptions<FreehandPolygonStyling> | undefined): void;
     private close;
     /** @internal */
     start(): void;

package/dist/modes/line-snapping.behavior.d.ts

@@ -1,6 +1,6 @@
 import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
 import { TerraDrawMouseEvent } from "../common";
-import { Position } from "geojson";
+import { Feature, Position } from "geojson";
 import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
 import { FeatureId } from "../store/store";
 import { PixelDistanceBehavior } from "./pixel-distance.behavior";
@@ -12,5 +12,10 @@ export declare class LineSnappingBehavior extends TerraDrawModeBehavior {
     /** Returns the nearest snappable coordinate - on first click there is no currentId so no need to provide */
     getSnappableCoordinateFirstClick: (event: TerraDrawMouseEvent) => Position | undefined;
     getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId: FeatureId) => Position | undefined;
-    private getSnappable;
+    getSnappable(event: TerraDrawMouseEvent, filter?: (feature: Feature) => boolean): {
+        coordinate: undefined | Position;
+        minDistance: number;
+        featureId: undefined | FeatureId;
+        featureCoordinateIndex: undefined | number;
+    };
 }

package/dist/modes/linestring/linestring.mode.d.ts

@@ -22,6 +22,8 @@ type LineStringStyling = {
 interface Cursors {
     start?: Cursor;
     close?: Cursor;
+    dragStart?: Cursor;
+    dragEnd?: Cursor;
 }
 interface InertCoordinates {
     strategy: "amount";
@@ -37,9 +39,10 @@ interface TerraDrawLineStringModeOptions<T extends CustomStyling> extends BaseMo
     keyEvents?: TerraDrawLineStringModeKeyEvents | null;
     cursors?: Cursors;
     insertCoordinates?: InertCoordinates;
+    editable?: boolean;
 }
 export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineStringStyling> {
-    mode: string;
+    mode: "linestring";
     private currentCoordinate;
     private currentId;
     private closingPointId;
@@ -50,9 +53,19 @@ export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineS
     private insertCoordinates;
     private lastCommitedCoordinates;
     private snappedPointId;
+    private editable;
+    private editedFeatureId;
+    private editedFeatureCoordinateIndex;
+    private editedSnapType;
+    private editedInsertIndex;
+    private editedPointId;
     private coordinateSnapping;
     private insertPoint;
+    private lineSnapping;
+    private pixelDistance;
+    private clickBoundingBox;
     constructor(options?: TerraDrawLineStringModeOptions<LineStringStyling>);
+    updateOptions(options?: TerraDrawLineStringModeOptions<LineStringStyling> | undefined): void;
     private close;
     private updateGeometries;
     private generateInsertCoordinates;
@@ -67,6 +80,8 @@ export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineS
     stop(): void;
     /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    private onRightClick;
+    private onLeftClick;
     /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
     /** @internal */
@@ -74,11 +89,11 @@ export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineS
     /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
     /** @internal */
-    onDragStart(): void;
+    onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDrag(): void;
+    onDrag(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDragEnd(): void;
+    onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
     cleanUp(): void;
     /** @internal */

package/dist/modes/point/point.mode.d.ts

@@ -1,22 +1,35 @@
 import { TerraDrawMouseEvent, TerraDrawAdapterStyling, NumericStyling, HexColorStyling, Cursor } from "../../common";
 import { GeoJSONStoreFeatures, StoreValidation } from "../../store/store";
 import { BaseModeOptions, CustomStyling, TerraDrawBaseDrawMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
 type PointModeStyling = {
     pointWidth: NumericStyling;
     pointColor: HexColorStyling;
     pointOutlineColor: HexColorStyling;
     pointOutlineWidth: NumericStyling;
+    editedPointColor: HexColorStyling;
+    editedPointWidth: NumericStyling;
+    editedPointOutlineColor: HexColorStyling;
+    editedPointOutlineWidth: NumericStyling;
 };
 interface Cursors {
     create?: Cursor;
+    dragStart?: Cursor;
+    dragEnd?: Cursor;
 }
 interface TerraDrawPointModeOptions<T extends CustomStyling> extends BaseModeOptions<T> {
     cursors?: Cursors;
+    editable?: boolean;
 }
 export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode<PointModeStyling> {
-    mode: string;
+    mode: "point";
     private cursors;
+    private editable;
+    private editedFeatureId;
+    private pixelDistance;
+    private clickBoundingBox;
     constructor(options?: TerraDrawPointModeOptions<PointModeStyling>);
+    updateOptions(options?: TerraDrawPointModeOptions<PointModeStyling> | undefined): void;
     /** @internal */
     start(): void;
     /** @internal */
@@ -31,14 +44,17 @@ export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode<PointModeS
     onKeyUp(): void;
     /** @internal */
     cleanUp(): void;
+    onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDragStart(): void;
+    onDrag(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDrag(): void;
-    /** @internal */
-    onDragEnd(): void;
+    onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
+    registerBehaviors(config: BehaviorConfig): void;
     /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
     validateFeature(feature: unknown): StoreValidation;
+    private onLeftClick;
+    private onRightClick;
+    private getNearestPointFeature;
 }
 export {};

package/dist/modes/polygon/polygon.mode.d.ts

@@ -20,10 +20,16 @@ type PolygonStyling = {
     snappingPointColor: HexColorStyling;
     snappingPointOutlineWidth: NumericStyling;
     snappingPointOutlineColor: HexColorStyling;
+    editedPointWidth: NumericStyling;
+    editedPointColor: HexColorStyling;
+    editedPointOutlineWidth: NumericStyling;
+    editedPointOutlineColor: HexColorStyling;
 };
 interface Cursors {
     start?: Cursor;
     close?: Cursor;
+    dragStart?: Cursor;
+    dragEnd?: Cursor;
 }
 interface Snapping {
     toLine?: boolean;
@@ -35,21 +41,30 @@ interface TerraDrawPolygonModeOptions<T extends CustomStyling> extends BaseModeO
     pointerDistance?: number;
     keyEvents?: TerraDrawPolygonModeKeyEvents | null;
     cursors?: Cursors;
+    editable?: boolean;
 }
 export declare class TerraDrawPolygonMode extends TerraDrawBaseDrawMode<PolygonStyling> {
-    mode: string;
+    mode: "polygon";
     private currentCoordinate;
     private currentId;
     private keyEvents;
+    private cursors;
+    private mouseMove;
     private snapping;
     private snappedPointId;
+    private editable;
+    private editedFeatureId;
+    private editedFeatureCoordinateIndex;
+    private editedSnapType;
+    private editedInsertIndex;
+    private editedPointId;
     private lineSnapping;
     private coordinateSnapping;
     private pixelDistance;
     private closingPoints;
-    private cursors;
-    private mouseMove;
+    private clickBoundingBox;
     constructor(options?: TerraDrawPolygonModeOptions<PolygonStyling>);
+    updateOptions(options?: TerraDrawPolygonModeOptions<PolygonStyling>): void;
     private close;
     /** @internal */
     registerBehaviors(config: BehaviorConfig): void;
@@ -61,18 +76,19 @@ export declare class TerraDrawPolygonMode extends TerraDrawBaseDrawMode<PolygonS
     onMouseMove(event: TerraDrawMouseEvent): void;
     private updatePolygonGeometry;
     private snapCoordinate;
+    private onRightClick;
+    private onLeftClick;
     /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
     /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
     /** @internal */
     onKeyDown(): void;
+    onDragStart(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDragStart(): void;
-    /** @internal */
-    onDrag(): void;
+    onDrag(event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
-    onDragEnd(): void;
+    onDragEnd(_: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void): void;
     /** @internal */
     cleanUp(): void;
     /** @internal */

package/dist/modes/rectangle/rectangle.mode.d.ts

@@ -19,13 +19,14 @@ interface TerraDrawRectangleModeOptions<T extends CustomStyling> extends BaseMod
     cursors?: Cursors;
 }
 export declare class TerraDrawRectangleMode extends TerraDrawBaseDrawMode<RectanglePolygonStyling> {
-    mode: string;
+    mode: "rectangle";
     private center;
     private clickCount;
     private currentRectangleId;
     private keyEvents;
     private cursors;
     constructor(options?: TerraDrawRectangleModeOptions<RectanglePolygonStyling>);
+    updateOptions(options?: TerraDrawRectangleModeOptions<RectanglePolygonStyling>): void;
     private updateRectangle;
     private close;
     /** @internal */

package/dist/modes/render/render.mode.d.ts

@@ -17,13 +17,14 @@ type RenderModeStyling = {
     zIndex: NumericStyling;
 };
 interface TerraDrawRenderModeOptions<T extends CustomStyling> extends BaseModeOptions<T> {
-    modeName: string;
+    modeName?: string;
     styles: Partial<T>;
 }
 export declare class TerraDrawRenderMode extends TerraDrawBaseDrawMode<RenderModeStyling> {
     type: ModeTypes;
     mode: string;
     constructor(options: TerraDrawRenderModeOptions<RenderModeStyling>);
+    updateOptions(options?: TerraDrawRenderModeOptions<RenderModeStyling> | undefined): void;
     /** @internal */
     registerBehaviors(behaviorConfig: BehaviorConfig): void;
     /** @internal */

package/dist/modes/sector/sector.mode.d.ts

@@ -22,7 +22,7 @@ interface TerraDrawSectorModeOptions<T extends CustomStyling> extends BaseModeOp
     cursors?: Cursors;
 }
 export declare class TerraDrawSectorMode extends TerraDrawBaseDrawMode<SectorPolygonStyling> {
-    mode: string;
+    mode: "sector";
     private currentCoordinate;
     private currentId;
     private keyEvents;
@@ -31,6 +31,7 @@ export declare class TerraDrawSectorMode extends TerraDrawBaseDrawMode<SectorPol
     private cursors;
     private mouseMove;
     constructor(options?: TerraDrawSectorModeOptions<SectorPolygonStyling>);
+    updateOptions(options?: TerraDrawSectorModeOptions<SectorPolygonStyling>): void;
     private close;
     /** @internal */
     start(): void;

package/dist/modes/select/select.mode.d.ts

@@ -61,13 +61,15 @@ interface TerraDrawSelectModeOptions<T extends CustomStyling> extends BaseModeOp
     allowManualDeselection?: boolean;
 }
 export declare class TerraDrawSelectMode extends TerraDrawBaseSelectMode<SelectionStyling> {
-    mode: string;
+    mode: "select";
     private allowManualDeselection;
     private dragEventThrottle;
     private dragEventCount;
     private selected;
     private flags;
     private keyEvents;
+    private cursors;
+    private validations;
     private selectionPoints;
     private midPoints;
     private featuresAtMouseEvent;
@@ -78,9 +80,8 @@ export declare class TerraDrawSelectMode extends TerraDrawBaseSelectMode<Selecti
     private rotateFeature;
     private scaleFeature;
     private dragCoordinateResizeFeature;
-    private cursors;
-    private validations;
     constructor(options?: TerraDrawSelectModeOptions<SelectionStyling>);
+    updateOptions(options?: TerraDrawSelectModeOptions<SelectionStyling>): void;
     selectFeature(featureId: FeatureId): void;
     setSelecting(): void;
     registerBehaviors(config: BehaviorConfig): void;

package/dist/modes/sensor/sensor.mode.d.ts

@@ -26,7 +26,7 @@ interface TerraDrawSensorModeOptions<T extends CustomStyling> extends BaseModeOp
     cursors?: Cursors;
 }
 export declare class TerraDrawSensorMode extends TerraDrawBaseDrawMode<SensorPolygonStyling> {
-    mode: string;
+    mode: "sensor";
     private currentCoordinate;
     private currentId;
     private currentInitialArcId;
@@ -37,6 +37,7 @@ export declare class TerraDrawSensorMode extends TerraDrawBaseDrawMode<SensorPol
     private cursors;
     private mouseMove;
     constructor(options?: TerraDrawSensorModeOptions<SensorPolygonStyling>);
+    updateOptions(options?: TerraDrawSensorModeOptions<SensorPolygonStyling>): void;
     private close;
     /** @internal */
     start(): void;

package/dist/modes/static/static.mode.d.ts

@@ -4,7 +4,7 @@ type StaticModeStylingExt<T extends TerraDrawAdapterStyling> = {};
 type StaticModeStyling = StaticModeStylingExt<TerraDrawAdapterStyling>;
 export declare class TerraDrawStaticMode extends TerraDrawBaseDrawMode<StaticModeStyling> {
     type: ModeTypes;
-    mode: string;
+    mode: "static";
     start(): void;
     stop(): void;
     onKeyUp(): void;

package/dist/store/store.d.ts

@@ -56,6 +56,7 @@ export declare class GeoJSONStore<Id extends FeatureId = FeatureId> {
         properties?: JSONObject;
     }[]): Id[];
     delete(ids: FeatureId[]): void;
+    copy(id: FeatureId): GeoJSONStoreFeatures;
     copyAll(): GeoJSONStoreFeatures[];
     clear(): void;
     size(): number;