leaflet/dist/types/dom/Draggable.d.ts

JavaScript library for mobile-friendly interactive maps

import { Evented } from '../core/Events.js';
import { Point } from '../geometry/Point.js';
import type { Defaults, DragEndEvent, DraggableDefaults, DraggableEventMap, DraggableOptions, LeafletEvent } from '../types.js';
/** @import {Defaults, DragEndEvent, DraggableDefaults, DraggableEventMap, DraggableOptions, LeafletEvent} from '../types.js' */
declare const defaultOptions: {
    /**
     * The max number of pixels a user can shift the pointer during a click for
     * it to be considered a valid click (as opposed to a pointer drag).
     */
    clickTolerance: number;
};
export type DraggableDefaultsValues = typeof defaultOptions;
export type DraggableEvents = {
    /**
     * Fired when a drag is about to start.
     */
    down: LeafletEvent;
    /**
     * Fired when a drag starts
     */
    dragstart: LeafletEvent;
    /**
     * Fired continuously during dragging *before* each corresponding update of the
     * element's position.
     */
    predrag: LeafletEvent;
    /**
     * Fired continuously during dragging.
     */
    drag: LeafletEvent;
    /**
     * Fired when the drag ends.
     */
    dragend: DragEndEvent;
};
export type DragEndEventProps = {
    /**
     * The distance in pixels the draggable element was moved by.
     */
    distance: number;
    /**
     * Whether the drag should end without inertia (set when the
     * draggable is disabled mid-drag).
     */
    noInertia?: boolean;
};
/** @typedef {typeof defaultOptions} DraggableDefaultsValues */
/**
 * @typedef {Object} DraggableEvents
 * @property {LeafletEvent} down Fired when a drag is about to start.
 * @property {LeafletEvent} dragstart Fired when a drag starts
 * @property {LeafletEvent} predrag Fired continuously during dragging *before* each corresponding update of the
 *   element's position.
 * @property {LeafletEvent} drag Fired continuously during dragging.
 * @property {DragEndEvent} dragend Fired when the drag ends.
 */
/**
 * @typedef {Object} DragEndEventProps
 * @property {number} distance The distance in pixels the draggable element was moved by.
 * @property {boolean} [noInertia] Whether the drag should end without inertia (set when the
 *   draggable is disabled mid-drag).
 */
/**
 * A class for making DOM elements draggable. Used internally
 * for map and marker dragging. Works on any DOM element
 * @example
 * ```js
 * const draggable = new Draggable(elementToDrag);
 * draggable.enable();
 * ```
 *
 * @extends {Evented<DraggableOptions & DraggableDefaults, DraggableEventMap>}
 */
export declare class Draggable extends Evented<DraggableOptions & DraggableDefaults, DraggableEventMap> {
    _element: HTMLElement;
    _dragStartTarget: HTMLElement;
    _enabled: boolean | undefined;
    _moved: boolean | undefined;
    /** @type {Point} */
    _startPoint: Point;
    /** @type {Point} */
    _startPos: Point;
    /** @type {{x: number, y: number}} */
    _parentScale: {
        x: number;
        y: number;
    };
    _draggingContainer: Element | null | undefined;
    /** @type {Element | null} */
    _lastTarget: Element | null;
    /** @type {Point} */
    _newPos: Point;
    _moving: boolean | undefined;
    _lastEvent: PointerEvent | undefined;
    static initHooks: boolean;
    /** @type {Defaults<DraggableOptions>} */
    static defaultOptions: Defaults<DraggableOptions>;
    /** @type {Draggable | false} */
    static _dragging: Draggable | false;
    /**
     * Creates a `Draggable` object for moving `element` when you start dragging
     * the `dragStartTarget` element (equals `element` itself by default).
     * @param {HTMLElement} element
     * @param {HTMLElement} [dragStartTarget]
     * @param {Partial<DraggableOptions>} [options]
     */
    constructor(element: HTMLElement, dragStartTarget?: HTMLElement, options?: Partial<DraggableOptions>);
    /** Enables the dragging ability */
    enable(): void;
    /** Disables the dragging ability */
    disable(): void;
    /** @param {PointerEvent} e */
    _onDown(e: PointerEvent): void;
    /** @param {PointerEvent} e */
    _onMove(e: PointerEvent): void;
    _updatePosition(): void;
    /** @param {PointerEvent} e */
    _onUp(e: PointerEvent): void;
    /**
     * Ends the current drag, firing `dragend` if the element was moved. `noInertia` is passed on in the event, so
     * that the map doesn't keep panning after a drag ended this way.
     * @param {boolean} [noInertia]
     */
    finishDrag(noInertia?: boolean): void;
}
export {};