terra-draw 0.0.1-alpha.0

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

@@ -0,0 +1,38 @@
+/// <reference types="google.maps" />
+import { TerraDrawCallbacks, TerraDrawAdapter, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawChanges } from "../common";
+export declare class TerraDrawGoogleMapsAdapter implements TerraDrawAdapter {
+    constructor(config: {
+        lib: typeof google.maps;
+        map: google.maps.Map;
+        coordinatePrecision?: number;
+    });
+    private _heldKeys;
+    private _cursor;
+    private _cursorStyleSheet;
+    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;
+    };
+    project: TerraDrawModeRegisterConfig["project"];
+    setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    private circlePath;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: TerraDrawAdapterStyling;
+    }): void;
+}

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

@@ -0,0 +1,35 @@
+import { TerraDrawCallbacks, TerraDrawAdapter, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawChanges } from "../common";
+import L from "leaflet";
+export declare class TerraDrawLeafletAdapter implements TerraDrawAdapter {
+    constructor(config: {
+        lib: typeof L;
+        map: L.Map;
+        coordinatePrecision?: number;
+    });
+    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 _midPointPaneZIndexStyleSheet;
+    private _midPointPane;
+    private _selectionPaneZIndexStyleSheet;
+    private _selectedPane;
+    project: TerraDrawModeRegisterConfig["project"];
+    unproject: TerraDrawModeRegisterConfig["unproject"];
+    setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    getMapContainer: () => HTMLElement;
+    private createPaneStyleSheet;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: TerraDrawAdapterStyling;
+    }): void;
+}

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

@@ -0,0 +1,36 @@
+import { TerraDrawCallbacks, TerraDrawAdapter, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawChanges } from "../common";
+import mapboxgl from "mapbox-gl";
+export declare class TerraDrawMapboxGLAdapter implements TerraDrawAdapter {
+    constructor(config: {
+        map: mapboxgl.Map;
+        coordinatePrecision: number;
+    });
+    unproject: TerraDrawModeRegisterConfig["unproject"];
+    project: TerraDrawModeRegisterConfig["project"];
+    setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    getMapContainer: () => HTMLElement;
+    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;
+    private _addFillOutlineLayer;
+    private _addLineLayer;
+    private _addPointLayer;
+    private _addLayer;
+    private _addGeoJSONLayer;
+    private _setGeoJSONLayerData;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: TerraDrawAdapterStyling;
+    }): void;
+}

package/dist/bundle.js

@@ -0,0 +1,6 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	
+/******/ 	
+/******/ })()
+;

package/dist/bundle.js.LICENSE.txt

@@ -0,0 +1,4 @@
+/* @preserve
+ * Leaflet 1.8.0, a JS library for interactive maps. https://leafletjs.com
+ * (c) 2010-2022 Vladimir Agafonkin, (c) 2010-2011 CloudMade
+ */

package/dist/common.d.ts

@@ -0,0 +1,99 @@
+import { StoreChangeHandler, GeoJSONStore, GeoJSONStoreFeatures } from "./store/store";
+export interface TerraDrawAdapterStyling {
+    pointColor: string;
+    pointWidth: number;
+    pointOutlineColor: string;
+    polygonFillColor: string;
+    polygonFillOpacity: number;
+    polygonOutlineColor: string;
+    polygonOutlineWidth: number;
+    lineStringWidth: number;
+    lineStringColor: string;
+    selectedColor: string;
+    selectionPointWidth: number;
+    selectedPointOutlineColor: string;
+    midPointColor: string;
+    midPointWidth: number;
+    midPointOutlineColor: string;
+    closingPointColor: string;
+    closingPointOutlineColor: string;
+    closingPointWidth: number;
+}
+export interface TerraDrawMouseEvent {
+    lng: number;
+    lat: number;
+    containerX: number;
+    containerY: number;
+    button: "left" | "right" | "pointer";
+    heldKeys: string[];
+}
+export interface TerraDrawKeyboardEvent {
+    key: string;
+}
+declare type SetCursor = (cursor: "unset" | "grab" | "grabbing" | "crosshair" | "pointer") => void;
+export declare type Project = (lng: number, lat: number) => {
+    x: number;
+    y: number;
+};
+export declare type Unproject = (x: number, y: number) => {
+    lat: number;
+    lng: number;
+};
+export interface TerraDrawModeRegisterConfig {
+    mode: string;
+    store: GeoJSONStore;
+    setCursor: SetCursor;
+    onChange: StoreChangeHandler;
+    onSelect: (selectedId: string) => void;
+    onDeselect: (deselectedId: string) => void;
+    project: Project;
+    unproject: Unproject;
+}
+export declare type TerraDrawModeState = "unregistered" | "registered" | "started" | "stopped";
+export interface TerraDrawMode {
+    mode: string;
+    styling: TerraDrawAdapterStyling;
+    state: TerraDrawModeState;
+    start: () => void;
+    stop: () => void;
+    register: (config: TerraDrawModeRegisterConfig) => void;
+    onKeyDown: (event: TerraDrawKeyboardEvent) => void;
+    onKeyUp: (event: TerraDrawKeyboardEvent) => void;
+    onMouseMove: (event: TerraDrawMouseEvent) => void;
+    onClick: (event: TerraDrawMouseEvent) => void;
+    onDragStart: (event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void) => void;
+    onDrag: (event: TerraDrawMouseEvent) => void;
+    onDragEnd: (event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void) => void;
+}
+export interface TerraDrawCallbacks {
+    onKeyUp: (event: TerraDrawKeyboardEvent) => void;
+    onKeyDown: (event: TerraDrawKeyboardEvent) => void;
+    onClick: (event: TerraDrawMouseEvent) => void;
+    onMouseMove: (event: TerraDrawMouseEvent) => void;
+    onDragStart: (event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void) => void;
+    onDrag: (event: TerraDrawMouseEvent) => void;
+    onDragEnd: (event: TerraDrawMouseEvent, setMapDraggability: (enabled: boolean) => void) => void;
+}
+export interface TerraDrawChanges {
+    created: GeoJSONStoreFeatures[];
+    updated: GeoJSONStoreFeatures[];
+    unchanged: GeoJSONStoreFeatures[];
+    deletedIds: string[];
+}
+export interface TerraDrawAdapter {
+    project: Project;
+    unproject: Unproject;
+    setCursor: SetCursor;
+    getMapContainer: () => HTMLElement;
+    register(callbacks: TerraDrawCallbacks): void;
+    unregister(): void;
+    render(changes: TerraDrawChanges, styling: {
+        [mode: string]: TerraDrawAdapterStyling;
+    }): void;
+}
+export declare const SELECT_PROPERTIES: {
+    readonly SELECTED: "selected";
+    readonly MID_POINT: "midPoint";
+    readonly SELECTION_POINT: "selectionPoint";
+};
+export {};

package/dist/geometry/boolean/point-in-polygon.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function pointInPolygon(point: Position, rings: Position[][]): boolean;

package/dist/geometry/boolean/self-intersects.d.ts

@@ -0,0 +1,2 @@
+import { Feature, LineString, Polygon } from "geojson";
+export declare function selfIntersects(feature: Feature<Polygon> | Feature<LineString>): boolean;

package/dist/geometry/centroid.d.ts

@@ -0,0 +1,2 @@
+import { Feature, LineString, Polygon, Position } from "geojson";
+export declare function centroid(geojson: Feature<Polygon | LineString>): Position;

package/dist/geometry/coordinates-identical.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function coordinatesIdentical(coordinate: Position, coordinateTwo: Position): boolean;

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

@@ -0,0 +1,6 @@
+import { Feature, Polygon } from "geojson";
+export declare function circle(options: {
+    center: [number, number];
+    radiusKilometers: number;
+    steps?: number;
+}): Feature<Polygon>;

package/dist/geometry/get-coordinates-as-points.d.ts

@@ -0,0 +1,6 @@
+import { Point, Position } from "geojson";
+import { JSONObject } from "../store/store";
+export declare function getCoordinatesAsPoints(selectedCoords: Position[], geometryType: "Polygon" | "LineString", properties: (index: number) => JSONObject): {
+    geometry: Point;
+    properties: JSONObject;
+}[];

package/dist/geometry/get-midpoints.d.ts

@@ -0,0 +1,7 @@
+import { Point, Position } from "geojson";
+import { JSONObject } from "../store/store";
+export declare function getMidPointCoordinates(featureCoords: Position[], precision: number): Position[];
+export declare function getMidPoints(selectedCoords: Position[], properties: (index: number) => JSONObject, precision: number): {
+    geometry: Point;
+    properties: JSONObject;
+}[];

package/dist/geometry/get-pixel-distance-to-line.d.ts

@@ -0,0 +1,10 @@
+export declare const getPixelDistanceToLine: (point: {
+    x: number;
+    y: number;
+}, linePointOne: {
+    x: number;
+    y: number;
+}, linePointTwo: {
+    x: number;
+    y: number;
+}) => number;

package/dist/geometry/get-pixel-distance.d.ts

@@ -0,0 +1,7 @@
+export declare const getPixelDistance: (pointOne: {
+    x: number;
+    y: number;
+}, pointTwo: {
+    x: number;
+    y: number;
+}) => number;

package/dist/geometry/haversine-distance.d.ts

@@ -0,0 +1 @@
+export declare function haversineDistanceKilometers(pointOne: [lng: number, lat: number], pointTwo: [lng: number, lat: number]): number;

package/dist/geometry/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const earthRadius = 6371008.8;
+export declare function degreesToRadians(degrees: number): number;
+export declare function lengthToRadians(distance: number): number;
+export declare function radiansToDegrees(radians: number): number;

package/dist/geometry/limit-decimal-precision.d.ts

@@ -0,0 +1 @@
+export declare function limitPrecision(num: number, decimalLimit?: number): number;

package/dist/geometry/measure/haversine-distance.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function haversineDistanceKilometers(pointOne: Position, pointTwo: Position): number;

package/dist/geometry/measure/pixel-distance-to-line.d.ts

@@ -0,0 +1,10 @@
+export declare const pixelDistanceToLine: (point: {
+    x: number;
+    y: number;
+}, linePointOne: {
+    x: number;
+    y: number;
+}, linePointTwo: {
+    x: number;
+    y: number;
+}) => number;

package/dist/geometry/measure/pixel-distance.d.ts

@@ -0,0 +1,7 @@
+export declare const pixelDistance: (pointOne: {
+    x: number;
+    y: number;
+}, pointTwo: {
+    x: number;
+    y: number;
+}) => number;

package/dist/geometry/measure/rhumb-bearing.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function rhumbBearing(start: Position, end: Position): number;

package/dist/geometry/measure/rhumb-destination.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function rhumbDestination(origin: Position, distanceMeters: number, bearing: number): Position;

package/dist/geometry/measure/rhumb-distance.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function rhumbDistance(destination: Position, origin: Position): number;

package/dist/geometry/midpoint-coordinate.d.ts

@@ -0,0 +1,2 @@
+import { Position } from "geojson";
+export declare function midpointCoordinate(coordinates1: Position, coordinates2: Position, precision: number): number[];

package/dist/geometry/point-in-polygon.d.ts

@@ -0,0 +1 @@
+export declare function pointInPolygon(point: [number, number], rings: [number, number][][]): boolean;

package/dist/geometry/self-intersects.d.ts

@@ -0,0 +1,2 @@
+import { Feature, LineString, Polygon } from "geojson";
+export declare function selfIntersects(feature: Feature<Polygon> | Feature<LineString>): boolean;

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

@@ -0,0 +1,7 @@
+import { Feature, Polygon, Position } from "geojson";
+export declare function destination(origin: Position, distance: number, bearing: number): Position;
+export declare function circle(options: {
+    center: Position;
+    radiusKilometers: number;
+    steps?: number;
+}): Feature<Polygon>;

package/dist/geometry/transform/rotate.d.ts

@@ -0,0 +1,2 @@
+import { Feature, LineString, Polygon } from "geojson";
+export declare function transformRotate(geojson: Feature<Polygon | LineString>, angle: number): Feature<Polygon | LineString, import("geojson").GeoJsonProperties>;

package/dist/geometry/transform/scale.d.ts

@@ -0,0 +1,2 @@
+import { Feature, LineString, Polygon } from "geojson";
+export declare function transformScale(feature: Feature<Polygon | LineString>, factor: number): Feature<Polygon | LineString, import("geojson").GeoJsonProperties>;

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

@@ -0,0 +1,19 @@
+import { Project, Unproject } from "../common";
+import { GeoJSONStore } from "../store/store";
+export declare type BehaviorConfig = {
+    store: GeoJSONStore;
+    mode: string;
+    project: Project;
+    unproject: Unproject;
+    pointerDistance: number;
+    coordinatePrecision: number;
+};
+export declare class TerraDrawModeBehavior {
+    protected store: GeoJSONStore;
+    protected mode: string;
+    protected project: Project;
+    protected unproject: Unproject;
+    protected pointerDistance: number;
+    protected coordinatePrecision: number;
+    constructor({ store, mode, project, unproject, pointerDistance, coordinatePrecision, }: BehaviorConfig);
+}

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

@@ -0,0 +1,30 @@
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawAdapterStyling, TerraDrawModeRegisterConfig, TerraDrawModeState } from "../common";
+import { GeoJSONStore } from "../store/store";
+export declare abstract class TerraDrawBaseDrawMode {
+    _state: TerraDrawModeState;
+    _styling: TerraDrawAdapterStyling;
+    get state(): TerraDrawModeState;
+    set state(_: TerraDrawModeState);
+    get styling(): TerraDrawAdapterStyling;
+    set styling(styling: TerraDrawAdapterStyling);
+    protected behaviors: TerraDrawModeBehavior[];
+    protected pointerDistance: number;
+    protected coordinatePrecision: number;
+    protected onStyleChange: any;
+    protected store: GeoJSONStore;
+    protected unproject: TerraDrawModeRegisterConfig["unproject"];
+    protected project: TerraDrawModeRegisterConfig["project"];
+    protected setCursor: TerraDrawModeRegisterConfig["setCursor"];
+    protected registerBehaviors(behaviorConfig: BehaviorConfig): void;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+        pointerDistance?: number;
+        coordinatePrecision?: number;
+    });
+    protected setStarted(): void;
+    protected setStopped(): void;
+    register(config: TerraDrawModeRegisterConfig): void;
+    onDeselect(deselectedId: string): void;
+    onSelect(selectedId: string): void;
+}

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

@@ -0,0 +1,27 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+declare type TerraDrawCircleModeKeyEvents = {
+    cancel: KeyboardEvent["key"];
+};
+export declare class TerraDrawCircleMode extends TerraDrawBaseDrawMode {
+    mode: string;
+    private center;
+    private clickCount;
+    private currentCircleId;
+    private keyEvents;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+        keyEvents?: TerraDrawCircleModeKeyEvents;
+    });
+    start(): void;
+    stop(): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onKeyDown(): void;
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    onDragStart(): void;
+    onDrag(): void;
+    onDragEnd(): void;
+    cleanUp(): void;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { TerraDrawMouseEvent, TerraDrawMode, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../common";
+export declare class TerraDrawCircleMode implements TerraDrawMode {
+    mode: string;
+    private store;
+    private project;
+    private center;
+    private clickCount;
+    private currentCircleId;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+    });
+    styling: TerraDrawAdapterStyling;
+    register(config: TerraDrawModeRegisterConfig): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onKeyPress(event: TerraDrawKeyboardEvent): void;
+    cleanUp(): void;
+}

package/dist/modes/click-bounding-box.behavior.d.ts

@@ -0,0 +1,7 @@
+import { Feature, Polygon } from "geojson";
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawMouseEvent } from "../common";
+export declare class ClickBoundingBoxBehavior extends TerraDrawModeBehavior {
+    constructor(config: BehaviorConfig);
+    create(event: TerraDrawMouseEvent): Feature<Polygon, import("geojson").GeoJsonProperties>;
+}

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

@@ -0,0 +1,29 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+declare type TerraDrawFreehandModeKeyEvents = {
+    cancel: KeyboardEvent["key"];
+};
+export declare class TerraDrawFreehandMode extends TerraDrawBaseDrawMode {
+    mode: string;
+    private startingClick;
+    private currentId;
+    private skip;
+    private everyNthMouseEvent;
+    private keyEvents;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+        everyNthMouseEvent?: number;
+        keyEvents?: TerraDrawFreehandModeKeyEvents;
+    });
+    start(): void;
+    stop(): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onKeyDown(): void;
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    onDragStart(): void;
+    onDrag(): void;
+    onDragEnd(): void;
+    cleanUp(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { TerraDrawMouseEvent, TerraDrawMode, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../common";
+export declare class TerraDrawFreehandMode implements TerraDrawMode {
+    mode: string;
+    private store;
+    private project;
+    private startingClick;
+    private currentId;
+    private skip;
+    private everyNthMouseEvent;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+        everyNthMouseEvent?: number;
+    });
+    styling: TerraDrawAdapterStyling;
+    register(config: TerraDrawModeRegisterConfig): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onKeyPress(event: TerraDrawKeyboardEvent): void;
+    cleanUp(): void;
+}

package/dist/modes/line-string.mode.d.ts

@@ -0,0 +1,21 @@
+import { TerraDrawMouseEvent, TerraDrawMode, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../common";
+export declare class TerraDrawLineStringMode implements TerraDrawMode {
+    mode: string;
+    private store;
+    private project;
+    private pointerDistance;
+    private currentCoordinate;
+    private currentId;
+    private allowSelfIntersections;
+    constructor(options?: {
+        allowSelfIntersections?: boolean;
+        styling?: Partial<TerraDrawAdapterStyling>;
+        pointerDistance?: number;
+    });
+    styling: TerraDrawAdapterStyling;
+    register(config: TerraDrawModeRegisterConfig): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onKeyPress(event: TerraDrawKeyboardEvent): void;
+    cleanUp(): void;
+}

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

@@ -0,0 +1,34 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling, TerraDrawKeyboardEvent } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+import { BehaviorConfig } from "../base.behavior";
+declare type TerraDrawLineStringModeKeyEvents = {
+    cancel: KeyboardEvent["key"];
+};
+export declare class TerraDrawLineStringMode extends TerraDrawBaseDrawMode {
+    mode: string;
+    private currentCoordinate;
+    private currentId;
+    private allowSelfIntersections;
+    private keyEvents;
+    private snappingEnabled;
+    private snapping;
+    constructor(options?: {
+        snapping?: boolean;
+        allowSelfIntersections?: boolean;
+        pointerDistance?: number;
+        styling?: Partial<TerraDrawAdapterStyling>;
+        keyEvents?: TerraDrawLineStringModeKeyEvents;
+    });
+    registerBehaviors(config: BehaviorConfig): void;
+    start(): void;
+    stop(): void;
+    onMouseMove(event: TerraDrawMouseEvent): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onKeyDown(): void;
+    onKeyUp(event: TerraDrawKeyboardEvent): void;
+    onDragStart(): void;
+    onDrag(): void;
+    onDragEnd(): void;
+    cleanUp(): void;
+}
+export {};

package/dist/modes/pixel-distance.behavior.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+import { TerraDrawMouseEvent } from "../common";
+import { Position } from "geojson";
+export declare class PixelDistanceBehavior extends TerraDrawModeBehavior {
+    constructor(config: BehaviorConfig);
+    measure(clickEvent: TerraDrawMouseEvent, secondCoordinate: Position): number;
+}

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

@@ -0,0 +1,18 @@
+import { TerraDrawMouseEvent, TerraDrawAdapterStyling } from "../../common";
+import { TerraDrawBaseDrawMode } from "../base.mode";
+export declare class TerraDrawPointMode extends TerraDrawBaseDrawMode {
+    mode: string;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+    });
+    start(): void;
+    stop(): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onMouseMove(): void;
+    onKeyDown(): void;
+    onKeyUp(): void;
+    cleanUp(): void;
+    onDragStart(): void;
+    onDrag(): void;
+    onDragEnd(): void;
+}

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

@@ -0,0 +1,14 @@
+import { TerraDrawMouseEvent, TerraDrawMode, TerraDrawModeRegisterConfig, TerraDrawAdapterStyling } from "../common";
+export declare class TerraDrawPointMode implements TerraDrawMode {
+    mode: string;
+    private store;
+    constructor(options?: {
+        styling?: Partial<TerraDrawAdapterStyling>;
+    });
+    styling: TerraDrawAdapterStyling;
+    register(config: TerraDrawModeRegisterConfig): void;
+    onClick(event: TerraDrawMouseEvent): void;
+    onMouseMove(): void;
+    onKeyPress(): void;
+    cleanUp(): void;
+}

package/dist/modes/polygon/behaviors/start-end-point.behavior.d.ts

@@ -0,0 +1,11 @@
+import { Position } from "geojson";
+import { BehaviorConfig, TerraDrawModeBehavior } from "../../base.behavior";
+export declare class StartEndPointBehavior extends TerraDrawModeBehavior {
+    constructor(config: BehaviorConfig);
+    private _startEndPoints;
+    get ids(): string[];
+    set ids(_: string[]);
+    create(selectedCoords: Position[], mode: string): void;
+    delete(): void;
+    update(updatedCoordinates: Position[]): void;
+}