declarations
Version:
[](https://www.npmjs.com/package/declarations)
259 lines (216 loc) • 7.6 kB
TypeScript
// Type definitions for Leaflet.Editable 0.7
// Project: https://github.com/yohanboniface/Leaflet.Editable
// Definitions by: Dominic Alie <https://github.com/dalie>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference path="../leaflet/leaflet.d.ts" />
declare namespace L {
/**
* Make geometries editable in Leaflet.
*
* This is not a plug and play UI, and will not. This is a minimal, lightweight, and fully extendable API to
* control editing of geometries. So you can easily build your own UI with your own needs and choices.
*/
export interface EditableStatic {
new (map: Map, options: EditOptions): Editable;
}
/**
* Options to pass to L.Editable when instanciating.
*/
export interface EditOptions {
/**
* Class to be used when creating a new Polyline.
*/
polylineClass?: Object;
/**
* Class to be used when creating a new Polygon.
*/
polygonClass?: Object;
/**
* Class to be used when creating a new Marker.
*/
markerClass?: Object;
/**
* CSS class to be added to the map container while drawing.
*/
drawingCSSClass?: string;
/**
* Layer used to store edit tools (vertex, line guide…).
*/
editLayer?: L.LayerGroup<L.ILayer>;
/**
* Default layer used to store drawn features (marker, polyline…).
*/
featuresLayer?: L.LayerGroup<L.Polyline|L.Polygon|L.Marker>;
/**
* Class to be used as vertex, for path editing.
*/
vertexMarkerClass?: Object;
/**
* Class to be used as middle vertex, pulled by the user to create a new point in the middle of a path.
*/
middleMarkerClass?: Object;
/**
* Class to be used as Polyline editor.
*/
polylineEditorClass?: Object;
/**
* Class to be used as Polygon editor.
*/
polygonEditorClass?: Object;
/**
* Class to be used as Marker editor.
*/
markerEditorClass?: Object;
/**
* Options to be passed to the line guides.
*/
lineGuideOptions?: Object;
/**
* Set this to true if you don't want middle markers.
*/
skipMiddleMarkers?: boolean;
}
/**
* Make geometries editable in Leaflet.
*
* This is not a plug and play UI, and will not. This is a minimal, lightweight, and fully extendable API to
* control editing of geometries. So you can easily build your own UI with your own needs and choices.
*/
export interface Editable extends Mixin.LeafletMixinEvents {
/**
* Options to pass to L.Editable when instanciating.
*/
options: EditOptions;
currentPolygon: Polyline|Polygon|Marker;
/**
* Start drawing a polyline. If latlng is given, a first point will be added. In any case, continuing on user
* click. If options is given, it will be passed to the polyline class constructor.
*/
startPolyline(latLng?: LatLng, options?: L.PolylineOptions): L.Polyline;
/**
* Start drawing a polygon. If latlng is given, a first point will be added. In any case, continuing on user
* click. If options is given, it will be passed to the polygon class constructor.
*/
startPolygon(latLng?: LatLng, options?: L.PolylineOptions): L.Polygon;
/**
* Start adding a marker. If latlng is given, the marker will be shown first at this point. In any case, it
* will follow the user mouse, and will have a final latlng on next click (or touch). If options is given,
* it will be passed to the marker class constructor.
*/
startMarker(latLng?: LatLng, options?: L.MarkerOptions): L.Marker;
/**
* When you need to stop any ongoing drawing, without needing to know which editor is active.
*/
stopDrawing(): void;
}
export var Editable: EditableStatic;
/**
* EditableMixin is included to L.Polyline, L.Polygon and L.Marker. It adds the following methods to them.
*
* When editing is enabled, the editor is accessible on the instance with the editor property.
*/
export interface EditableMixin {
/**
* Enable editing, by creating an editor if not existing, and then calling enable on it.
*/
enableEdit(): any;
/**
* Disable editing, also remove the editor property reference.
*/
disableEdit(): void;
/**
* Enable or disable editing, according to current status.
*/
toggleEdit(): void;
/**
* Return true if current instance has an editor attached, and this editor is enabled.
*/
editEnabled(): boolean;
}
export interface Map {
/**
* Whether to create a L.Editable instance at map init or not.
*/
editable: boolean;
/**
* Options to pass to L.Editable when instanciating.
*/
editOptions: EditOptions;
/**
* L.Editable plugin instance.
*/
editTools: Editable;
}
export interface Polyline extends EditableMixin {
}
namespace Map {
export interface MapOptions {
/**
* Whether to create a L.Editable instance at map init or not.
*/
editable?: boolean;
/**
* Options to pass to L.Editable when instanciating.
*/
editOptions?: EditOptions;
}
}
/**
* When editing a feature (marker, polyline…), an editor is attached to it. This editor basically knows
* how to handle the edition.
*/
export interface BaseEditor {
/**
* Set up the drawing tools for the feature to be editable.
*/
enable(): MarkerEditor|PolylineEditor|PolygonEditor;
/**
* Remove editing tools.
*/
disable(): MarkerEditor|PolylineEditor|PolygonEditor;
}
/**
* Inherit from L.Editable.BaseEditor.
* Inherited by L.Editable.PolylineEditor and L.Editable.PolygonEditor.
*/
export interface PathEditor extends BaseEditor {
/**
* Rebuild edit elements (vertex, middlemarker, etc.).
*/
reset(): void;
}
/**
* Inherit from L.Editable.PathEditor.
*/
export interface PolylineEditor extends PathEditor {
/**
* Set up drawing tools to continue the line forward.
*/
continueForward(): void;
/**
* Set up drawing tools to continue the line backward.
*/
continueBackward(): void;
}
/**
* Inherit from L.Editable.PathEditor.
*/
export interface PolygonEditor extends PathEditor {
/**
* Set up drawing tools for creating a new hole on the polygon. If the latlng param is given, a first
* point is created.
*/
newHole(latlng: LatLng): void;
}
/**
* Inherit from L.Editable.BaseEditor.
*/
export interface MarkerEditor extends BaseEditor {
}
export interface Marker extends EditableMixin, MarkerEditor {
}
export interface Polyline extends EditableMixin, PolylineEditor {
}
export interface Polygon extends EditableMixin, PolygonEditor {
}
}