terra-draw 0.0.1-alpha.15 → 0.0.1-alpha.16

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.1-alpha.16](https://github.com/JamesLMilner/terra-draw/compare/v0.0.1-alpha.15...v0.0.1-alpha.16) (2023-02-19)
+
+
+### Features
+
+* add great circle line mode ([72136a0](https://github.com/JamesLMilner/terra-draw/commit/72136a044ed3a7c9192e92fbb383e64243ce8bd6))
+
+
+### Chore
+
+* add local scratch folder to allow for experimentation ([828e1dd](https://github.com/JamesLMilner/terra-draw/commit/828e1ddfa575a8a9703c63c3bf8d1f11535e3fef))
+* fix scratch pad folder location for local development ([107db58](https://github.com/JamesLMilner/terra-draw/commit/107db581a94852925f7b647f77b67b67f0a7598d))
+
 ### [0.0.1-alpha.15](https://github.com/JamesLMilner/terra-draw/compare/v0.0.1-alpha.14...v0.0.1-alpha.15) (2023-02-05)
 
 

package/dist/adapters/common/adapter-listener.d.ts

@@ -0,0 +1,14 @@
+export declare class AdapterListener {
+    name: string;
+    callback: (...args: any[]) => any;
+    registered: boolean;
+    register: any;
+    unregister: any;
+    private listeners;
+    constructor({ name, callback, unregister, register }: {
+        name: string;
+        callback: (...args: any[]) => any;
+        unregister: (...callbacks: any[]) => void;
+        register: (callback: (...args: any[]) => any) => any[];
+    });
+}

package/dist/adapters/google-maps.adapter.d.ts

@@ -13,24 +13,16 @@ export declare class TerraDrawGoogleMapsAdapter implements TerraDrawAdapter {
     private _coordinatePrecision;
     private _lib;
     private _map;
-    private _onMouseMoveListener;
-    private _onMouseMoveCallback;
-    private _onClickListener;
-    private _onRightClickListener;
-    private _onClickCallback;
-    private _onKeyUpListener;
-    private _onDragStartListener;
-    private _onDragListener;
-    private _onDragEndListener;
     private _layers;
     getMapContainer: () => HTMLElement;
-    unproject: (x: number, y: number) => {
-        lng: number;
-        lat: number;
-    };
+    setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
+    unproject: TerraDrawModeRegisterConfig["unproject"];
     project: TerraDrawModeRegisterConfig["project"];
     setCursor: TerraDrawModeRegisterConfig["setCursor"];
     private circlePath;
+    private currentModeCallbacks;
+    private listeners;
+    private dragState;
     register(callbacks: TerraDrawCallbacks): void;
     unregister(): void;
     render(changes: TerraDrawChanges, styling: {

package/dist/adapters/leaflet.adapter.d.ts

@@ -7,19 +7,16 @@ export declare class TerraDrawLeafletAdapter implements TerraDrawAdapter {
         map: L.Map;
         coordinatePrecision?: number;
     });
+    private listeners;
     private _heldKeys;
     private _lib;
     private _coordinatePrecision;
     private _map;
-    private _onMouseMoveListener;
-    private _onClickListener;
-    private _onKeyUpListener;
-    private _onKeyDownListener;
-    private _onDragStartListener;
-    private _onDragListener;
-    private _onDragEndListener;
     private _layer;
     private _panes;
+    private dragState;
+    private currentModeCallbacks;
+    setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
     project: TerraDrawModeRegisterConfig["project"];
     unproject: TerraDrawModeRegisterConfig["unproject"];
     setCursor: TerraDrawModeRegisterConfig["setCursor"];

package/dist/adapters/mapbox-gl.adapter.d.ts

@@ -4,22 +4,19 @@ import { GeoJSONStoreFeatures } from "../store/store";
 export declare class TerraDrawMapboxGLAdapter implements TerraDrawAdapter {
     constructor(config: {
         map: mapboxgl.Map;
-        coordinatePrecision: number;
+        coordinatePrecision?: number;
     });
+    private dragState;
+    setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
     unproject: TerraDrawModeRegisterConfig["unproject"];
     project: TerraDrawModeRegisterConfig["project"];
     setCursor: TerraDrawModeRegisterConfig["setCursor"];
     getMapContainer: () => HTMLElement;
+    private _listeners;
+    private _currentModeCallbacks;
     private _heldKeys;
     private _coordinatePrecision;
     private _map;
-    private _onMouseMoveListener;
-    private _onClickListener;
-    private _onDragStartListener;
-    private _onDragListener;
-    private _onDragEndListener;
-    private _onKeyDownListener;
-    private _onKeyUpListener;
     private _rendered;
     private _addGeoJSONSource;
     private _addFillLayer;

package/dist/adapters/maplibre-gl.adapter.d.ts

@@ -0,0 +1,20 @@
+import { TerraDrawCallbacks, TerraDrawAdapter, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawChanges } from "../common";
+import { Map } from "maplibre-gl";
+import { GeoJSONStoreFeatures } from "../store/store";
+export declare class TerraDrawMapLibreGLAdapter implements TerraDrawAdapter {
+    private mapboxglAdapter;
+    constructor(config: {
+        map: Map;
+        coordinatePrecision?: number;
+    });
+    setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
+    unproject: TerraDrawModeRegisterConfig["unproject"];
+    project: TerraDrawModeRegisterConfig["project"];
+    setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    getMapContainer: () => HTMLElement;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: (feature: GeoJSONStoreFeatures) => TerraDrawAdapterStyling;
+    }): void;
+}

package/dist/adapters/openlayers.adapter.d.ts

@@ -0,0 +1,55 @@
+import { TerraDrawCallbacks, TerraDrawAdapter, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawChanges } from "../common";
+import { GeoJSONStoreFeatures } from "../store/store";
+import CircleGeom from 'ol/geom/Circle';
+import Feature from 'ol/Feature';
+import GeoJSON from 'ol/format/GeoJSON';
+import Map from 'ol/Map';
+import Circle from 'ol/style/Circle';
+import Stroke from 'ol/style/Stroke';
+import Style from 'ol/style/Style';
+import VectorSource from "ol/source/Vector";
+import VectorLayer from "ol/layer/Vector";
+import { toLonLat } from "ol/proj";
+type InjectableOL = {
+    Circle: typeof CircleGeom;
+    Feature: typeof Feature;
+    GeoJSON: typeof GeoJSON;
+    Style: typeof Style;
+    CircleStyle: typeof Circle;
+    VectorLayer: typeof VectorLayer;
+    VectorSource: typeof VectorSource;
+    Stroke: typeof Stroke;
+    toLonLat: typeof toLonLat;
+};
+export declare class TerraDrawOpenLayersAdapter implements TerraDrawAdapter {
+    constructor(config: {
+        map: Map;
+        lib: InjectableOL;
+        coordinatePrecision?: number;
+    });
+    private _dragState;
+    private _listeners;
+    private _currentModeCallbacks;
+    private _lib;
+    private _map;
+    private _heldKeys;
+    private _coordinatePrecision;
+    private HexToRGB;
+    setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
+    unproject: TerraDrawModeRegisterConfig["unproject"];
+    project: TerraDrawModeRegisterConfig["project"];
+    setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    getMapContainer: () => HTMLElement;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    private vectorSource;
+    private getStyles;
+    private geoJSONReader;
+    private addFeature;
+    private removeFeature;
+    private projection;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: (feature: GeoJSONStoreFeatures) => TerraDrawAdapterStyling;
+    }): void;
+}
+export {};

package/dist/common.d.ts

@@ -1,5 +1,5 @@
 import { StoreChangeHandler, GeoJSONStore, GeoJSONStoreFeatures } from "./store/store";
-export declare type HexColor = `#${string}`;
+export type HexColor = `#${string}`;
 export interface TerraDrawAdapterStyling {
     pointColor: HexColor;
     pointWidth: number;
@@ -24,18 +24,19 @@ export interface TerraDrawMouseEvent {
 export interface TerraDrawKeyboardEvent {
     key: string;
 }
-declare type SetCursor = (cursor: "unset" | "grab" | "grabbing" | "crosshair" | "pointer") => void;
-export declare type Project = (lng: number, lat: number) => {
+type SetCursor = (cursor: "unset" | "grab" | "grabbing" | "crosshair" | "pointer") => void;
+export type Project = (lng: number, lat: number) => {
     x: number;
     y: number;
 };
-export declare type Unproject = (x: number, y: number) => {
+export type Unproject = (x: number, y: number) => {
     lat: number;
     lng: number;
 };
 export interface TerraDrawModeRegisterConfig {
     mode: string;
     store: GeoJSONStore;
+    setDoubleClickToZoom: (enabled: boolean) => void;
     setCursor: SetCursor;
     onChange: StoreChangeHandler;
     onSelect: (selectedId: string) => void;
@@ -43,7 +44,7 @@ export interface TerraDrawModeRegisterConfig {
     project: Project;
     unproject: Unproject;
 }
-export declare type TerraDrawModeState = "unregistered" | "registered" | "started" | "stopped";
+export type TerraDrawModeState = "unregistered" | "registered" | "started" | "stopped";
 export interface TerraDrawMode {
     mode: string;
     styleFeature: (feature: GeoJSONStoreFeatures) => TerraDrawAdapterStyling;
@@ -75,13 +76,14 @@ export interface TerraDrawChanges {
     unchanged: GeoJSONStoreFeatures[];
     deletedIds: string[];
 }
-declare type TerraDrawStylingFunction = {
+type TerraDrawStylingFunction = {
     [mode: string]: (feature: GeoJSONStoreFeatures) => TerraDrawAdapterStyling;
 };
 export interface TerraDrawAdapter {
     project: Project;
     unproject: Unproject;
     setCursor: SetCursor;
+    setDoubleClickToZoom: (enabled: boolean) => void;
     getMapContainer: () => HTMLElement;
     register(callbacks: TerraDrawCallbacks): void;
     unregister(): void;

package/dist/geometry/shape/create-circle.d.ts

@@ -3,5 +3,6 @@ export declare function destination(origin: Position, distance: number, bearing:
 export declare function circle(options: {
     center: Position;
     radiusKilometers: number;
+    coordinatePrecision: number;
     steps?: number;
 }): Feature<Polygon>;

package/dist/geometry/shape/great-circle-line.d.ts

@@ -0,0 +1,12 @@
+import { Feature, LineString, Position } from "geojson";
+import { JSONObject } from "../../store/store";
+export declare function greatCircleLine<Properties extends JSONObject>({ start, end, options }: {
+    start: Position;
+    end: Position;
+    options?: {
+        numberOfPoints?: number;
+        offset?: number;
+        properties?: Properties;
+        coordinatePrecision?: number;
+    };
+}): Feature<LineString, import("geojson").GeoJsonProperties> | null;

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

@@ -1,6 +1,6 @@
 import { Project, Unproject } from "../common";
 import { GeoJSONStore } from "../store/store";
-export declare type BehaviorConfig = {
+export type BehaviorConfig = {
     store: GeoJSONStore;
     mode: string;
     project: Project;

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

@@ -1,7 +1,7 @@
 import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
 import { TerraDrawModeRegisterConfig, TerraDrawModeState } from "../common";
 import { GeoJSONStore, GeoJSONStoreFeatures } from "../store/store";
-declare type CustomStyling = Record<string, string | number>;
+type CustomStyling = Record<string, string | number>;
 export declare abstract class TerraDrawBaseDrawMode<T extends CustomStyling> {
     protected _state: TerraDrawModeState;
     get state(): TerraDrawModeState;
@@ -14,6 +14,7 @@ export declare abstract class TerraDrawBaseDrawMode<T extends CustomStyling> {
     protected coordinatePrecision: number;
     protected onStyleChange: any;
     protected store: GeoJSONStore;
+    protected setDoubleClickToZoom: TerraDrawModeRegisterConfig["setDoubleClickToZoom"];
     protected unproject: TerraDrawModeRegisterConfig["unproject"];
     protected project: TerraDrawModeRegisterConfig["project"];
     protected setCursor: TerraDrawModeRegisterConfig["setCursor"];

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

@@ -1,11 +1,11 @@
 import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
 import { GeoJSONStoreFeatures } from "../../store/store";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-declare type TerraDrawCircleModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
-    finish: KeyboardEvent["key"];
+type TerraDrawCircleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-declare type FreehandPolygonStyling = {
+type FreehandPolygonStyling = {
     fillColor: HexColor;
     outlineColor: HexColor;
     outlineWidth: number;
@@ -19,19 +19,30 @@ export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode<FreehandP
     private keyEvents;
     constructor(options?: {
         styles?: Partial<FreehandPolygonStyling>;
-        keyEvents?: TerraDrawCircleModeKeyEvents;
+        keyEvents?: TerraDrawCircleModeKeyEvents | null;
     });
     private close;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

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

@@ -1,11 +1,11 @@
 import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { GeoJSONStoreFeatures } from "../../store/store";
-declare type TerraDrawFreehandModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
-    finish: KeyboardEvent["key"];
+type TerraDrawFreehandModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-declare type FreehandPolygonStyling = {
+type FreehandPolygonStyling = {
     fillColor: HexColor;
     outlineColor: HexColor;
     outlineWidth: number;
@@ -25,19 +25,30 @@ export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode<Freehan
     constructor(options?: {
         styles?: Partial<FreehandPolygonStyling>;
         minDistance?: number;
-        keyEvents?: TerraDrawFreehandModeKeyEvents;
+        keyEvents?: TerraDrawFreehandModeKeyEvents | null;
     });
     private close;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

package/dist/modes/great-circle-snapping.behavior.d.ts

@@ -0,0 +1,13 @@
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawMouseEvent } from "../common";
+import { Position } from "geojson";
+import { ClickBoundingBoxBehavior } from "./click-bounding-box.behavior";
+import { PixelDistanceBehavior } from "./pixel-distance.behavior";
+export declare class GreatCircleSnappingBehavior extends TerraDrawModeBehavior {
+    readonly config: BehaviorConfig;
+    private readonly pixelDistance;
+    private readonly clickBoundingBox;
+    constructor(config: BehaviorConfig, pixelDistance: PixelDistanceBehavior, clickBoundingBox: ClickBoundingBoxBehavior);
+    getSnappableCoordinate: (event: TerraDrawMouseEvent, currentFeatureId?: string) => Position | undefined;
+    private getSnappableEnds;
+}

package/dist/modes/greatcircle/great-circle.mode.d.ts

@@ -0,0 +1,57 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
+import { GeoJSONStoreFeatures } from "../../store/store";
+type TerraDrawGreateCircleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
+};
+type GreateCircleStyling = {
+    lineStringWidth: number;
+    lineStringColor: HexColor;
+    closingPointColor: HexColor;
+    closingPointWidth: number;
+    closingPointOutlineColor: HexColor;
+    closingPointOutlineWidth: number;
+};
+export declare class TerraDrawGreatCircleMode extends TerraDrawBaseDrawMode<GreateCircleStyling> {
+    mode: string;
+    private currentCoordinate;
+    private currentId;
+    private closingPointId;
+    private keyEvents;
+    private snappingEnabled;
+    private snapping;
+    constructor(options?: {
+        snapping?: boolean;
+        pointerDistance?: number;
+        styles?: Partial<GreateCircleStyling>;
+        keyEvents?: TerraDrawGreateCircleModeKeyEvents | null;
+    });
+    private close;
+    /** @internal */
+    registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onKeyDown(): void;
+    /** @internal */
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    onDragStart(): void;
+    /** @internal */
+    onDrag(): void;
+    /** @internal */
+    onDragEnd(): void;
+    /** @internal */
+    cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
+}
+export {};

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

@@ -2,11 +2,11 @@ import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, H
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { BehaviorConfig } from "../base.behavior";
 import { GeoJSONStoreFeatures } from "../../store/store";
-declare type TerraDrawLineStringModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
-    finish: KeyboardEvent["key"];
+type TerraDrawLineStringModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
 };
-declare type LineStringStyling = {
+type LineStringStyling = {
     lineStringWidth: number;
     lineStringColor: HexColor;
     closingPointColor: HexColor;
@@ -28,20 +28,32 @@ export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode<LineS
         allowSelfIntersections?: boolean;
         pointerDistance?: number;
         styles?: Partial<LineStringStyling>;
-        keyEvents?: TerraDrawLineStringModeKeyEvents;
+        keyEvents?: TerraDrawLineStringModeKeyEvents | null;
     });
     private close;
+    /** @internal */
     registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

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

@@ -1,26 +1,38 @@
 import { TerraDrawMouseEvent, TerraDrawAdapterStyling, HexColor } from "../../common";
 import { GeoJSONStoreFeatures } from "../../store/store";
 import { TerraDrawBaseDrawMode } from "../base.mode";
-declare type PointModeStyling = {
+type PointModeStyling = {
     pointWidth: number;
     pointColor: HexColor;
     pointOutlineColor: HexColor;
+    pointOutlineWidth: number;
 };
 export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode<PointModeStyling> {
     mode: string;
     constructor(options?: {
         styles?: Partial<PointModeStyling>;
     });
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onMouseMove(): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onKeyUp(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

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

@@ -2,11 +2,11 @@ import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, H
 import { TerraDrawBaseDrawMode } from "../base.mode";
 import { BehaviorConfig } from "../base.behavior";
 import { GeoJSONStoreFeatures } from "../../store/store";
-declare type TerraDrawPolygonModeKeyEvents = {
-    cancel: KeyboardEvent["key"];
-    finish: KeyboardEvent["key"];
+type TerraDrawPolygonModeKeyEvents = {
+    cancel?: KeyboardEvent["key"] | null;
+    finish?: KeyboardEvent["key"] | null;
 };
-declare type PolygonStyling = {
+type PolygonStyling = {
     fillColor: HexColor;
     outlineColor: HexColor;
     outlineWidth: number;
@@ -32,20 +32,32 @@ export declare class TerraDrawPolygonMode extends TerraDrawBaseDrawMode<PolygonS
         snapping?: boolean;
         pointerDistance?: number;
         styles?: Partial<PolygonStyling>;
-        keyEvents?: TerraDrawPolygonModeKeyEvents;
+        keyEvents?: TerraDrawPolygonModeKeyEvents | null;
     });
     private close;
+    /** @internal */
     registerBehaviors(config: BehaviorConfig): void;
+    /** @internal */
     start(): void;
+    /** @internal */
     stop(): void;
+    /** @internal */
     onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
     onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
     onKeyDown(): void;
+    /** @internal */
     onDragStart(): void;
+    /** @internal */
     onDrag(): void;
+    /** @internal */
     onDragEnd(): void;
+    /** @internal */
     cleanUp(): void;
+    /** @internal */
     styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
 }
 export {};

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

@@ -0,0 +1,48 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent, HexColor } from "../../common";
+import { GeoJSONStoreFeatures } from "../../store/store";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+type TerraDrawRectangleModeKeyEvents = {
+    cancel: KeyboardEvent["key"] | null;
+    finish: KeyboardEvent["key"] | null;
+};
+type FreehandPolygonStyling = {
+    fillColor: HexColor;
+    outlineColor: HexColor;
+    outlineWidth: number;
+    fillOpacity: number;
+};
+export declare class TerraDrawRectangleMode extends TerraDrawBaseDrawMode<FreehandPolygonStyling> {
+    mode: string;
+    private center;
+    private clickCount;
+    private currentRectangleId;
+    private keyEvents;
+    constructor(options?: {
+        styles?: Partial<FreehandPolygonStyling>;
+        keyEvents?: TerraDrawRectangleModeKeyEvents | null;
+    });
+    private close;
+    /** @internal */
+    start(): void;
+    /** @internal */
+    stop(): void;
+    /** @internal */
+    onClick(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    /** @internal */
+    onKeyDown(): void;
+    /** @internal */
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    /** @internal */
+    onDragStart(): void;
+    /** @internal */
+    onDrag(): void;
+    /** @internal */
+    onDragEnd(): void;
+    /** @internal */
+    cleanUp(): void;
+    /** @internal */
+    styleFeature(feature: GeoJSONStoreFeatures): TerraDrawAdapterStyling;
+}
+export {};