@rio-cloud/rio-uikit 0.16.4-beta.2 → 0.16.4-beta.20

package/components/map/components/features/basics/marker/Marker.js

@@ -1,116 +1,116 @@
-/* eslint-disable no-undef */
-import React, { useContext, useEffect, useState, useRef } from 'react';
-import ReactDomServer from 'react-dom/server';
-import PropTypes from 'prop-types';
-import mapProps from '../../../../utils/proptypes';
-import { addEventListenerMap, removeEventListenerMap } from '../../../../utils/eventHandling';
-import MapException from '../../../../exceptions/MapException';
-import { MapContext } from '../../../context';
-export const isHMapIcon = icon => icon instanceof H.map.Icon;
-export const isDomMakerNeeded = icon => (!icon ? false : !isHMapIcon(icon));
-export function getOrCreateIcon(icon) {
-    if (!icon || isHMapIcon(icon) || icon instanceof H.map.DomIcon) {
-        return;
-    }
-    const renderedIcon = React.isValidElement(icon)
-        ? ReactDomServer.renderToStaticMarkup(React.cloneElement(icon))
-        : icon;
-    return new H.map.DomIcon(renderedIcon);
-}
-const convertPosition = pos => (Array.isArray(pos) ? new H.geo.MultiPoint(pos) : pos);
-const checkPositionProperties = position => {
-    ['lat', 'lng'].forEach(propertyName => {
-        // eslint-disable-next-line no-prototype-builtins
-        if (!position.hasOwnProperty(propertyName)) {
-            throw new MapException(`Error in Marker: position object requires property "${propertyName}"`);
-        }
-    });
-};
-const getPosition = position => {
-    if (!position) {
-        throw new MapException('Error in Marker: invalid position property');
-    }
-    if (Array.isArray(position)) {
-        position.forEach(pos => checkPositionProperties(pos));
-    }
-    else {
-        checkPositionProperties(position);
-    }
-    return position;
-};
-const getConvertedPosition = position => convertPosition(getPosition(position));
-const setupMarker = (props, api) => {
-    const { position, customData, icon, draggable, eventListenerMap } = props;
-    const MarkerConstructor = isDomMakerNeeded(icon) ? H.map.DomMarker : H.map.Marker;
-    const marker = new MarkerConstructor(getConvertedPosition(position), {
-        icon: getOrCreateIcon(icon, api.settings.baseLayer),
-    });
-    marker.setData(customData);
-    marker.draggable = !!draggable;
-    api.map.addObject(marker);
-    addEventListenerMap(marker, eventListenerMap, api.map);
-    return marker;
-};
-const destroyMarker = (marker, api) => {
-    removeEventListenerMap(marker);
-    if (api.map.getObjects().includes(marker)) {
-        api.map.removeObject(marker);
-    }
-    marker.dispose();
-};
-const Marker = props => {
-    const { position, customData, icon, eventListenerMap } = props;
-    const { api } = useContext(MapContext);
-    const markerRef = useRef();
-    useEffect(() => {
-        markerRef.current = setupMarker(props, api);
-        return () => {
-            if (markerRef.current) {
-                destroyMarker(markerRef.current, api);
-                markerRef.current = undefined;
-            }
-        };
-    }, []);
-    // Update marker position
-    useEffect(() => {
-        if (markerRef.current) {
-            markerRef.current.setGeometry(getConvertedPosition(position));
-        }
-    }, [position, markerRef.current]);
-    // Update marker custom data
-    useEffect(() => {
-        if (markerRef.current) {
-            markerRef.current.setData(customData);
-        }
-    }, [customData, markerRef.current]);
-    // Update EventListenerMap
-    useEffect(() => {
-        if (markerRef.current) {
-            // use exports to make methods accessible for stubbing
-            const mapApi = removeEventListenerMap(markerRef.current);
-            addEventListenerMap(markerRef.current, eventListenerMap, mapApi);
-        }
-    }, [eventListenerMap, markerRef.current]);
-    // If icon type changed, we need to change the marker type
-    useEffect(() => {
-        if (!(markerRef.current && icon)) {
-            return;
-        }
-        if (isDomMakerNeeded(icon)) {
-            destroyMarker(markerRef.current, api);
-            markerRef.current = setupMarker(props, api);
-        }
-        else {
-            markerRef.current.setIcon(getOrCreateIcon(icon));
-        }
-    }, [icon, markerRef.current]);
-    return null;
-};
-Marker.propTypes = {
-    position: PropTypes.oneOfType([mapProps.position, mapProps.positions]).isRequired,
-    icon: mapProps.icon,
-    eventListenerMap: PropTypes.object,
-    customData: PropTypes.object,
-    draggable: PropTypes.bool,
-};
-export default Marker;
+/* eslint-disable no-undef */
+import React, { useContext, useEffect, useState, useRef } from 'react';
+import ReactDomServer from 'react-dom/server';
+import PropTypes from 'prop-types';
+import mapProps from '../../../../utils/proptypes';
+import { addEventListenerMap, removeEventListenerMap } from '../../../../utils/eventHandling';
+import MapException from '../../../../exceptions/MapException';
+import { MapContext } from '../../../context';
+export const isHMapIcon = icon => icon instanceof H.map.Icon;
+export const isDomMakerNeeded = icon => (!icon ? false : !isHMapIcon(icon));
+export function getOrCreateIcon(icon) {
+    if (!icon || isHMapIcon(icon) || icon instanceof H.map.DomIcon) {
+        return;
+    }
+    const renderedIcon = React.isValidElement(icon)
+        ? ReactDomServer.renderToStaticMarkup(React.cloneElement(icon))
+        : icon;
+    return new H.map.DomIcon(renderedIcon);
+}
+const convertPosition = pos => (Array.isArray(pos) ? new H.geo.MultiPoint(pos) : pos);
+const checkPositionProperties = position => {
+    ['lat', 'lng'].forEach(propertyName => {
+        // eslint-disable-next-line no-prototype-builtins
+        if (!position.hasOwnProperty(propertyName)) {
+            throw new MapException(`Error in Marker: position object requires property "${propertyName}"`);
+        }
+    });
+};
+const getPosition = position => {
+    if (!position) {
+        throw new MapException('Error in Marker: invalid position property');
+    }
+    if (Array.isArray(position)) {
+        position.forEach(pos => checkPositionProperties(pos));
+    }
+    else {
+        checkPositionProperties(position);
+    }
+    return position;
+};
+const getConvertedPosition = position => convertPosition(getPosition(position));
+const setupMarker = (props, api) => {
+    const { position, customData, icon, draggable, eventListenerMap } = props;
+    const MarkerConstructor = isDomMakerNeeded(icon) ? H.map.DomMarker : H.map.Marker;
+    const marker = new MarkerConstructor(getConvertedPosition(position), {
+        icon: getOrCreateIcon(icon, api.settings.baseLayer),
+    });
+    marker.setData(customData);
+    marker.draggable = !!draggable;
+    api.map.addObject(marker);
+    addEventListenerMap(marker, eventListenerMap, api.map);
+    return marker;
+};
+const destroyMarker = (marker, api) => {
+    removeEventListenerMap(marker);
+    if (api.map.getObjects().includes(marker)) {
+        api.map.removeObject(marker);
+    }
+    marker.dispose();
+};
+const Marker = props => {
+    const { position, customData, icon, eventListenerMap } = props;
+    const { api } = useContext(MapContext);
+    const markerRef = useRef();
+    useEffect(() => {
+        markerRef.current = setupMarker(props, api);
+        return () => {
+            if (markerRef.current) {
+                destroyMarker(markerRef.current, api);
+                markerRef.current = undefined;
+            }
+        };
+    }, []);
+    // Update marker position
+    useEffect(() => {
+        if (markerRef.current) {
+            markerRef.current.setGeometry(getConvertedPosition(position));
+        }
+    }, [position, markerRef.current]);
+    // Update marker custom data
+    useEffect(() => {
+        if (markerRef.current) {
+            markerRef.current.setData(customData);
+        }
+    }, [customData, markerRef.current]);
+    // Update EventListenerMap
+    useEffect(() => {
+        if (markerRef.current) {
+            // use exports to make methods accessible for stubbing
+            const mapApi = removeEventListenerMap(markerRef.current);
+            addEventListenerMap(markerRef.current, eventListenerMap, mapApi);
+        }
+    }, [eventListenerMap, markerRef.current]);
+    // If icon type changed, we need to change the marker type
+    useEffect(() => {
+        if (!(markerRef.current && icon)) {
+            return;
+        }
+        if (isDomMakerNeeded(icon)) {
+            destroyMarker(markerRef.current, api);
+            markerRef.current = setupMarker(props, api);
+        }
+        else {
+            markerRef.current.setIcon(getOrCreateIcon(icon));
+        }
+    }, [icon, markerRef.current]);
+    return null;
+};
+Marker.propTypes = {
+    position: PropTypes.oneOfType([mapProps.position, mapProps.positions]).isRequired,
+    icon: mapProps.icon,
+    eventListenerMap: PropTypes.object,
+    customData: PropTypes.object,
+    draggable: PropTypes.bool,
+};
+export default Marker;

package/components/map/components/features/basics/marker/Marker2.d.ts

@@ -0,0 +1,21 @@
+export function getOrCreateIcon(icon: any, mapType: any): H.map.DomIcon | undefined;
+export function isHMapIcon(icon: any): boolean;
+export function isDomMakerNeeded(icon: any): boolean;
+export default Marker2;
+declare function Marker2(props: any): null;
+declare namespace Marker2 {
+    namespace propTypes {
+        const position: PropTypes.Validator<NonNullable<NonNullable<PropTypes.InferProps<{
+            lat: PropTypes.Validator<number>;
+            lng: PropTypes.Validator<number>;
+        }> | (PropTypes.InferProps<{
+            lat: PropTypes.Validator<number>;
+            lng: PropTypes.Validator<number>;
+        }> | null | undefined)[] | null | undefined>>>;
+        const icon: PropTypes.Requireable<H.map.DomIcon>;
+        const eventListenerMap: PropTypes.Requireable<object>;
+        const customData: PropTypes.Requireable<object>;
+        const draggable: PropTypes.Requireable<boolean>;
+    }
+}
+import PropTypes from "prop-types";

package/components/map/components/features/basics/marker/Marker2.js

@@ -0,0 +1,215 @@
+/* eslint-disable no-undef */
+import React, { useContext, useEffect, useState, useRef } from 'react';
+import ReactDomServer from 'react-dom/server';
+import PropTypes from 'prop-types';
+import mapProps from '../../../../utils/proptypes';
+import { addEventListenerMap, removeEventListenerMap, checkAndUpdateEventListenerMap, } from '../../../../utils/eventHandling';
+import MapException from '../../../../exceptions/MapException';
+import { MapContext } from '../../../context';
+export const isHMapIcon = icon => icon instanceof H.map.Icon;
+export const isDomMakerNeeded = icon => (!icon ? false : !isHMapIcon(icon));
+export function getOrCreateIcon(icon, mapType) {
+    if (!icon || isHMapIcon(icon) || icon instanceof H.map.DomIcon) {
+        return;
+    }
+    const renderedIcon = React.isValidElement(icon)
+        ? ReactDomServer.renderToStaticMarkup(React.cloneElement(icon, { mapType }))
+        : icon;
+    return new H.map.DomIcon(renderedIcon);
+}
+// class Marker extends React.Component {
+//     constructor(props, context) {
+//         super(props, context);
+//         //console.log(context);
+//         this.setupMarker(props);
+//         console.log(this.context.mapRef);
+//     }
+//     // eslint-disable-next-line camelcase
+//     UNSAFE_componentWillReceiveProps(nextProps) {
+//         const { position, customData, icon } = this.props;
+//         checkAndUpdateEventListenerMap(this.marker, this.props, nextProps);
+//         if (position !== nextProps.position) {
+//             this.marker.setGeometry(this.getConvertedPosition(nextProps));
+//         }
+//         this.marker.draggable = !!nextProps.draggable;
+//         if (customData !== nextProps.customData) {
+//             this.marker.setData(nextProps.customData);
+//         }
+//         console.log(this.context.settings);
+//         if (icon !== nextProps.icon) {
+//             if (isDomMakerNeeded(icon) !== isDomMakerNeeded(nextProps.icon)) {
+//                 // icon type changed so we need to change the marker type
+//                 this.destroyMarker();
+//                 this.setupMarker(nextProps);
+//             } else {
+//                 this.marker.setIcon(getOrCreateIcon(nextProps.icon, this.context.settings));
+//             }
+//         }
+//     }
+//     shouldComponentUpdate() {
+//         return false;
+//     }
+//     componentWillUnmount() {
+//         this.destroyMarker();
+//     }
+//     render() {
+//         return null;
+//     }
+//     setupMarker(nextProps) {
+//         const { customData, draggable } = this.props;
+//         const MarkerConstructor = isDomMakerNeeded(nextProps.icon) ? H.map.DomMarker : H.map.Marker;
+//         this.marker = new MarkerConstructor(this.getConvertedPosition(nextProps), {
+//             icon: getOrCreateIcon(nextProps.icon, this.context.settings),
+//         });
+//         this.marker.setData(customData);
+//         this.marker.draggable = !!draggable;
+//         this.context.api.group.addObject(this.marker);
+//         addEventListenerMap(this.marker, nextProps.eventListenerMap, this.context.api.map);
+//     }
+//     destroyMarker() {
+//         removeEventListenerMap(this.marker);
+//         if (this.context.api.group.getObjects().includes(this.marker)) {
+//             this.context.api.group.removeObject(this.marker);
+//         }
+//         this.marker.dispose();
+//     }
+//     getConvertedPosition(props) {
+//         return this.convertPosition(this.getPosition(props));
+//     }
+//     getPosition(props) {
+//         const { position } = props;
+//         if (!position) {
+//             throw new MapException('Error in Marker: invalid position property');
+//         }
+//         if (Array.isArray(position)) {
+//             position.forEach(pos => this.checkPositionProperties(pos));
+//         } else {
+//             this.checkPositionProperties(position);
+//         }
+//         return position;
+//     }
+//     checkPositionProperties(position) {
+//         ['lat', 'lng'].forEach(propertyName => {
+//             // eslint-disable-next-line no-prototype-builtins
+//             if (!position.hasOwnProperty(propertyName)) {
+//                 throw new MapException(`Error in Marker: position object requires property "${propertyName}"`);
+//             }
+//         });
+//     }
+//     convertPosition(pos) {
+//         return Array.isArray(pos) ? new H.geo.MultiPoint(pos) : pos;
+//     }
+// }
+// Marker.contextType = MapContext;
+// ---------------------
+const convertPosition = pos => (Array.isArray(pos) ? new H.geo.MultiPoint(pos) : pos);
+const checkPositionProperties = position => {
+    ['lat', 'lng'].forEach(propertyName => {
+        // eslint-disable-next-line no-prototype-builtins
+        if (!position.hasOwnProperty(propertyName)) {
+            throw new MapException(`Error in Marker: position object requires property "${propertyName}"`);
+        }
+    });
+};
+const getPosition = position => {
+    if (!position) {
+        throw new MapException('Error in Marker: invalid position property');
+    }
+    if (Array.isArray(position)) {
+        position.forEach(pos => checkPositionProperties(pos));
+    }
+    else {
+        checkPositionProperties(position);
+    }
+    return position;
+};
+const getConvertedPosition = position => convertPosition(getPosition(position));
+const setupMarker = (props, api) => {
+    const { position, customData, icon, draggable, eventListenerMap } = props;
+    const MarkerConstructor = isDomMakerNeeded(icon) ? H.map.DomMarker : H.map.Marker;
+    const marker = new MarkerConstructor(getConvertedPosition(position), {
+        icon: getOrCreateIcon(icon, api.settings.baseLayer),
+    });
+    marker.setData(customData);
+    marker.draggable = !!draggable;
+    api.group.addObject(marker);
+    addEventListenerMap(marker, eventListenerMap, api.map);
+    return marker;
+};
+const destroyMarker = (marker, api) => {
+    removeEventListenerMap(marker);
+    if (api.group.getObjects().includes(marker)) {
+        api.group.removeObject(marker);
+    }
+    marker.dispose();
+};
+const Marker2 = props => {
+    const { position, customData, icon, eventListenerMap } = props;
+    const { api } = useContext(MapContext);
+    const markerRef = useRef();
+    const [currentBaseLayer, setCurrentBaseLayer] = useState(api === null || api === void 0 ? void 0 : api.settings.baseLayer);
+    useEffect(() => {
+        markerRef.current = setupMarker(props, api);
+        return () => {
+            if (markerRef.current) {
+                destroyMarker(markerRef.current, api);
+                markerRef.current = undefined;
+            }
+        };
+    }, []);
+    // Update marker position
+    useEffect(() => {
+        if (markerRef.current) {
+            markerRef.current.setGeometry(getConvertedPosition(position));
+        }
+    }, [position, markerRef.current]);
+    // Update marker custom data
+    useEffect(() => {
+        if (markerRef.current) {
+            markerRef.current.setData(customData);
+        }
+    }, [customData, markerRef.current]);
+    // Update EventListenerMap
+    useEffect(() => {
+        if (markerRef.current) {
+            // use exports to make methods accessible for stubbing
+            const mapApi = removeEventListenerMap(markerRef.current);
+            addEventListenerMap(markerRef.current, eventListenerMap, mapApi);
+        }
+    }, [eventListenerMap, markerRef.current]);
+    // In case the map base layer has changed between day and night, update the marker
+    useEffect(() => {
+        if (!markerRef.current) {
+            return;
+        }
+        const newBaseLayer = api.settings.baseLayer;
+        if (newBaseLayer !== currentBaseLayer) {
+            console.log(newBaseLayer);
+            // Update marker icons
+            markerRef.current.setIcon(getOrCreateIcon(icon, newBaseLayer));
+            setCurrentBaseLayer(newBaseLayer);
+        }
+    }, [api.settings.baseLayer, markerRef.current]);
+    // If icon type changed, we need to change the marker type
+    useEffect(() => {
+        if (!(markerRef.current && icon)) {
+            return;
+        }
+        if (isDomMakerNeeded(icon)) {
+            destroyMarker(markerRef.current, api);
+            markerRef.current = setupMarker(props, api);
+        }
+        else {
+            markerRef.current.setIcon(getOrCreateIcon(icon, api.settings.baseLayer));
+        }
+    }, [icon, markerRef.current]);
+    return null;
+};
+Marker2.propTypes = {
+    position: PropTypes.oneOfType([mapProps.position, mapProps.positions]).isRequired,
+    icon: mapProps.icon,
+    eventListenerMap: PropTypes.object,
+    customData: PropTypes.object,
+    draggable: PropTypes.bool,
+};
+export default Marker2;

package/components/map/components/features/basics/marker/TextMarker.d.ts

@@ -1,17 +1,17 @@
-export const emptyTextException: "Error in TextMarker: TextMarker without text makes no sense";
-export const wrongTypeException: "Error in TextMarker: property text must be string type";
-export default TextMarker;
-declare function TextMarker(props: any): JSX.Element;
-declare namespace TextMarker {
-    namespace propTypes {
-        const position: PropTypes.Validator<NonNullable<NonNullable<PropTypes.InferProps<{
-            lat: PropTypes.Validator<number>;
-            lng: PropTypes.Validator<number>;
-        }> | (PropTypes.InferProps<{
-            lat: PropTypes.Validator<number>;
-            lng: PropTypes.Validator<number>;
-        }> | null | undefined)[] | null | undefined>>>;
-        const text: PropTypes.Validator<string>;
-    }
-}
-import PropTypes from "prop-types";
+export const emptyTextException: "Error in TextMarker: TextMarker without text makes no sense";
+export const wrongTypeException: "Error in TextMarker: property text must be string type";
+export default TextMarker;
+declare function TextMarker(props: any): import("react/jsx-runtime").JSX.Element;
+declare namespace TextMarker {
+    namespace propTypes {
+        const position: PropTypes.Validator<NonNullable<NonNullable<PropTypes.InferProps<{
+            lat: PropTypes.Validator<number>;
+            lng: PropTypes.Validator<number>;
+        }> | (PropTypes.InferProps<{
+            lat: PropTypes.Validator<number>;
+            lng: PropTypes.Validator<number>;
+        }> | null | undefined)[] | null | undefined>>>;
+        const text: PropTypes.Validator<string>;
+    }
+}
+import PropTypes from "prop-types";

package/components/map/components/features/basics/marker/TextMarker.js

@@ -1,28 +1,28 @@
-import { __rest } from "tslib";
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from 'react';
-import PropTypes from 'prop-types';
-import MapException from '../../../../exceptions/MapException';
-import mapProps from '../../../../utils/proptypes';
-import Marker from './Marker';
-export const emptyTextException = 'Error in TextMarker: TextMarker without text makes no sense';
-export const wrongTypeException = 'Error in TextMarker: property text must be string type';
-const TextMarker = props => {
-    const other = __rest(props, []);
-    const textDiv = `<div class="bg-white padding-x-5 padding-y-3 border border-color-darker shadow-accent">${getText(props.text)}</div>`;
-    return _jsx(Marker, Object.assign({}, other, { icon: textDiv }));
-};
-const getText = text => {
-    if (!text) {
-        throw new MapException(emptyTextException);
-    }
-    if (typeof text !== 'string') {
-        throw new MapException(wrongTypeException);
-    }
-    return text;
-};
-TextMarker.propTypes = {
-    position: PropTypes.oneOfType([mapProps.position, mapProps.positions]).isRequired,
-    text: PropTypes.string.isRequired,
-};
-export default TextMarker;
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import PropTypes from 'prop-types';
+import MapException from '../../../../exceptions/MapException';
+import mapProps from '../../../../utils/proptypes';
+import Marker from './Marker';
+export const emptyTextException = 'Error in TextMarker: TextMarker without text makes no sense';
+export const wrongTypeException = 'Error in TextMarker: property text must be string type';
+const TextMarker = props => {
+    const other = __rest(props, []);
+    const textDiv = `<div class="bg-white padding-x-5 padding-y-3 border border-color-darker shadow-accent">${getText(props.text)}</div>`;
+    return _jsx(Marker, Object.assign({}, other, { icon: textDiv }));
+};
+const getText = text => {
+    if (!text) {
+        throw new MapException(emptyTextException);
+    }
+    if (typeof text !== 'string') {
+        throw new MapException(wrongTypeException);
+    }
+    return text;
+};
+TextMarker.propTypes = {
+    position: PropTypes.oneOfType([mapProps.position, mapProps.positions]).isRequired,
+    text: PropTypes.string.isRequired,
+};
+export default TextMarker;

package/components/map/components/features/layers/IncidentsLayer.d.ts

@@ -1,2 +1,2 @@
-export default IncidentsLayer;
-declare function IncidentsLayer(props: any): JSX.Element;
+export default IncidentsLayer;
+declare function IncidentsLayer(props: any): import("react/jsx-runtime").JSX.Element;

package/components/map/components/features/layers/IncidentsLayer.js

@@ -1,9 +1,25 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/* eslint-disable no-undef */
-import React from 'react';
-import Layer from './Layer';
-function getIncidentsLayer(api) {
-    return api.defaultLayers.vector.normal.trafficincidents;
-}
-const IncidentsLayer = props => _jsx(Layer, Object.assign({}, props, { createLayer: getIncidentsLayer }));
-export default IncidentsLayer;
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import Layer from './Layer';
+// Layer that shows construction sites marker that are interactive and use a popup for details
+// Since "vector.normal.trafficincidents" is deprecated we have to use the Here Traffic Service v7
+// see: https://developer.here.com/documentation/maps/3.1.46.0/api_reference/H.service.Platform.html
+const createTrafficIncidentsLayer = api => {
+    const config = `
+  sources:
+    omv:
+        type: OMV
+  layers:
+    incident_icons:
+        data: {source: omv}
+`;
+    return api.platform.getTrafficVectorTileService().createLayer(new H.map.render.webgl.Style(config));
+};
+// For raster map, we use the old deprecated fallback for now
+const createTrafficIncidentsLayerFallback = api => api.defaultLayers.vector.normal.trafficincidents;
+const IncidentsLayer = props => {
+    const { useWebGL } = props, remainingProps = __rest(props, ["useWebGL"]);
+    return (_jsx(Layer, Object.assign({}, remainingProps, { createLayer: useWebGL ? createTrafficIncidentsLayer : createTrafficIncidentsLayerFallback })));
+};
+export default IncidentsLayer;

package/components/map/components/features/layers/Layer.d.ts

@@ -1,16 +1,15 @@
-export default Layer;
-declare function Layer(props: any): null;
-declare namespace Layer {
-    namespace propTypes {
-        const api: PropTypes.Requireable<PropTypes.InferProps<{
-            map: PropTypes.Requireable<any>;
-            platform: PropTypes.Requireable<any>;
-            defaultLayers: PropTypes.Requireable<object>;
-            group: PropTypes.Requireable<any>;
-        }>>;
-        const createLayer: PropTypes.Validator<(...args: any[]) => any>;
-        const language: PropTypes.Requireable<string>;
-        const layerIndex: PropTypes.Requireable<number>;
-    }
-}
-import PropTypes from "prop-types";
+export default Layer;
+declare function Layer(props: any): null;
+declare namespace Layer {
+    namespace propTypes {
+        const api: PropTypes.Requireable<PropTypes.InferProps<{
+            map: PropTypes.Requireable<H.Map>;
+            platform: PropTypes.Requireable<H.service.Platform>;
+            defaultLayers: PropTypes.Requireable<object>;
+            group: PropTypes.Requireable<NonNullable<H.Map | H.map.Group | null | undefined>>;
+        }>>;
+        const createLayer: PropTypes.Validator<(...args: any[]) => any>;
+        const layerIndex: PropTypes.Requireable<number>;
+    }
+}
+import PropTypes from "prop-types";