@opengeoweb/core 19.0.0 → 19.1.1

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

@@ -0,0 +1,329 @@
+import type { mapTypes } from '@opengeoweb/store';
+import type { DimensionTooltipGenerator, SingleValueComponentProps } from './LayerContainerRow/LayerRow/DimensionSelect/DimensionSelect';
+import type { Size, ToolbarButtonSettings } from './LayerManagerHeaderOptions';
+export declare const columnClasses: {
+    column1: string;
+    columnService: string;
+    column2: string;
+    column3: string;
+    column4: string;
+    column5: string;
+    column6: string;
+    column7: string;
+    acceptanceTime: string;
+    loadDuration: string;
+    columnHeader: string;
+    baseLayer: string;
+    columnTarget: string;
+};
+export declare const leftButtonsStyle: {
+    width: number;
+    display: string;
+    background: string;
+};
+export declare const layerManagerStyle: {
+    '.column-hover-icon': {
+        display: string;
+    };
+    '.columnHeader:hover': {
+        backgroundColor: string;
+        cursor: string;
+        '.column-hover-icon': {
+            display: string;
+        };
+    };
+    '.layerManagerContainer': {
+        containerType: string;
+    };
+    '.descriptionRow': {
+        height: string;
+        marginTop: string;
+        marginBottom: string;
+    };
+    '.is-dragging header+.MuiBox-root': {
+        overflow: string;
+    };
+    '.baseLayer': {
+        width: string;
+    };
+    '.column-service': {
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        flexGrow: number;
+        width: string;
+    };
+    '.column-2': {
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        flexGrow: number;
+        width: string;
+    };
+    '.column-3': {
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        flexGrow: number;
+        width: string;
+    };
+    '.column-4': {
+        flexGrow: number;
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        width: number;
+    };
+    '.column-5': {
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        flexGrow: number;
+        width: string;
+    };
+    '.column-acceptanceTime': {
+        flexGrow: number;
+        height: string;
+        alignContent: string;
+        alignItems: string;
+        display: string;
+        justifyContent: string;
+        whiteSpace: string;
+        overflow: string;
+        color: string;
+        width: number;
+    };
+    '.column-loadDuration': {
+        width: number;
+        paddingLeft: number;
+        paddingRight: number;
+    };
+    '.column-6': {
+        width: number;
+        display: string;
+        marginLeft: string;
+    };
+    '.column-7': {
+        width: string;
+    };
+    '.enable-btn-mini': {
+        display: string;
+    };
+    '.header-layermanager': {
+        containerType: string;
+    };
+    '.medium-layermanager': {
+        display: string;
+    };
+    '.collapseLarge-btn': {
+        display: string;
+    };
+    '@container (max-width: 320px)': {
+        '.layermanager': {
+            '.column-1': {
+                width: string;
+            };
+            '.enable-btn-mini': {
+                display: string;
+            };
+            '.activateLayer-btn, .enable-btn, .column-service, .column-2, .column-3, .column-4, .column-5, .column-6, .column-7, .column-acceptanceTime, .column-loadDuration': {
+                display: string;
+            };
+            '.addLayer-column, .setProjection-column, .overlayers-column': {
+                display: string;
+            };
+            '.descriptionRow': {
+                height: number;
+                '.MuiButtonBase-root': {
+                    display: string;
+                };
+            };
+        };
+        '.header-layermanager': {
+            '.header-left': {
+                display: string;
+            };
+            '&>div': {
+                justifyContent: string;
+                padding: number;
+                height: number;
+            };
+            '.header-right': {
+                maxWidth: string;
+                flexBasis: string;
+            };
+            '.collapseSmall-btn': {
+                display: string;
+            };
+        };
+    };
+    '@container (max-width: 600px)': {
+        '.layermanager': {
+            '.column-service, .column-2, .column-3, .column-4, .column-5, .column-6, .column-7, .column-acceptanceTime, .column-loadDuration': {
+                display: string;
+            };
+            '.columnLayerName, .baseLayer': {
+                width: string;
+            };
+        };
+        '.header-layermanager': {
+            '.collapseLarge-btn': {
+                display: string;
+            };
+        };
+    };
+    '@container (max-width: 600px) and (min-width: 321px)': {
+        '.layermanager': {
+            '.medium-layermanager': {
+                display: string;
+            };
+        };
+        '.deleteBtnMedium': {
+            display: string;
+            '&+button': {
+                display: string;
+            };
+        };
+        '.layerRow': {
+            '.column-1': {
+                display: string;
+            };
+            '.column-2': {
+                display: string;
+            };
+        };
+        '.header-layermanager': {
+            '.collapseMedium-btn': {
+                display: string;
+            };
+        };
+    };
+};
+export declare const returnCorrectSize: (sizeResult: mapTypes.DockedLayerManagerSize | undefined) => Size;
+export type DimensionNameMappings = Record<string, string>;
+export type DimensionValueMappings = Record<string, (value: string, latest?: string) => string>;
+export interface LayerManagerCustomSettings {
+    toolbar?: {
+        dragHandle?: {
+            icon?: React.ReactNode;
+        };
+        controlButtonSettings?: ToolbarButtonSettings;
+        closeButton?: {
+            icon?: React.ReactNode;
+        };
+    };
+    header?: {
+        addLayer?: {
+            tooltipTitle?: string;
+            icon?: React.ReactNode;
+        };
+        layerService?: {
+            title: string;
+        };
+        layerName?: {
+            title: string;
+        };
+        layerStyle?: {
+            title: string;
+        };
+        opacity?: {
+            title: string;
+        };
+        dimensions?: {
+            title: string;
+        };
+        acceptanceTime?: {
+            title: string;
+        };
+    };
+    content?: {
+        dragHandle?: {
+            tooltipTitle?: string;
+            icon?: React.ReactNode;
+        };
+        activateLayer?: {
+            isDisabled?: boolean;
+        };
+        enableLayer?: {
+            enabledIcon?: React.ReactNode;
+            disabledIcon?: React.ReactNode;
+            enabledTooltipTitle?: string;
+            disabledTooltipTitle?: string;
+        };
+        renderLayer?: {
+            Element?: React.FC<{
+                layerId: string;
+                mapId: string;
+            }>;
+            tooltipPrefix?: string;
+        };
+        layerStyle?: {
+            tooltipPrefix?: string;
+            icon?: React.ElementType;
+        };
+        opacity?: {
+            tooltipPrefix?: string;
+        };
+        acceptanceTime?: {
+            tooltipTitle?: string;
+            icon?: React.ElementType;
+        };
+        dimensions?: {
+            dimensionsToShow?: string[];
+            SingleValueComponent?: React.FC<SingleValueComponentProps>;
+            icon?: React.ElementType;
+            tooltipGenerator?: DimensionTooltipGenerator;
+            nameMappings?: DimensionNameMappings;
+            valueMappings?: DimensionValueMappings;
+            hideLatestDuplicate?: boolean;
+        };
+        deleteLayer?: {
+            tooltipTitle?: string;
+            icon?: React.ReactNode;
+        };
+        menu?: {
+            tooltipTitle?: string;
+            icon?: React.ReactNode;
+        };
+    };
+    footer?: {
+        baseLayerRow?: {
+            title?: string;
+            addLayersButton?: {
+                isDisabled?: boolean;
+            };
+        };
+        baseLayerDropdown?: {
+            tooltipPrefix?: string;
+            icon?: React.ElementType;
+        };
+        projection?: {
+            shouldHide?: boolean;
+        };
+    };
+}

package/dist/src/lib/components/LayerManager/LayerSelect/LayerSelectButton.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface LayerSelectButtonProps {
+    tooltipTitle?: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+}
+export declare const LayerSelectButton: React.FC<LayerSelectButtonProps>;
+export {};

package/dist/src/lib/components/LayerManager/OverlayersRow/OverlayersSelect.d.ts

@@ -0,0 +1,15 @@
+export interface OverLayer {
+    id: string;
+    name: string;
+}
+interface OverlayersSelectProps {
+    mapId: string;
+    selectedOverlayer: OverLayer;
+    onChangeOverlayer: (mapId: string, selectedOverlayer: OverLayer) => void;
+    availableOverlayers?: {
+        id: string;
+        name: string;
+    }[];
+}
+declare const OverlayersSelect: React.FC<OverlayersSelectProps>;
+export default OverlayersSelect;

package/dist/src/lib/components/LayerManager/OverlayersRow/OverlayersSelectConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface OverlayersSelectConnectProps {
+    mapId?: string;
+}
+declare const OverlayersSelectConnect: React.FC<OverlayersSelectConnectProps>;
+export default OverlayersSelectConnect;

package/dist/src/lib/components/LayerManager/ProjectionSelect/ProjectionSelect.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { Bbox } from '@opengeoweb/webmap';
+export interface ProjectionDetails {
+    name: string;
+    value: string;
+    bbox: Bbox;
+}
+export declare const availableProjections: ProjectionDetails[];
+export interface ProjectionSelectProps {
+    currentProjection: string;
+    onChangeProjection: (projection: ProjectionDetails) => void;
+}
+declare const ProjectionSelect: React.FC<ProjectionSelectProps>;
+export default ProjectionSelect;

package/dist/src/lib/components/LayerManager/ProjectionSelect/ProjectionSelectConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface ProjectionSelectConnectProps {
+    mapId: string;
+}
+declare const ProjectionSelectConnect: React.FC<ProjectionSelectConnectProps>;
+export default ProjectionSelectConnect;

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

@@ -0,0 +1,9 @@
+export { default as LayerManager } from './LayerManager';
+export { default as LayerManagerHeaderOptions } from './LayerManagerHeaderOptions';
+export { default as LayerManagerDescriptionRow } from './DescriptionRow/DescriptionRow';
+export { default as LayerManagerLayerContainerRow } from './LayerContainerRow/LayerContainerRow';
+export { default as LayerManagerBaseLayerRow } from './BaseLayerRow/BaseLayerRow';
+export { default as LayerManagerConnect } from './LayerManagerConnect';
+export { default as LayerManagerMapButtonConnect } from './LayerManagerMapButtonConnect';
+export { default as LoadingIndicatorProgressBar } from './LayerContainerRow/LayerRow/LoadDuration/LoadingIndicatorProgressBar';
+export { useFetchServices } from './useFetchServices';

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

@@ -0,0 +1,4 @@
+import type { serviceTypes, uiTypes } from '@opengeoweb/store';
+export declare const getServicesToLoad: (services: serviceTypes.NoIdService[]) => Promise<serviceTypes.InitialService[]>;
+export declare const useFetchServices: (dialogType: uiTypes.DialogType, preloadedServices?: serviceTypes.InitialService[], shouldDisableFetch?: boolean) => void;
+export declare const mergePresetsAndUserAddedServices: (presets: serviceTypes.InitialService[], userAddedServices: serviceTypes.UserAddedServices) => serviceTypes.NoIdService[];

package/dist/src/lib/components/LegendConnect/LegendConnect.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { uiTypes } from '@opengeoweb/store';
+interface LegendConnectProps {
+    showMapId?: boolean;
+    source?: uiTypes.Source;
+    mapId?: string;
+    multiLegend?: boolean;
+}
+/**
+ * Legend component connected to the store displaying a legend for every layer shown on the active map Id
+ * Please note that in order to use this and open/close the dialog, every map on the screen that should be able to show
+ * a dialog should have the <LegendMapButtonConnect/> which is used to focus the correct map and open the dialog
+ *
+ * Expects the following props:
+ * @param {boolean} showMapId (optional) showMapId: boolean - show the id of the map in the dialog title of which the legend is shown in te dialog
+ * @param {uiTypes.Source} source (optional) source: uiTypes.Source - default is 'app', 'module' makes sure it will be shown on top of the module
+
+ * ``` <LegendConnect legendDialogId={legendDialogId} />```
+ */
+declare const LegendConnect: React.FC<LegendConnectProps>;
+export default LegendConnect;

package/dist/src/lib/components/LegendConnect/LegendMapButtonConnect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { uiTypes } from '@opengeoweb/store';
+interface LegendMapButtonProps {
+    mapId: string;
+    source?: uiTypes.Source;
+    multiLegend?: boolean;
+}
+declare const LegendMapButtonConnect: React.FC<LegendMapButtonProps>;
+export default LegendMapButtonConnect;

package/dist/src/lib/components/LegendConnect/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LegendConnect } from './LegendConnect';
+export { default as LegendMapButtonConnect } from './LegendMapButtonConnect';

package/dist/src/lib/components/LocationSearch/LocationSearch.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { LocationDetail } from './types';
+export interface LocationSearchProps {
+    isOpen: boolean;
+    mapId?: string;
+    onSelectLocation?: (location?: LocationDetail) => void;
+    onUpdateMyLocation?: (location?: LocationDetail) => void;
+    isMyLocationSelected?: boolean;
+}
+export declare const LocationSearch: React.FC<LocationSearchProps>;

package/dist/src/lib/components/LocationSearch/LocationSearchConnect.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface LocationSearchConnectProps {
+    mapId?: string;
+}
+export declare const LocationSearchConnect: React.FC<LocationSearchConnectProps>;

package/dist/src/lib/components/LocationSearch/MyMapLocation.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LocationDetail } from './types';
+export interface MyMapLocationProps {
+    mapId?: string;
+    isSelected?: boolean;
+    onUpdateMyLocation?: (location?: LocationDetail) => void;
+}
+export declare const MY_LOCATION = "My location";
+export declare const MyMapLocation: React.FC<MyMapLocationProps>;

package/dist/src/lib/components/LocationSearch/SearchControlButtonConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { CustomIconProps } from '@opengeoweb/shared';
+import { uiTypes } from '@opengeoweb/store';
+export interface SearchControlButtonConnectProps extends CustomIconProps {
+    mapId: string;
+    source?: uiTypes.Source;
+}
+export declare const SearchControlButtonConnect: React.FC<SearchControlButtonConnectProps>;

package/dist/src/lib/components/LocationSearch/index.d.ts

@@ -0,0 +1,5 @@
+export { SearchControlButtonConnect } from './SearchControlButtonConnect';
+export { LocationSearchConnect } from './LocationSearchConnect';
+export { LocationSearch } from './LocationSearch';
+export { MyMapLocation } from './MyMapLocation';
+export type * as LocationSearchTypes from './types';

package/dist/src/lib/components/LocationSearch/types.d.ts

@@ -0,0 +1,23 @@
+export interface LocationDetail {
+    id: string;
+    name: string;
+    source: string;
+    lat: number;
+    lon: number;
+    geometry?: GeoJSON.Feature;
+    bbox?: GeoJSON.BBox;
+}
+export interface PredefinedLocation extends LocationDetail {
+    group?: 'airport' | 'country' | 'city' | 'region' | 'special';
+    source: 'predefined';
+}
+export interface LocationListResult {
+    id: string;
+    name: string;
+    source: string;
+    group?: 'airport' | 'country' | 'city' | 'region' | 'special';
+}
+export interface PredefinedOption extends LocationListResult {
+    groupHeader?: string;
+    groupIcon?: React.ElementType;
+}

package/dist/src/lib/components/LocationSearch/utils.d.ts

@@ -0,0 +1,8 @@
+import type { GeoJsonProperties } from 'geojson';
+import type { LocationDetail } from './types';
+export declare const geometryStyling: GeoJsonProperties;
+export declare const bufferFromZoomLevel: (zoom: number, lat: number, viewportWidthPx: number) => number;
+export declare const bboxFromPolygon: (geom: GeoJSON.Geometry, buffer: number) => number[];
+export declare const bboxFromPoint: (geom: GeoJSON.Geometry, buffer: number) => number[];
+export declare const useShiftPressed: () => boolean;
+export declare const useDrawOnMap: (mapId: string) => [(location?: LocationDetail) => void];

package/dist/src/lib/components/MapDrawToolRedux/OpenLayersFeatureLayerConnect.d.ts

@@ -0,0 +1,21 @@
+import type { StyleLike } from 'ol/style/Style';
+import React from 'react';
+import type { layerTypes } from '@opengeoweb/store';
+import type { HoverSelect } from '@opengeoweb/webmap-react';
+interface SelectionState {
+    geojson?: GeoJSON.FeatureCollection;
+    selectedFeatureIds?: string[];
+}
+export declare const getCurrentSelectedIndices: ({ geojson, selectedFeatureIds, }: SelectionState) => number[];
+export declare const calculateNewSelection: (currentSelectedIndices: number[], clickedIndex: number, isShiftClick: boolean) => number[];
+export declare const getAffectedIndices: (oldSelection: number[], newSelection: number[]) => number[];
+export declare const shouldEnterEditMode: (isReadonly: boolean, isShiftClick: boolean, newSelectionCount: number) => boolean;
+interface OpenLayersFeatureLayerConnectProps {
+    layer: layerTypes.ReduxLayer;
+    layerId?: string;
+    zIndex: number;
+    style: StyleLike;
+    hoverSelect?: HoverSelect;
+}
+export declare const OpenLayersFeatureLayerConnect: React.FC<OpenLayersFeatureLayerConnectProps>;
+export {};

package/dist/src/lib/components/MapOptions/FeatureInfo/GetFeatureInfoButtonConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { uiTypes } from '@opengeoweb/store';
+interface GetFeatureInfoButtonProps {
+    mapId: string;
+    source?: uiTypes.Source;
+}
+declare const GetFeatureInfoButtonConnect: React.FC<GetFeatureInfoButtonProps>;
+export default GetFeatureInfoButtonConnect;

package/dist/src/lib/components/MapOptions/FeatureInfo/GetFeatureInfoConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const IS_GETFEATUREINFO_OPEN_BY_DEFAULT = false;
+interface GetFeatureInfoConnectProps {
+    showMapId?: boolean;
+    mapId: string;
+}
+declare const GetFeatureInfoConnect: React.FC<GetFeatureInfoConnectProps>;
+export default GetFeatureInfoConnect;

package/dist/src/lib/components/MapOptions/FeatureInfo/GetFeatureInfoDialog.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { layerTypes, uiTypes } from '@opengeoweb/store';
+import type { MapLocation } from '@opengeoweb/webmap-react';
+interface GetFeatureInfoDialogProps {
+    layers: layerTypes.Layer[];
+    isOpen: boolean;
+    onClose: () => void;
+    onMouseDown?: () => void;
+    mapId: string;
+    showMapId?: boolean;
+    order?: number;
+    source?: uiTypes.Source;
+    mapPinLocation?: MapLocation;
+}
+declare const GetFeatureInfoDialog: React.FC<GetFeatureInfoDialogProps>;
+export default GetFeatureInfoDialog;

package/dist/src/lib/components/MapOptions/FeatureInfo/index.d.ts

@@ -0,0 +1,3 @@
+import GetFeatureInfoConnect from './GetFeatureInfoConnect';
+export { default as GetFeatureInfoButtonConnect } from './GetFeatureInfoButtonConnect';
+export { GetFeatureInfoConnect };

package/dist/src/lib/components/MapOptions/FeatureInfo/utils.d.ts

@@ -0,0 +1,19 @@
+import type { layerTypes } from '@opengeoweb/store';
+import type { MapLocation } from '@opengeoweb/webmap-react';
+export interface GFIResult {
+    data: string;
+    isLoading: boolean;
+}
+export interface GFILayer {
+    layerId: string;
+    url: string;
+    title: string;
+}
+export declare const getFeatureInfoUrl: (layer: layerTypes.Layer, mapPinLocation: MapLocation | null) => string | undefined;
+/**
+ * Make a list of GFI Layers to display.
+ * @param layers
+ * @param mapId
+ * @returns
+ */
+export declare const getLayersToUpdate: (mapPinLocation: MapLocation | null, layers: layerTypes.Layer[]) => GFILayer[];

package/dist/src/lib/components/MapOptions/MapOptionsButtonConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface MapOptionsButtonProps {
+    mapId: string;
+    getFeatureInfo?: boolean;
+    measureTool?: boolean;
+}
+export declare const MapOptionsButtonConnect: React.FC<MapOptionsButtonProps>;
+export {};

package/dist/src/lib/components/MapOptions/MeasureTool/MeasureToolButton.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface MeasureToolButtonProps {
+    isActive: boolean;
+    setIsActive: (isActive: boolean) => void;
+}
+export declare const MeasureToolButton: React.FC<MeasureToolButtonProps>;
+export {};

package/dist/src/lib/components/MapOptions/MeasureTool/index.d.ts

@@ -0,0 +1,2 @@
+import { MeasureToolButton } from './MeasureToolButton';
+export { MeasureToolButton };

package/dist/src/lib/components/MapOptions/index.d.ts

@@ -0,0 +1,4 @@
+import { MapOptionsButtonConnect } from './MapOptionsButtonConnect';
+export * from './FeatureInfo';
+export * from './MeasureTool';
+export { MapOptionsButtonConnect };

package/dist/src/lib/components/MapViewConnect/OlMapViewConnect.d.ts

@@ -0,0 +1,40 @@
+import type { StyleLike } from 'ol/style/Style';
+import React from 'react';
+import type { Source } from '@opengeoweb/shared';
+import type { Bbox, TileServerSettings } from '@opengeoweb/webmap';
+export interface MapControlsProps {
+    mapControlsPositionTop?: number;
+    search?: boolean;
+    zoomControls?: boolean;
+    layerManagerAndLegend?: boolean;
+    multiLegend?: boolean;
+    dimensionSelect?: boolean;
+    getFeatureInfo?: boolean;
+    dataExplorerButton?: boolean;
+    measureToolButton?: boolean;
+    additionalMapControls?: React.ReactNode;
+}
+export interface OlMapViewConnectProps {
+    mapId: string;
+    children?: React.ReactNode;
+    controls?: MapControlsProps;
+    initialBbox?: Bbox;
+    holdShiftToScroll?: boolean;
+    displayTimeInMap?: boolean;
+    showScaleBar?: boolean;
+    shouldAutoFetch?: number | boolean;
+    shouldDisablePrefetching?: boolean;
+    tileServerSettings?: TileServerSettings;
+    source?: Source;
+    featureStyle?: StyleLike;
+}
+/**
+ * Connected component used to display the map and selected layers.
+ * Includes options to disable the map controls and legend.
+ *
+ * Expects the following props:
+ * @param {string} mapId mapId: string - Id of the map
+ * @param {object} [controls.zoomControls] **optional** controls: object - toggle the map controls, zoomControls defaults to true
+ */
+declare const OlMapViewConnect: React.FC<OlMapViewConnectProps>;
+export default OlMapViewConnect;