Logo for jsDocs.io

react-leaflet

  • Version 5.0.0
  • Published
  • 48.9 kB
  • 1 dependency
  • Hippocratic-2.1 license

Install

npm i react-leaflet
yarn add react-leaflet
pnpm add react-leaflet

Overview

React components for Leaflet maps

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable AttributionControl

const AttributionControl: any;

    variable Circle

    const Circle: any;

      variable CircleMarker

      const CircleMarker: any;

        variable FeatureGroup

        const FeatureGroup: any;

          variable GeoJSON

          const GeoJSON: any;

            variable ImageOverlay

            const ImageOverlay: any;

              variable LayerGroup

              const LayerGroup: any;

                variable LayersControl

                const LayersControl: any;

                  variable MapContainer

                  const MapContainer: React.ForwardRefExoticComponent<any>;

                    variable Marker

                    const Marker: any;

                      variable Pane

                      const Pane: React.ForwardRefExoticComponent<any>;

                        variable Polygon

                        const Polygon: any;

                          variable Polyline

                          const Polyline: any;
                            const Popup: any;

                              variable Rectangle

                              const Rectangle: any;

                                variable ScaleControl

                                const ScaleControl: any;

                                  variable SVGOverlay

                                  const SVGOverlay: any;

                                    variable TileLayer

                                    const TileLayer: any;

                                      variable Tooltip

                                      const Tooltip: any;

                                        variable VideoOverlay

                                        const VideoOverlay: any;

                                          variable WMSTileLayer

                                          const WMSTileLayer: any;

                                            variable ZoomControl

                                            const ZoomControl: any;

                                              Functions

                                              function useMap

                                              useMap: () => LeafletMap;

                                                function useMapEvent

                                                useMapEvent: <T extends string | number | symbol>(
                                                    type: T,
                                                    handler: LeafletEventHandlerFnMap
                                                ) => LeafletMap;

                                                  function useMapEvents

                                                  useMapEvents: (handlers: LeafletEventHandlerFnMap) => LeafletMap;

                                                    Interfaces

                                                    interface ControlledLayerProps

                                                    interface ControlledLayerProps {}

                                                      property checked

                                                      checked?: boolean;

                                                        property children

                                                        children: ReactNode;

                                                          property name

                                                          name: string;

                                                            interface FeatureGroupProps

                                                            interface FeatureGroupProps extends LayerGroupProps, PathProps {}

                                                              interface GeoJSONProps

                                                              interface GeoJSONProps extends GeoJSONOptions, LayerGroupProps, PathProps {}

                                                                property data

                                                                data: GeoJsonObject;

                                                                  interface ImageOverlayProps

                                                                  interface ImageOverlayProps extends MediaOverlayProps {}

                                                                    property children

                                                                    children?: ReactNode;

                                                                      property url

                                                                      url: string;

                                                                        interface LayerGroupProps

                                                                        interface LayerGroupProps extends LayerOptions, EventedProps {}

                                                                          property children

                                                                          children?: ReactNode;

                                                                            interface LayersControlProps

                                                                            interface LayersControlProps extends Control.LayersOptions {}

                                                                              property children

                                                                              children?: ReactNode;

                                                                                interface MapContainerProps

                                                                                interface MapContainerProps extends MapOptions {}

                                                                                  property bounds

                                                                                  bounds?: LatLngBoundsExpression;

                                                                                    property boundsOptions

                                                                                    boundsOptions?: FitBoundsOptions;

                                                                                      property children

                                                                                      children?: ReactNode;

                                                                                        property className

                                                                                        className?: string;

                                                                                          property id

                                                                                          id?: string;

                                                                                            property placeholder

                                                                                            placeholder?: ReactNode;

                                                                                              property style

                                                                                              style?: CSSProperties;

                                                                                                property whenReady

                                                                                                whenReady?: () => void;

                                                                                                  interface MarkerProps

                                                                                                  interface MarkerProps extends MarkerOptions, EventedProps {}

                                                                                                    property children

                                                                                                    children?: ReactNode;

                                                                                                      property position

                                                                                                      position: LatLngExpression;

                                                                                                        interface PaneProps

                                                                                                        interface PaneProps {}

                                                                                                          property children

                                                                                                          children?: ReactNode;

                                                                                                            property className

                                                                                                            className?: string;

                                                                                                              property name

                                                                                                              name: string;

                                                                                                                property pane

                                                                                                                pane?: string;

                                                                                                                  property style

                                                                                                                  style?: CSSProperties;

                                                                                                                    interface PolygonProps

                                                                                                                    interface PolygonProps extends PolylineOptions, PathProps {}

                                                                                                                      property children

                                                                                                                      children?: ReactNode;

                                                                                                                        property positions

                                                                                                                        positions: LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][];

                                                                                                                          interface PolylineProps

                                                                                                                          interface PolylineProps extends PolylineOptions, PathProps {}

                                                                                                                            property children

                                                                                                                            children?: ReactNode;

                                                                                                                              property positions

                                                                                                                              positions: LatLngExpression[] | LatLngExpression[][];

                                                                                                                                interface PopupProps

                                                                                                                                interface PopupProps extends PopupOptions, EventedProps {}

                                                                                                                                  property children

                                                                                                                                  children?: ReactNode;

                                                                                                                                    property position

                                                                                                                                    position?: LatLngExpression;

                                                                                                                                      interface RectangleProps

                                                                                                                                      interface RectangleProps extends PathOptions, PathProps {}

                                                                                                                                        property bounds

                                                                                                                                        bounds: LatLngBoundsExpression;

                                                                                                                                          property children

                                                                                                                                          children?: ReactNode;

                                                                                                                                            interface SVGOverlayProps

                                                                                                                                            interface SVGOverlayProps extends MediaOverlayProps {}

                                                                                                                                              property attributes

                                                                                                                                              attributes?: Record<string, string>;

                                                                                                                                                property children

                                                                                                                                                children?: ReactNode;

                                                                                                                                                  interface TileLayerProps

                                                                                                                                                  interface TileLayerProps extends TileLayerOptions, LayerProps {}

                                                                                                                                                    property url

                                                                                                                                                    url: string;

                                                                                                                                                      interface TooltipProps

                                                                                                                                                      interface TooltipProps extends TooltipOptions, EventedProps {}

                                                                                                                                                        property children

                                                                                                                                                        children?: ReactNode;

                                                                                                                                                          property position

                                                                                                                                                          position?: LatLngExpression;

                                                                                                                                                            interface VideoOverlayProps

                                                                                                                                                            interface VideoOverlayProps extends MediaOverlayProps, VideoOverlayOptions {}

                                                                                                                                                              property children

                                                                                                                                                              children?: ReactNode;

                                                                                                                                                                property play

                                                                                                                                                                play?: boolean;

                                                                                                                                                                  property url

                                                                                                                                                                  url: string | string[] | HTMLVideoElement;

                                                                                                                                                                    interface WMSTileLayerProps

                                                                                                                                                                    interface WMSTileLayerProps extends WMSOptions, LayerProps {}

                                                                                                                                                                      property params

                                                                                                                                                                      params?: WMSParams;

                                                                                                                                                                        property url

                                                                                                                                                                        url: string;

                                                                                                                                                                          Type Aliases

                                                                                                                                                                          type AttributionControlProps

                                                                                                                                                                          type AttributionControlProps = Control.AttributionOptions;

                                                                                                                                                                            type ScaleControlProps

                                                                                                                                                                            type ScaleControlProps = Control.ScaleOptions;

                                                                                                                                                                              type ZoomControlProps

                                                                                                                                                                              type ZoomControlProps = Control.ZoomOptions;

                                                                                                                                                                                Package Files (24)

                                                                                                                                                                                Dependencies (1)

                                                                                                                                                                                Dev Dependencies (4)

                                                                                                                                                                                Peer Dependencies (3)

                                                                                                                                                                                Badge

                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/react-leaflet.

                                                                                                                                                                                • Markdown
                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/react-leaflet)
                                                                                                                                                                                • HTML
                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/react-leaflet"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>