@opengeoweb/core 4.3.0 → 4.5.0

package/lib/components/CanvasComponent/CanvasComponent.d.ts

@@ -3,7 +3,7 @@ interface CanvasComponentProps {
     onRenderCanvas: (ctx: CanvasRenderingContext2D, width: number, height: number, canvas: HTMLCanvasElement) => void;
     onCanvasClick?: (x: number, y: number, width: number, height: number) => void;
     onMouseMove?: (x: number, y: number, event: MouseEvent, width: number) => void;
-    onMouseUp?: () => void;
+    onMouseUp?: (x: number) => void;
     onMouseDown?: (x: number, y: number, width: number) => void;
     onTouchStart?: (event: TouchEvent, width: number) => void;
     onTouchEnd?: () => void;
@@ -24,14 +24,14 @@ interface CanvasComponentProps {
     children?: React.ReactNode;
 }
 export default class CanvasComponent extends Component<CanvasComponentProps> {
-    canvas: any;
-    ctx: any;
+    canvas: HTMLCanvasElement | null;
+    ctx: CanvasRenderingContext2D | null;
     currentWidth: number;
     currentHeight: number;
-    canvascontaineroutside: any;
-    canvascontainer: any;
-    timer: any;
-    redrawTimer: any;
+    canvascontaineroutside: React.RefObject<HTMLDivElement> | null;
+    canvascontainer: React.RefObject<HTMLDivElement> | null;
+    timer: ReturnType<typeof setTimeout> | null;
+    redrawTimer: ReturnType<typeof setTimeout> | null;
     loopHasStarted: boolean;
     mounted: boolean;
     static defaultProps: {
@@ -59,7 +59,7 @@ export default class CanvasComponent extends Component<CanvasComponentProps> {
     updateCanvas(): void;
     resize(): void;
     handleMouseMoveEvent(event: MouseEvent): void;
-    handleMouseUpEvent(): void;
+    handleMouseUpEvent(event: MouseEvent): void;
     handleMouseDownEvent(event: MouseEvent): void;
     handleTouchStartEvent(event: TouchEvent): void;
     handleTouchEndEvent(): void;

package/lib/components/ConfigurableMap/ConfigurableMapConnect.d.ts

@@ -29,5 +29,7 @@ export interface ConfigurableMapConnectProps {
     displayDimensionSelectButtonInMap?: boolean;
     multiLegend?: boolean;
     shouldShowLayerManager?: boolean;
+    showClock?: boolean;
+    children?: React.ReactNode;
 }
 export declare const ConfigurableMapConnect: React.FC<ConfigurableMapConnectProps>;

package/lib/components/LayerManager/BaseLayerRow/BaseLayerRow.d.ts

@@ -1,12 +1,10 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../LayerManagerUtils';
 import { Layer } from '../../../store/mapStore/types';
 import { Service } from '../../WMSLoader/services';
 interface BaseLayerRowProps {
     mapId: string;
     preloadedAvailableBaseLayers?: Layer[];
     preloadedServices?: Service[];
-    layerManagerWidth: LayerManagerWidth;
     tooltip?: string;
 }
 declare const BaseLayerRow: React.FC<BaseLayerRowProps>;

package/lib/components/LayerManager/DescriptionRow/DescriptionRow.d.ts

@@ -1,14 +1,9 @@
 import * as React from 'react';
-import { Service } from '../../WMSLoader/services';
-import { LayerType } from '../../../store/mapStore/types';
-import { LayerManagerWidth } from '../LayerManagerUtils';
+import { Source } from '../../../store/ui/types';
 interface DescriptionRowProps {
     mapId: string;
-    preloadedServices?: Service[];
-    layerType?: LayerType;
-    tooltip?: string;
-    layerManagerWidth: LayerManagerWidth;
-    layerSelect?: boolean;
+    mapPresetsModule?: React.ReactElement;
+    source?: Source;
 }
 declare const DescriptionRow: React.FC<DescriptionRowProps>;
 export default DescriptionRow;

package/lib/components/LayerManager/DockedLayerManagerConnect.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { Layer } from '../../store/mapStore/types';
+import { Service } from '../WMSLoader/services';
+interface DockedLayerManagerConnectProps {
+    mapId: string;
+    preloadedAvailableBaseLayers?: Layer[];
+    preloadedBaseServices?: Service[];
+    bounds?: string;
+    showTitle?: boolean;
+    leftHeaderComponent?: React.ReactElement;
+}
+/**
+ * Docked Layer Manager connected to the store displaying the layers for the corresponding map it's included in
+ * Expects the following props:
+ * @param {Service[]} preloadedBaseServices preloadedBaseServices: array of Service objects - contains an array of Service objects that are preloaded into in the WMS Loader fpr baselayers
+ * @param {Layer[]} preloadedAvailableBaseLayers preloadedAvailableBaseLayers: array of Layer objects - contains an array of Layer objects (consisting solely of type baseLayer) that are available to be shown as basemaps
+ * ``` <LayerManagerConnect />```
+ */
+declare const DockedLayerManagerConnect: React.FC<DockedLayerManagerConnectProps>;
+export default DockedLayerManagerConnect;

package/lib/components/LayerManager/LayerContainerRow/LayerContainerRow.d.ts

@@ -1,8 +1,6 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../LayerManagerUtils';
 interface LayerContainerRowProps {
     mapId: string;
-    layerManagerWidth: LayerManagerWidth;
 }
 declare const LayerContainerRow: React.FC<LayerContainerRowProps>;
 /**

package/lib/components/LayerManager/LayerContainerRow/LayerRow/ActivateLayer/ActivateLayer.d.ts

@@ -4,6 +4,7 @@ interface ActivateLayerProps {
     onClickActivate: () => void;
     isActive?: boolean;
     isEnabled?: boolean;
+    id?: string;
 }
 declare const ActivateLayer: React.FC<ActivateLayerProps>;
 export default ActivateLayer;

package/lib/components/LayerManager/LayerContainerRow/LayerRow/EnableLayer/EnableLayerConnect.d.ts

@@ -2,6 +2,8 @@ import * as React from 'react';
 interface EnableLayerProps {
     layerId: string;
     mapId: string;
+    isEnabled?: boolean;
+    layerName?: string;
 }
 declare const EnableLayerConnect: React.FC<EnableLayerProps>;
 /**

package/lib/components/LayerManager/LayerContainerRow/LayerRow/LayerRow.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 import { Dimension, Layer, Services } from '../../../../store/mapStore/types';
-import { LayerManagerWidth } from '../../LayerManagerUtils';
 interface LayerRowProps {
     layerId?: string;
     layer?: Layer;
+    layerName?: string;
     mapId: string;
     onLayerRowClick?: (layerId?: string) => void;
     onLayerEnable?: (payload: {
@@ -44,7 +44,6 @@ interface LayerRowProps {
     layerMenuLayout?: React.ReactChild;
     layerActiveLayout?: React.ReactChild;
     services?: Services;
-    layerManagerWidth: LayerManagerWidth;
     isEnabled?: boolean;
     dragHandle?: React.ReactElement;
     isLayerMissing?: boolean;

package/lib/components/LayerManager/LayerContainerRow/LayerRow/LayerRowConnect.d.ts

@@ -1,9 +1,7 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../../LayerManagerUtils';
 interface LayerRowConnectProps {
     layerId: string;
     mapId: string;
-    layerManagerWidth: LayerManagerWidth;
     dragHandle: React.ReactElement;
     layerIndex: number;
 }

package/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderLayers/RenderLayers.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { ServiceLayer } from '../../../../../store/mapStore/types';
-interface RenderLayersProps {
+export interface RenderLayersProps {
     onChangeLayerName: (name: string) => void;
     layerName: string;
     layers: ServiceLayer[];

package/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderStyles/RenderStyles.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { Style } from '@opengeoweb/webmap';
-interface RenderStylesProps {
+export interface RenderStylesProps {
     layerStyles: Style[];
     currentLayerStyle: string;
     onChangeLayerStyle: (style: string) => void;

package/lib/components/LayerManager/LayerManager.d.ts

@@ -2,10 +2,15 @@ import * as React from 'react';
 import { Layer } from '../../store/mapStore/types';
 import { Source } from '../../store/ui/types';
 import { Service } from '../WMSLoader/services';
+import { Size } from './LayerManagerHeaderOptions';
+export declare type Position = {
+    top: number;
+    left?: number;
+    right?: number;
+};
 interface LayerManagerProps {
     mapId: string;
     preloadedAvailableBaseLayers?: Layer[];
-    preloadedMapServices?: Service[];
     preloadedBaseServices?: Service[];
     bounds?: string;
     showTitle?: boolean;
@@ -14,24 +19,14 @@ interface LayerManagerProps {
     isOpen: boolean;
     order?: number;
     source?: Source;
-    layerSelect?: boolean;
-    showAddLayersTooltip?: boolean;
-    leftComponent?: React.ReactNode;
+    leftHeaderComponent?: React.ReactElement;
     isLoading?: boolean;
     error?: string;
+    isDockedLayerManager?: boolean;
+    onToggleDock?: () => void;
+    size?: Size;
+    startPosition?: Position;
 }
-export declare const calculateStartSize: (minSize: {
-    width: number;
-    height: number;
-}, prefSize: {
-    width: number;
-    height: number;
-}, startPosition: {
-    top: number;
-    left: number;
-}) => {
-    width: number;
-    height: number;
-};
+export declare const calculateStartSize: (minSize: Size, prefSize: Size, startPosition: Position) => Size;
 declare const LayerManager: React.FC<LayerManagerProps>;
 export default LayerManager;

package/lib/components/LayerManager/LayerManager.stories.d.ts

@@ -9,6 +9,26 @@ export declare const LayerManagerLightTheme: {
     };
     storyName: string;
 };
+export declare const DockedLayerManagerLightTheme: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+    storyName: string;
+};
+export declare const LayerManagerLightThemeSmall: () => React.ReactElement;
+export declare const LayerManagerLightThemeMedium: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+};
 export declare const LayerManagerDarkTheme: {
     (): React.ReactElement;
     parameters: {
@@ -19,6 +39,26 @@ export declare const LayerManagerDarkTheme: {
     };
     storyName: string;
 };
+export declare const DockedLayerManagerDarkTheme: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+    storyName: string;
+};
+export declare const LayerManagerDarkThemeSmall: () => React.ReactElement;
+export declare const LayerManagerDarkThemeMedium: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+};
 export declare const LayerManagerLoadingState: () => React.ReactElement;
 export declare const LayerManagerWithErrorLight: {
     (): React.ReactElement;

package/lib/components/LayerManager/LayerManagerConnect.d.ts

@@ -7,8 +7,7 @@ interface LayerManagerConnectProps {
     preloadedBaseServices?: Service[];
     bounds?: string;
     showTitle?: boolean;
-    layerSelect?: boolean;
-    leftComponent?: React.ReactNode;
+    leftHeaderComponent?: React.ReactElement;
 }
 /**
  * Layer Managerconnected to the store displaying the layers forthe active map Id

package/lib/components/LayerManager/LayerManagerHeaderOptions.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+export declare type Size = {
+    width: number;
+    height: number;
+};
+interface HeaderOptionsProps {
+    isDockedLayerManager: boolean;
+    onClickDockButton: () => void;
+    onChangeSize: (size: Size) => void;
+}
+export declare const sizeSmall: {
+    width: number;
+    height: number;
+};
+export declare const sizeMedium: {
+    width: number;
+    height: number;
+};
+export declare const sizeLarge: {
+    width: number;
+    height: number;
+};
+declare const HeaderOptions: React.FC<HeaderOptionsProps>;
+export default HeaderOptions;

package/lib/components/LayerManager/LayerManagerUtils.d.ts

@@ -1,54 +1,151 @@
-export declare const LayerManagerColumnsLarge: {
-    column1: {
+export declare const columnClasses: {
+    column1: string;
+    column2: string;
+    column3: string;
+    column4: string;
+    column5: string;
+    column6: string;
+    column7: string;
+};
+export declare const layerManagerStyle: {
+    '@container (max-width: 320px)'?: {
+        '.layermanager': {
+            '.column-1:not(.container-query-polyfill)': {
+                width: string;
+            };
+            '.enable-btn-mini:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.activateLayer-btn:not(.container-query-polyfill), .enable-btn:not(.container-query-polyfill), .column-2:not(.container-query-polyfill), .column-3:not(.container-query-polyfill), .column-4:not(.container-query-polyfill), .column-5:not(.container-query-polyfill), .column-6:not(.container-query-polyfill), .column-7:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '#mappresets-menubutton:not(.container-query-polyfill), .addLayer-column:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.descriptionRow:not(.container-query-polyfill)': {
+                height: number;
+                '.MuiButtonBase-root:not(.container-query-polyfill)': {
+                    display: string;
+                };
+            };
+        };
+        '.header-layermanager': {
+            '.header-left:not(.container-query-polyfill), .header-title:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '&>div:not(.container-query-polyfill)': {
+                justifyContent: string;
+                padding: number;
+                height: number;
+            };
+            '.header-right:not(.container-query-polyfill)': {
+                maxWidth: string;
+                flexBasis: string;
+            };
+            '.collapseSmall-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '@container (max-width: 600px)'?: {
+        '.layermanager': {
+            '.column-3:not(.container-query-polyfill), .column-4:not(.container-query-polyfill), .column-5:not(.container-query-polyfill), .column-6:not(.container-query-polyfill), .column-7:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.column-2:not(.container-query-polyfill)': {
+                width: string;
+            };
+            '.header-layer.mappresetsModule-enabled:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.header-mapPresets:not(.container-query-polyfill)': {
+                display: string;
+                '.MuiButtonBase-root:not(.container-query-polyfill)': {
+                    height: number;
+                    '.MuiBox-root:not(.container-query-polyfill)': {
+                        textAlign: string;
+                    };
+                };
+            };
+        };
+        '.header-layermanager': {
+            '.mapPresets-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.collapseLarge-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '@container (max-width: 600px) and (min-width: 321px)'?: {
+        '.layermanager': {
+            '.medium-layermanager:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.deleteBtnMedium:not(.container-query-polyfill)': {
+            display: string;
+            '&+button:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.layerRow': {
+            '.column-1:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.column-2:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.header-layermanager': {
+            '.collapseMedium-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '.layerManagerContainer': {
+        containerType: string;
+    };
+    '.is-dragging header+.MuiBox-root': {
+        overflow: string;
+    };
+    '.column-1': {
         width: number;
         display: string;
+        background: string;
     };
-    column2: {
+    '.column-2': {
         width: string;
     };
-    column3: {
+    '.column-3': {
         width: string;
     };
-    column4: {
+    '.column-4': {
         width: string;
     };
-    column5: {
+    '.column-5': {
         width: string;
     };
-    column6: {
+    '.column-6': {
         width: number;
         display: string;
     };
-    columns35: {
-        width: string;
-    };
-};
-export declare const LayerManagerColumnsSmall: {
-    column1: {
-        width: number;
-    };
-    column2: {
+    '.column-7': {
         width: string;
     };
-    column3: {
+    '.enable-btn-mini': {
         display: string;
     };
-    column4: {
-        display: string;
+    '.header-layermanager': {
+        containerType: string;
     };
-    column5: {
+    '.header-mapPresets': {
         display: string;
     };
-    column6: {
-        width: number;
+    '.medium-layermanager': {
         display: string;
     };
-    columns35: {
+    '.collapseLarge-btn': {
         display: string;
     };
 };
-export declare enum LayerManagerWidth {
-    sm = 0,
-    lg = 1
-}
-export declare const widthToWidthClass: (w: number) => LayerManagerWidth;

package/lib/components/LayerManager/LayerSelect/LayerSelectUtils.d.ts

@@ -1,4 +1,5 @@
 import { CSSProperties } from 'react';
+import { ActiveServices } from '../../../store/layerSelect/types';
 export declare const layerSelectColumnsLarge: {
     column1: {
         width: number;
@@ -73,3 +74,4 @@ export declare const layerSelectColumnsSmall: {
 };
 export declare const widthToColumns: (width: number) => Record<string, CSSProperties>;
 export declare const widthToRowHeight: (width: number) => number;
+export declare const sortByService: (serviceObj: ActiveServices) => ActiveServices;

package/lib/components/LayerManager/LayerSelect/ServiceList/ServiceListConnect.d.ts

@@ -1,8 +1,6 @@
 import * as React from 'react';
-import { ActiveServices } from '../../../../store/layerSelect/types';
 interface ServiceListConnectProps {
     setHeight: (height: number) => void;
 }
-export declare const sortByService: (serviceObj: ActiveServices) => ActiveServices;
 declare const ServiceListConnect: React.FC<ServiceListConnectProps>;
 export default ServiceListConnect;

package/lib/components/LayerManager/LayerSelect/ServiceOptionsDialog/ServiceOptionsDialog.d.ts

@@ -4,9 +4,11 @@ import { PopupVariant } from '../ServicePopup/ServicePopup';
 import { ReduxLayer } from '../../../../store/mapStore/types';
 interface ServiceOptionsDialogProps {
     services: ActiveServices;
-    layerSelectRemoveService?: (serviceId: string, serviceUrl: string) => void;
+    layerSelectRemoveService?: (serviceId: string, serviceUrl: string, serviceName: string) => void;
+    layerSelectReloadService?: (serviceUrl: string) => void;
     selectedLayers: ReduxLayer[];
     setServicePopupInfo?: (popupInfo: ServicePopupInfo) => void;
+    isLoading?: boolean;
 }
 export interface ServicePopupInfo {
     isOpen: boolean;

package/lib/components/LayerManager/LayerSelect/ServiceOptionsDialog/ServiceOptionsDialogConnect.d.ts

@@ -4,5 +4,7 @@ interface ServiceOptionsDialogConnectProps {
     mapId?: string;
     setServicePopupInfo?: (popupInfo: ServicePopupInfo) => void;
 }
+export declare const getServiceSuccesUpdateMessage: (serviceName: string) => string;
+export declare const getServiceFailedUpdateMessage: (error: Error) => string;
 declare const ServiceOptionsDialogConnect: React.FC<ServiceOptionsDialogConnectProps>;
 export default ServiceOptionsDialogConnect;

package/lib/components/LayerManager/LayerSelect/ServicePopup/ServicePopup.d.ts

@@ -7,6 +7,7 @@ export interface ServicePopupProps {
     hideBackdrop?: boolean;
     isOpen?: boolean;
     closePopup?: () => void;
+    shouldDisableAutoFocus?: boolean;
     serviceId?: string;
     serviceUrl?: string;
     serviceName?: string;

package/lib/components/LayerManager/LayerSelect/ServicePopup/utils.d.ts

@@ -1,8 +1,11 @@
 import { ActiveServices } from '../../../../store/layerSelect/types';
+import { SetLayersForServicePayload } from '../../../../store/mapStore/types';
 export declare type ValidationResult = string | boolean;
 export declare const VALIDATIONS_NAME_EXISTING = "This name already exists. Choose another name.";
 export declare const VALIDATIONS_SERVICE_EXISTING = "URL already exists.";
 export declare const VALIDATIONS_SERVICE_VALID_URL = "Not a valid URL.";
 export declare const VALIDATIONS_REQUEST_FAILED = "Download failed. Check the URL.";
+export declare const VALIDATIONS_FIELD_REQUIRED = "This field is required";
 export declare const validateServiceName: (value: string, services: ActiveServices, ownServiceName?: string) => ValidationResult;
 export declare const validateServiceUrl: (value: string, services: ActiveServices) => ValidationResult;
+export declare const loadWMSService: (serviceUrl: string, forceReload?: boolean) => Promise<SetLayersForServicePayload>;

package/lib/components/LayerManager/index.d.ts

@@ -1,2 +1,4 @@
 export { default as LayerManagerConnect } from './LayerManagerConnect';
+export { default as DockedLayerManagerConnect } from './DockedLayerManagerConnect';
+export { default as LayerSelectConnect } from './LayerSelect/LayerSelectConnect';
 export { default as LayerManagerMapButtonConnect } from './LayerManagerMapButtonConnect';

package/lib/components/LayerManager/useFetchServices.d.ts

@@ -1,4 +1,4 @@
 import { NoIdService, UserAddedServices } from '../../utils/types';
 import { Service } from '../WMSLoader/services';
-export declare const useFetchServices: (dialogType: string, preloadedServices?: Service[]) => void;
+export declare const useFetchServices: (dialogType: string, preloadedServices?: Service[] | undefined) => void;
 export declare const mergePresetsAndUserAddedServices: (presets: Service[], userAddedServices: UserAddedServices) => NoIdService[];

package/lib/components/MultiMapView/ModelRunInterval/ModelRunInterval.d.ts

@@ -1,6 +1,12 @@
 import * as React from 'react';
 import { Layer } from '../../../store/mapStore/types';
 import { MultiMapPreset } from '../MultiMapViewConnect';
+/**
+ * Custom hook to find out if the list of syncgroup id's contains a group which is of type SYNCGROUPS_TYPE_SETLAYERACTIONS
+ * @param syncGroupsIds A string array of syncgroup ids
+ * @returns True if indeed a group is included which is of type SYNCGROUPS_TYPE_SETLAYERACTIONS
+ */
+export declare const useHasSyncGroupWithLayerActions: (syncGroupsIds: string[] | undefined) => boolean;
 export declare const makeMapPreset: (timeIncrement: number, uniqueId: string, referenceTime: string, layers: Layer[], syncGroupsIds: string[], displayLayerManagerAndLegendButtonInMap: boolean, displayDimensionSelectButtonInMap: boolean) => MultiMapPreset;
 export interface ModelRunIntervalProps {
     layers?: Layer[];

package/lib/components/MultiMapView/MultiMapViewConnect.d.ts

@@ -21,5 +21,6 @@ export interface MultiMapViewProps {
     showTimeSlider?: boolean;
     showZoomControls?: boolean;
     multiLegend?: boolean;
+    showClock?: boolean;
 }
 export declare const MultiMapViewConnect: React.FC<MultiMapViewProps>;

package/lib/components/ReactMapView/AdagucMapDraw.d.ts

@@ -125,7 +125,7 @@ export default class AdagucMapDraw extends React.PureComponent<AdagucMapDrawProp
     static defaultProps: {
         isInEditMode: boolean;
         isInDeleteMode: boolean;
-        webmapjs: any;
+        webmapjs: undefined;
         featureNrToEdit: number;
     };
     featureEvent: FeatureEvent;

package/lib/components/ReactMapView/AdagucMapDrawTools.d.ts

@@ -6,4 +6,4 @@ export declare type CheckHoverFeaturesResult = {
     feature: GeoJsonFeature;
 } | null;
 export declare const distance: (a: Coordinate, b: Coordinate) => number;
-export declare const checkHoverFeatures: (geojson: GeoJSON.FeatureCollection, mouseX: number, mouseY: number, convertGeoCoordsToScreenCoords: (featureCoords: Position[]) => Coordinate[], ignoreCoordinateIndexInFeature?: boolean) => CheckHoverFeaturesResult;
+export declare const checkHoverFeatures: (geojson: GeoJSON.FeatureCollection, mouseX: number, mouseY: number, convertGeoCoordsToScreenCoords: (featureCoords: Position[]) => Coordinate[], ignoreCoordinateIndexInFeature?: boolean | undefined) => CheckHoverFeaturesResult;

package/lib/components/ReactMapView/ReactMapView.d.ts

@@ -36,10 +36,10 @@ declare class ReactMapView extends React.Component<ReactMapViewProps, ReactMapVi
     currentMapProps: {
         children?: React.ReactNode;
     };
-    mapTimer: any;
-    featureLayerUpdateTimer: any;
-    currentWidth: any;
-    currentHeight: any;
+    mapTimer: undefined;
+    featureLayerUpdateTimer: undefined;
+    currentWidth: undefined;
+    currentHeight: undefined;
     adagucContainerRef: any;
     adagucWebMapJSRef: any;
     refetchTimer: NodeJS.Timeout;
@@ -73,7 +73,7 @@ declare class ReactMapView extends React.Component<ReactMapViewProps, ReactMapVi
         layerArrayMutated: boolean;
     };
     clearRefetchTimer: () => void;
-    parseWMJSLayer: (wmLayer: WMLayer, forceReload: boolean, child?: React.ReactElement) => void;
+    parseWMJSLayer: (wmLayer: WMLayer, forceReload: boolean, child?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined) => void;
     checkNewProps(prevProps: ReactMapViewProps, props: ReactMapViewProps): void;
     drawDebounced(): void;
     handleWindowResize(): void;