@opengeoweb/core 19.1.0 → 19.1.1

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { LayerManagerCustomSettings } from '../../LayerManagerUtils';
+interface LayerRowConnectProps {
+    layerId: string;
+    mapId: string;
+    dragHandle: React.ReactElement;
+    settings?: LayerManagerCustomSettings['content'];
+    collapsedColumns?: Record<string, boolean>;
+}
+declare const LayerRowConnect: React.FC<LayerRowConnectProps>;
+export default LayerRowConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/LayerService/LayerService.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface LayerServiceProps {
+    serviceName: string;
+    isEnabled?: boolean;
+    tooltipPrefix?: string;
+}
+declare const LayerService: React.FC<LayerServiceProps>;
+export default LayerService;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/LoadDuration/LoadDuration.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export declare const MAX_DURATION_IN_SECONDS = 60;
+export declare const MIN_DURATION_IN_SECONDS = 0.1;
+export declare const DECIMALS_IN_LABEL = 1;
+export declare const DECIMALS_IN_TOOLTIP = 3;
+declare const LoadDuration: React.FC<{
+    mapId: string;
+    layerId: string;
+}>;
+/**
+ * Hook to subscribe to changes in the load duration for a map layer.
+ * This will only trigger a render when the load duration rounded down to seconds changes for the given layer and map combination
+ * @param mapId
+ * @param layerId
+ * @returns {number}
+ */
+export declare const useLoadDurationLabel: (mapId: string, layerId: string) => [string | undefined, number];
+export default LoadDuration;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/LoadDuration/LoadingIndicatorProgressBar.d.ts

@@ -0,0 +1,9 @@
+interface LoadingIndicatorProgressBarProps {
+    progressPercentage: number;
+    width?: number;
+    height?: number;
+    top?: number;
+    left?: number;
+}
+declare const LoadingIndicatorProgressBar: ({ progressPercentage, width: loadingBarWidthInPx, height: loadingBarHeightPx, top, left, }: LoadingIndicatorProgressBarProps) => React.ReactElement;
+export default LoadingIndicatorProgressBar;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/Menubutton/MenuButton.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface LayerManagerButtonProps {
+    mapId: string;
+    layerId?: string;
+    isFeatureLayer?: boolean;
+    onLayerDuplicate?: (payload: {
+        mapId: string;
+        layerId: string;
+    }) => void;
+    onLayerCopyToOtherMaps?: () => void;
+    onLayerRemoveFromOtherMaps?: () => void;
+    tooltipTitle?: string;
+    icon?: React.ReactNode;
+}
+declare const LayerManagerMenuButton: React.FC<LayerManagerButtonProps>;
+export default LayerManagerMenuButton;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/Menubutton/MenuButtonConnect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface LayerManagerButtonProps {
+    mapId: string;
+    layerId?: string;
+    tooltipTitle?: string;
+    icon?: React.ReactNode;
+}
+declare const LayerManagerMenuButtonConnect: React.FC<LayerManagerButtonProps>;
+export default LayerManagerMenuButtonConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/MissingData/MissingData.d.ts

@@ -0,0 +1,16 @@
+import type { FC } from 'react';
+export declare const GREEN: {
+    backgroundColor: string;
+    borderColor: string;
+};
+export declare const RED: {
+    backgroundColor: string;
+    borderColor: string;
+};
+export declare const ORANGE: {
+    backgroundColor: string;
+    borderColor: string;
+};
+export declare const MissingData: FC<{
+    layerIsInsideAcceptanceTime: 'equal' | 'inside' | 'outside';
+}>;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/MissingData/MissingDataConnect.d.ts

@@ -0,0 +1,5 @@
+import type { FC } from 'react';
+export declare const MissingDataConnect: FC<{
+    mapId: string;
+    layerId?: string;
+}>;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/OpacitySelect/OpacitySelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface OpacitySelectProps {
+    currentOpacity: number;
+    onLayerChangeOpacity: (opacity: number) => void;
+    isEnabled?: boolean;
+    tooltipPrefix?: string;
+}
+declare const OpacitySelect: React.FC<OpacitySelectProps>;
+export default OpacitySelect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/OpacitySelect/OpacitySelectConnect.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface OpacitySelectConnectProps {
+    layerId: string;
+    mapId: string;
+    tooltipPrefix?: string;
+}
+declare const OpacitySelectConnect: React.FC<OpacitySelectConnectProps>;
+/**
+ * Contains a select allowing you to change the opacity of a layer on the map
+ *
+ * Expects the following props:
+ * @param {string} layerId layerId: string - Id of the layer
+ * @example
+ * ``` <OpacitySelectConnect layerId="layerid_1"/> ```
+ */
+export default OpacitySelectConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderLayers/RenderEDRLayers.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { EDRFeatureLayerOptions, LayerProps } from '@opengeoweb/webmap';
+export interface RenderEDRLayersProps {
+    onChangeLayerOptions: (options: EDRFeatureLayerOptions) => void;
+    selectedParams: string[];
+    layers: LayerProps[];
+    layerName: string;
+    collectionId: string;
+    isEnabled?: boolean;
+    tooltipPrefix?: string;
+    skipLocalStyling?: boolean;
+}
+export declare const getRenderEDRLayersValues: (selectedParams: string[], layers: LayerProps[]) => {
+    currentValues: string[];
+    extendedLayers: LayerProps[];
+};
+declare const RenderEDRLayers: React.FC<RenderEDRLayersProps>;
+export default RenderEDRLayers;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderLayers/RenderLayerName.d.ts

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

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

@@ -0,0 +1,14 @@
+import type { i18n, TFunction } from 'i18next';
+import React from 'react';
+import type { LayerProps } from '@opengeoweb/webmap';
+export declare const showNoLayers: (t: TFunction<"core", i18n>) => React.ReactElement;
+export interface RenderLayersProps {
+    onChangeLayerName: (name: string) => void;
+    layerName: string;
+    layers: LayerProps[];
+    isEnabled?: boolean;
+    tooltipPrefix?: string;
+    skipLocalStyling?: boolean;
+}
+declare const RenderLayers: React.FC<RenderLayersProps>;
+export default RenderLayers;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderLayers/RenderLayersConnect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface RenderLayersProps {
+    layerId: string;
+    mapId: string;
+    tooltipPrefix?: string;
+    skipLocalStyling?: boolean;
+}
+declare const RenderLayersConnect: React.FC<RenderLayersProps>;
+export default RenderLayersConnect;

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { Style } from '@opengeoweb/webmap';
+export interface RenderStylesProps {
+    layerStyles: Style[];
+    currentLayerStyle: string;
+    onChangeLayerStyle: (style: string) => void;
+    isStacGeoTIFFLayer?: boolean;
+    isEnabled?: boolean;
+    icon?: React.ElementType;
+    tooltipPrefix?: string;
+    skipLocalStyling?: boolean;
+}
+declare const RenderStyles: React.FC<RenderStylesProps>;
+export default RenderStyles;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/RenderStyles/RenderStylesConnect.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface RenderStylesProps {
+    layerId: string;
+    mapId: string;
+    icon?: React.ElementType;
+    tooltipPrefix?: string;
+    skipLocalStyling?: boolean;
+}
+declare const RenderStylesConnect: React.FC<RenderStylesProps>;
+export default RenderStylesConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/SelectableFeaturesCheckbox/SelectableFeaturesCheckbox.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface SelectableFeaturesProps {
+    layerId: string;
+    isSelectable: boolean;
+    onToggleSelectable: () => void;
+}
+declare const SelectableFeatures: React.FC<SelectableFeaturesProps>;
+export default SelectableFeatures;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/SelectableFeaturesCheckbox/SelectableFeaturesCheckboxConnect.d.ts

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

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

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { DraggablePosition, Position, DraggableSize, HeaderSize } from '@opengeoweb/shared';
+import type { layerTypes, mapTypes, serviceTypes, uiTypes } from '@opengeoweb/store';
+import type { LayerManagerCustomSettings } from './LayerManagerUtils';
+interface LayerManagerProps {
+    mapId: string;
+    preloadedAvailableBaseLayers?: layerTypes.Layer[];
+    preloadedBaseServices?: serviceTypes.InitialService[];
+    bounds?: string;
+    title?: string;
+    onClose: () => void;
+    onMouseDown?: () => void;
+    isOpen: boolean;
+    order?: number;
+    source?: uiTypes.Source;
+    isLoading?: boolean;
+    error?: string;
+    isDockedLayerManager?: boolean;
+    onToggleDock?: () => void;
+    onDockedLayerManagerDragEnd?: (position: DraggablePosition) => void;
+    onDockedLayerManagerSizeChange?: (size: mapTypes.DockedLayerManagerSize) => void;
+    onDockedLayerManagerDimensionsChange?: (dimensions: mapTypes.DockedLayerManagerDimensions) => void;
+    size?: DraggableSize;
+    startDraggablePosition?: DraggablePosition;
+    startPosition?: Position;
+    settings?: LayerManagerCustomSettings;
+    headerSize?: HeaderSize;
+    addLayerComponent?: React.ReactElement;
+    defaultCollapsedColumns?: Record<string, boolean>;
+}
+declare const LayerManager: React.FC<LayerManagerProps>;
+export default LayerManager;

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { layerTypes, serviceTypes } from '@opengeoweb/store';
+import { uiTypes } from '@opengeoweb/store';
+export declare const getDialogType: (mapId: string, isMultiMap: boolean, isDocked: boolean) => uiTypes.DialogType;
+interface LayerManagerConnectProps {
+    mapId?: string;
+    preloadedAvailableBaseLayers?: layerTypes.Layer[];
+    preloadedMapServices?: serviceTypes.InitialService[];
+    preloadedBaseServices?: serviceTypes.InitialService[];
+    bounds?: string;
+    title?: string;
+    showMapIdInTitle?: boolean;
+    isMultiMap?: boolean;
+    isDocked?: boolean;
+    source?: uiTypes.Source;
+}
+/**
+ * Layer Managerconnected to the store displaying the layers forthe 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 <LayerManagerMapButtonConnect/> which is used to focus the correct map and open the dialog
+ *
+ * Expects the following props:
+ * @param {serviceTypes.InitialService[]} preloadedMapServices preloadedMapServices: array of Service objects - contains an array of Service objects that are preloaded into in the WMS Loader for maplayers
+ * @param {serviceTypes.InitialService[]} 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 LayerManagerConnect: React.FC<LayerManagerConnectProps>;
+export default LayerManagerConnect;

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

@@ -0,0 +1,50 @@
+import React from 'react';
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface ToolbarButtonSettings {
+    small?: {
+        icon?: React.ReactNode;
+        isDisabled?: boolean;
+    };
+    medium?: {
+        icon?: React.ReactNode;
+        isDisabled?: boolean;
+    };
+    large?: {
+        icon?: React.ReactNode;
+        isDisabled?: boolean;
+    };
+    dock?: {
+        isDisabled?: boolean;
+    };
+    divider?: {
+        element: React.ReactNode;
+    };
+}
+interface HeaderOptionsProps {
+    isDockedLayerManager: boolean;
+    shortcutsEnabled: boolean;
+    onClickDockButton: () => void;
+    onChangeSize: (size: Size) => void;
+    buttonSettings?: ToolbarButtonSettings;
+}
+export declare const sizeSmall: {
+    width: number;
+    height: number;
+};
+export declare const sizeMedium: {
+    width: number;
+    height: number;
+};
+export declare const sizeLarge: {
+    width: number;
+    height: number;
+};
+export declare const sizeExtraLarge: {
+    width: number;
+    height: number;
+};
+declare const HeaderOptions: React.FC<HeaderOptionsProps>;
+export default HeaderOptions;

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

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { Size, ToolbarButtonSettings } from './LayerManagerHeaderOptions';
+interface HeaderOptionsProps {
+    isDockedLayerManager: boolean;
+    mapId: string;
+    onClickDockButton: () => void;
+    onChangeSize: (size: Size) => void;
+    buttonSettings?: ToolbarButtonSettings;
+}
+export declare const areShortcutsEnabled: (activeMapId: string, mapId: string, floatingLmOpen: boolean, isDockedLayerManager: boolean) => boolean;
+declare const HeaderOptionsConnect: React.FC<HeaderOptionsProps>;
+export default HeaderOptionsConnect;

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

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