leaflet/dist/types/layer/vector/Canvas.d.ts

JavaScript library for mobile-friendly interactive maps

import { Renderer } from './Renderer.js';
import { Bounds } from '../../geometry/Bounds.js';
import type { CanvasDefaults, CanvasOptions, Defaults, RendererEventMap } from '../../types.js';
import type { LeafletMap } from '../../map/Map.js';
import type { Point } from '../../geometry/Point.js';
import type { CircleMarker } from './CircleMarker.js';
import type { Path } from './Path.js';
import type { Polyline } from './Polyline.js';
/** @import {CanvasDefaults, CanvasOptions, Defaults, RendererEventMap} from '../../types.js' */
/** @import {LeafletMap} from '../../map/Map.js' */
/** @import {Point} from '../../geometry/Point.js' */
/** @import {CircleMarker} from './CircleMarker.js' */
/** @import {Path} from './Path.js' */
/** @import {Polyline} from './Polyline.js' */
declare const defaultOptions: {
    /** How much to extend the click tolerance around a path/object on the map. */
    tolerance: number;
};
export type CanvasDefaultsValues = typeof defaultOptions;
export type DrawOrder = {
    layer: Path;
    prev?: DrawOrder | null;
    next?: DrawOrder | null;
};
/**
 * Allows vector layers to be displayed with [`<canvas>`](https://developer.mozilla.org/docs/Web/API/Canvas_API).
 * Inherits `Renderer`.
 * @constructorDescription Creates a Canvas renderer with the given options.
 * @example
 * Use Canvas by default for all paths in the map:
 *
 * ```js
 * const map = new LeafletMap('map', {
 * 	renderer: new Canvas()
 * });
 * ```
 *
 * Use a Canvas renderer with extra padding for specific vector geometries:
 *
 * ```js
 * const map = new LeafletMap('map');
 * const myRenderer = new Canvas({ padding: 0.5 });
 * const line = new Polyline( coordinates, { renderer: myRenderer } );
 * const circle =  new Circle( center, { renderer: myRenderer, radius: 100 } );
 * ```
 * @template {CanvasOptions} [O=CanvasOptions]
 * @template {RendererEventMap} [E=RendererEventMap]
 * @extends {Renderer<O & CanvasDefaults, E>}
 */
export declare class Canvas<O extends CanvasOptions = CanvasOptions, E extends RendererEventMap = RendererEventMap> extends Renderer<O & CanvasDefaults, E> {
    /** @type {boolean} */
    _postponeUpdatePaths: boolean;
    _container: HTMLCanvasElement;
    /** @type {CanvasRenderingContext2D} */
    _ctx: CanvasRenderingContext2D;
    /** @type {number | null} */
    _redrawRequest: number | null;
    _ctxScale: number;
    /** @type {Bounds | null} */
    _redrawBounds: Bounds | null;
    /** @type {DrawOrder | null | undefined} */
    _drawLast: DrawOrder | null | undefined;
    _drawFirst: DrawOrder | null | undefined;
    /** @type {boolean} */
    _drawing: boolean;
    _hoveredLayer: Path | null | undefined;
    _pointerHoverThrottled: boolean | undefined;
    /** @type {number | undefined} */
    _pointerHoverThrottleTimeout: number | undefined;
    /** @type {Defaults<CanvasOptions>} */
    static defaultOptions: Defaults<CanvasOptions>;
    getEvents(): import("../../types.js").MapListeners;
    _onViewPreReset(): void;
    /** @param {LeafletMap} map */
    onAdd(map: LeafletMap): void;
    /** @param {LeafletMap} map */
    onRemove(map: LeafletMap): void;
    _initContainer(): void;
    _destroyContainer(): void;
    _resizeContainer(): Point;
    _updatePaths(): void;
    _update(): void;
    _reset(): void;
    /** @param {Path} layer */
    _initPath(layer: Path): void;
    /** @param {Path} layer */
    _addPath(layer: Path): void;
    /** @param {Path} layer */
    _removePath(layer: Path): void;
    /** @param {Path} layer */
    _updatePath(layer: Path): void;
    /** @param {Path} layer */
    _updateStyle(layer: Path): void;
    /** @param {Path} layer */
    _updateDashArray(layer: Path): void;
    /** @param {Path} layer */
    _requestRedraw(layer: Path): void;
    /** @param {Path} layer */
    _extendRedrawBounds(layer: Path): void;
    _redraw(): void;
    _clear(): void;
    _draw(): void;
    /**
     * @param {Polyline} layer
     * @param {boolean} [closed]
     */
    _updatePoly(layer: Polyline, closed?: boolean): void;
    /** @param {CircleMarker} layer */
    _updateCircle(layer: CircleMarker): void;
    /**
     * @param {CanvasRenderingContext2D} ctx
     * @param {Path} layer
     */
    _fillStroke(ctx: CanvasRenderingContext2D, layer: Path): void;
    /** @param {MouseEvent} e */
    _onClick(e: MouseEvent): void;
    /** @param {PointerEvent} e */
    _onPointerMove(e: PointerEvent): void;
    /** @param {PointerEvent} e */
    _handlePointerOut(e: PointerEvent): void;
    /**
     * @param {PointerEvent} e
     * @param {Point} point
     */
    _handlePointerHover(e: PointerEvent, point: Point): void;
    /**
     * @param {Path[] | false} layers
     * @param {MouseEvent} e
     * @param {string} [type]
     */
    _fireEvent(layers: Path[] | false, e: MouseEvent, type?: string): void;
    /** @param {Path} layer */
    _bringToFront(layer: Path): void;
    /** @param {Path} layer */
    _bringToBack(layer: Path): void;
}
export {};