react-leaflet

  • Version 3.2.2
  • Published
  • 116 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

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 Marker

                  const Marker: 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 MapConsumer

                                          MapConsumer: ({
                                          children,
                                          }: MapConsumerProps) => ReactElement<
                                          any,
                                          string | import('react').JSXElementConstructor<any>
                                          > | null;

                                            function MapContainer

                                            MapContainer: <Props extends MapContainerProps = MapContainerProps>({
                                            children,
                                            className,
                                            id,
                                            placeholder,
                                            style,
                                            whenCreated,
                                            ...options
                                            }: Props) => any;

                                              function Pane

                                              Pane: (props: PaneProps) => React.ReactPortal | null;

                                                function useMap

                                                useMap: () => any;

                                                  function useMapEvent

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

                                                    function useMapEvents

                                                    useMapEvents: (handlers: any) => any;

                                                      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 MapConsumerProps

                                                                                  interface MapConsumerProps {}

                                                                                    property children

                                                                                    children: (map: Map) => ReactElement | null;

                                                                                      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 whenCreated

                                                                                                      whenCreated?: (map: LeafletMap) => void;

                                                                                                        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 onClose

                                                                                                                                            onClose?: () => void;

                                                                                                                                              property onOpen

                                                                                                                                              onOpen?: () => void;

                                                                                                                                                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 onClose

                                                                                                                                                                      onClose?: () => void;

                                                                                                                                                                        property onOpen

                                                                                                                                                                        onOpen?: () => void;

                                                                                                                                                                          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 CircleProps

                                                                                                                                                                                            type CircleProps = CircleMarkerProps;

                                                                                                                                                                                              type ScaleControlProps

                                                                                                                                                                                              type ScaleControlProps = Control.ScaleOptions;

                                                                                                                                                                                                type ZoomControlProps

                                                                                                                                                                                                type ZoomControlProps = Control.ZoomOptions;

                                                                                                                                                                                                  Package Files (25)

                                                                                                                                                                                                  Dependencies (1)

                                                                                                                                                                                                  Dev Dependencies (6)

                                                                                                                                                                                                  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>