@opengeoweb/shared 19.1.0 → 19.2.0

package/dist/src/lib/components/Storybook/StorybookDocsWrapper.d.ts

@@ -0,0 +1,6 @@
+import type { BoxProps } from '@mui/material';
+interface StorybookDocsWrapperProps extends BoxProps {
+    isDark?: boolean;
+}
+export declare const StorybookDocsWrapper: React.FC<StorybookDocsWrapperProps>;
+export {};

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

@@ -0,0 +1 @@
+export * from './StorybookDocsWrapper';

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

@@ -0,0 +1,8 @@
+import type { SwitchProps } from '@mui/material';
+import React from 'react';
+declare const SwitchButton: React.FC<SwitchProps & {
+    activeLabel?: string;
+    inActiveLabel?: string;
+    tooltip?: string;
+}>;
+export default SwitchButton;

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

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

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

@@ -0,0 +1,32 @@
+import type { PopoverOrigin, SxProps, Theme } from '@mui/material';
+import React from 'react';
+import type { Variant } from '../CustomIconButton';
+type MenuPosition = 'left' | 'right' | 'bottom';
+export declare const getPosition: (menuPosition: MenuPosition) => {
+    anchorOrigin: PopoverOrigin;
+    transformOrigin: PopoverOrigin;
+};
+export interface MenuItemType {
+    text: string;
+    action: (event: React.MouseEvent) => void;
+    icon?: React.ReactNode;
+    isDisabled?: boolean;
+    isSelected?: boolean;
+}
+interface ToggleMenuProps {
+    buttonTestId?: string;
+    menuPosition?: MenuPosition;
+    menuItems?: MenuItemType[];
+    menuTitle?: string;
+    secondaryMenuItems?: MenuItemType[];
+    secondaryMenuTitle?: string;
+    children?: React.ReactNode;
+    buttonSx?: SxProps<Theme>;
+    tooltipTitle?: string;
+    variant?: Variant;
+    isDefaultOpen?: boolean;
+    buttonIcon?: React.ReactNode;
+    isDisabled?: boolean;
+}
+export declare const ToggleMenu: React.FC<ToggleMenuProps>;
+export {};

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

@@ -0,0 +1 @@
+export * from './ToggleMenu';

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ToolContainerProps } from './types';
+export declare const BASE_ELEVATION = 5;
+declare const ToolContainer: React.FC<ToolContainerProps>;
+export default ToolContainer;

package/dist/src/lib/components/ToolContainer/ToolContainerDraggable.d.ts

@@ -0,0 +1,40 @@
+import type { SxProps } from '@mui/material';
+import type { NumberSize } from 're-resizable';
+import React from 'react';
+import type { HeaderSize } from './types';
+import type { DraggablePosition, DraggableSize, Position, ResizableComponentProps, Size } from '../DraggableResizable/types';
+export declare const calculateDialogSizeAndPosition: () => {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export declare const calculateStartSize: (minSize: DraggableSize, prefSize: DraggableSize, startPosition: Position) => DraggableSize;
+interface DraggableComponentProps extends Omit<ResizableComponentProps, 'bounds'> {
+    startPosition?: Position;
+    startDraggablePosition?: DraggablePosition;
+    onStartResize?: () => void;
+    isOpen?: boolean;
+    onClose?: () => void;
+    title?: string;
+    headerSize?: HeaderSize;
+    initialMaxHeight?: string | number;
+    fixTopPosition?: boolean;
+    onChangeSize?: (size: Size) => void;
+    onDragEnd?: (position: DraggablePosition, size: Size) => void;
+    onMouseDown?: (event: MouseEvent) => void;
+    bounds?: 'parent' | string;
+    cancel?: string;
+    order?: number;
+    source?: Source;
+    leftHeaderComponent?: React.ReactNode;
+    rightHeaderComponent?: React.ReactNode;
+    dragHandleIcon?: React.ReactNode;
+    closeIcon?: React.ReactNode;
+    sx?: SxProps;
+    resetPositionOnOpen?: boolean;
+}
+export declare const calculateNewPosition: (position: DraggablePosition, isRightAligned: boolean, handle: string, delta: NumberSize) => DraggablePosition;
+export type Source = 'app' | 'module';
+declare const DraggableComponent: React.FC<DraggableComponentProps>;
+export default DraggableComponent;

package/dist/src/lib/components/ToolContainer/ToolFooter.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ToolFooter: React.FC;
+export default ToolFooter;

package/dist/src/lib/components/ToolContainer/ToolHeader.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ToolHeaderProps } from './types';
+declare const ToolHeader: React.FC<ToolHeaderProps>;
+export default ToolHeader;

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

@@ -0,0 +1,7 @@
+export { default as ToolContainer } from './ToolContainer';
+export { default as ToolContainerDraggable } from './ToolContainerDraggable';
+export type { Source } from './ToolContainerDraggable';
+export { calculateDialogSizeAndPosition, calculateStartSize, } from './ToolContainerDraggable';
+export { default as ToolHeader } from './ToolHeader';
+export { default as ToolFooter } from './ToolFooter';
+export type * from './types';

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

@@ -0,0 +1,19 @@
+import type { PaperProps } from '@mui/material';
+export type HeaderSize = 'xxs' | 'xs' | 'small' | 'medium' | 'large';
+export interface ToolHeaderProps {
+    title?: string;
+    size?: HeaderSize;
+    onClose?: () => void;
+    className?: string;
+    isDraggable?: boolean;
+    leftHeaderComponent?: React.ReactNode;
+    rightHeaderComponent?: React.ReactNode;
+    dragHandleIcon?: React.ReactNode;
+    closeIcon?: React.ReactNode;
+}
+export interface ToolContainerProps extends PaperProps, ToolHeaderProps {
+    isResizable?: boolean;
+    children?: React.ReactNode;
+    maxHeight?: string | number;
+    headerClassName?: string;
+}

package/dist/src/lib/components/ToolContainer/useHandleSizeFromOutsideComponent.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DraggablePosition, Position, Size } from '../DraggableResizable/types';
+export declare const getNewPositionSize: (element: Element, boundsNode: Element, isRightAligned: boolean, position: DraggablePosition, fixTopPosition: boolean, newSize?: Size) => {
+    position: Position;
+    size: Size;
+};
+export declare const useHandleSizeFromOutsideComponent: ({ nodeRef, bounds, position, isRightAligned, isOpen, startSize, onChangeSize, fixTopPosition, }: {
+    nodeRef: React.RefObject<HTMLDivElement | null>;
+    position: DraggablePosition;
+    bounds: string;
+    isRightAligned: boolean;
+    isOpen: boolean;
+    startSize: Size;
+    onChangeSize: (size: Size) => void;
+    fixTopPosition?: boolean;
+}) => void;

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

@@ -0,0 +1,23 @@
+import type { BaseSelectProps, SelectVariants, SxProps, Theme } from '@mui/material';
+import React from 'react';
+interface ListElement {
+    value: string;
+}
+type TooltipSelectProps = Omit<BaseSelectProps, 'sx'> & {
+    tooltip: string;
+    list?: ListElement[];
+    currentIndex?: number;
+    onChangeMouseWheel?: (element: ListElement) => void;
+    isEnabled?: boolean;
+    hasBackgroundColor?: boolean;
+    variant?: SelectVariants;
+    additionalStyling?: SxProps;
+    skipLocalStyling?: boolean;
+};
+export declare const TooltipSelect: React.FC<TooltipSelectProps>;
+interface StyledSelectProps extends Omit<TooltipSelectProps, 'tooltip' | 'skipLocalStyling'> {
+    skipLocalStyling: boolean;
+}
+export declare const StyledSelect: import("@emotion/styled").StyledComponent<Omit<StyledSelectProps, "ref"> & React.RefAttributes<unknown> & import("@mui/system").MUIStyledCommonProps<Theme>, {}, {}>;
+export declare const tooltipContainerStyles: (theme: Theme, isEnabled: boolean, hasBackgroundColor?: boolean) => object;
+export {};

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

@@ -0,0 +1 @@
+export * from './TooltipSelect';

package/dist/src/lib/components/UserMenu/CheatSheet/CheatSheet.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const CheatSheet: React.FC;
+export default CheatSheet;

package/dist/src/lib/components/UserMenu/CheatSheet/ShortcutList.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type Platform = 'windows' | 'mac';
+declare const ShortcutList: React.FC<{
+    platform?: Platform;
+}>;
+export default ShortcutList;

package/dist/src/lib/components/UserMenu/CheatSheet/ShortcutSegment.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface ShortCutSegmentProps {
+    type?: 'text' | 'icon' | 'divider' | 'connect';
+    children?: React.ReactNode;
+}
+declare const ShortCutSegment: React.FC<ShortCutSegmentProps>;
+export default ShortCutSegment;

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

@@ -0,0 +1,11 @@
+import React from 'react';
+interface UserMenuProps {
+    isOpen?: boolean;
+    onToggle?: () => void;
+    onClose?: () => void;
+    children?: React.ReactNode;
+    initials?: string;
+    isAdmin?: boolean;
+}
+declare const UserMenu: React.FC<UserMenuProps>;
+export default UserMenu;

package/dist/src/lib/components/UserMenu/UserMenuItemCheatSheet.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const UserMenuItemCheatSheet: React.FC;
+export default UserMenuItemCheatSheet;

package/dist/src/lib/components/UserMenu/UserMenuItemTheme.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface MenuItemThemeProps {
+    enableSpecialThemes?: boolean;
+}
+declare const MenuItemTheme: React.FC<MenuItemThemeProps>;
+export default MenuItemTheme;

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

@@ -0,0 +1,5 @@
+export { default as UserMenu } from './UserMenu';
+export { default as UserMenuItemTheme } from './UserMenuItemTheme';
+export { default as UserMenuItemCheatSheet } from './UserMenuItemCheatSheet';
+export { useUserMenu } from './useUserMenu';
+export { getInitials } from './utils';

package/dist/src/lib/components/UserMenu/useUserMenu.d.ts

@@ -0,0 +1,7 @@
+interface UseUserMenuProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onToggle: () => void;
+}
+export declare const useUserMenu: (open?: boolean) => UseUserMenuProps;
+export {};

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

@@ -0,0 +1 @@
+export declare const getInitials: (name: string) => string;

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

@@ -0,0 +1,26 @@
+export * from './StatusTag';
+export * from './ConfirmationDialog';
+export * from './AlertBanner';
+export * from './AppLayout';
+export * from './AppHeader';
+export * from './DraggableResizable';
+export * from './ErrorBoundary';
+export * from './UserMenu';
+export * from './ToolContainer';
+export * from './CustomSlider';
+export * from './CustomToggleButton';
+export * from './ToggleMenu';
+export * from './AlertIcon';
+export * from './TooltipSelect';
+export * from './Avatar';
+export * from './CustomTooltip';
+export * from './CustomAccordion';
+export * from './CustomDialog';
+export * from './CustomIconButton';
+export * from './SearchHighlight';
+export * from './SwitchButton';
+export * from './SearchField';
+export * from './LastUpdateTime';
+export * from './CanvasComponent';
+export * from './Filter';
+export * from './Storybook';

package/dist/src/lib/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export * from './usePreventBrowserClose/usePreventBrowserClose';
+export * from './usePoller/usePoller';
+export * from './usePrevious/usePrevious';
+export * from './useIsMounted/useIsMounted';
+export * from './useMakeSureContainerStaysInsideWindow/useMakeSureContainerStaysInsideWindow';
+export * from './useDebounce/useDebounce';
+export * from './useWheelStopPropagation/useWheelStopPropagation';
+export * from './useScrollingInIsolation/useScrollingInIsolation';
+export * from './useResizeObserver/useResizeObserver';

package/dist/src/lib/hooks/useDebounce/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: <S>(value: S, timeout: number) => S;

package/dist/src/lib/hooks/useIsMounted/useIsMounted.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const useIsMounted: () => {
+    isMounted: React.RefObject<boolean>;
+};

package/dist/src/lib/hooks/useMakeSureContainerStaysInsideWindow/useMakeSureContainerStaysInsideWindow.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { DraggablePosition } from '../../components/DraggableResizable/types';
+export declare const adjustPosition: (bbox: DOMRect, containingView: DOMRect, position: DraggablePosition, setPosition: (position: DraggablePosition) => void) => void;
+export declare const useMakeSureContainerStaysInsideWindow: (nodeRef: React.RefObject<HTMLDivElement | null>, position: DraggablePosition, setPosition: (position: DraggablePosition) => void) => void;

package/dist/src/lib/hooks/usePoller/usePoller.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const pollingIntervalTimeout = 300000;
+export declare const usePoller: (deps: unknown[], callback: () => void, pollingInterval?: number) => React.RefObject<ReturnType<typeof setTimeout> | null>;

package/dist/src/lib/hooks/usePreventBrowserClose/usePreventBrowserClose.d.ts

@@ -0,0 +1,2 @@
+export declare const showPrompt: (event: Event) => void;
+export declare function usePreventBrowserClose(shouldPreventClose: boolean): void;

package/dist/src/lib/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare function usePrevious<T>(value: T): T;

package/dist/src/lib/hooks/useResizeObserver/useResizeObserver.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const useResizeObserver: (listContainerRef: React.RefObject<HTMLDivElement | null>, collections: unknown[], ResizeObserverImpl?: typeof ResizeObserver) => number;

package/dist/src/lib/hooks/useScrollingInIsolation/useScrollingInIsolation.d.ts

@@ -0,0 +1,11 @@
+/**
+ *  This hook allows to stop wheel events from propagating to parent elements.
+ *  Normally, when you scroll a child element, the scroll event will propagate to the parent element,
+ *  as calling event.stopPropagation() on syncthetic events does not stop the propagation
+ */
+import React from 'react';
+interface ScrollInIsolationProps {
+    onWheel?: (event: WheelEvent) => void;
+}
+export declare const useScrollingInIsolation: <T extends HTMLElement>(options?: ScrollInIsolationProps) => React.RefObject<T | null>;
+export {};

package/dist/src/lib/hooks/useWheelStopPropagation/useWheelStopPropagation.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const useWheelStopPropagation: <T extends HTMLElement>() => React.RefObject<T | null>;

package/dist/src/lib/types/crss-types.d.ts

@@ -0,0 +1,26 @@
+export interface Referencing {
+    coordinates: string[];
+    system: CRSSystem;
+}
+interface GeographicCRS {
+    type: 'GeographicCRS';
+    id: string;
+}
+interface ProjectedCRS {
+    type: 'ProjectedCRS';
+    id: string;
+}
+interface VerticalCRS {
+    type: 'VerticalCRS';
+    id: string;
+}
+interface EngineeringCRS {
+    type: 'EngineeringCRS';
+    id?: string;
+}
+interface TemporalRS {
+    type: 'TemporalRS';
+    calendar: string;
+}
+type CRSSystem = GeographicCRS | ProjectedCRS | VerticalCRS | EngineeringCRS | TemporalRS;
+export {};

package/dist/src/lib/types/edr-coverage-types.d.ts

@@ -0,0 +1,98 @@
+import type { Referencing } from './crss-types';
+interface AxisValues {
+    values: number[] | string[];
+}
+interface SingleValueAxis {
+    values: [number];
+}
+interface SingleTimeValueAxis {
+    values: [string];
+}
+interface PointSeriesAxes {
+    x: SingleValueAxis;
+    y: SingleValueAxis;
+    z?: SingleTimeValueAxis;
+    t: AxisValues;
+}
+export interface PointSeriesDomain {
+    type: 'Domain';
+    domainType: 'PointSeries';
+    axes: PointSeriesAxes;
+    referencing?: Referencing[];
+}
+interface PointAxes {
+    x: SingleValueAxis;
+    y: SingleValueAxis;
+    z?: SingleValueAxis;
+    t?: SingleTimeValueAxis;
+}
+export interface PointDomain {
+    type: 'Domain';
+    domainType: 'Point';
+    axes: PointAxes;
+    referencing?: Referencing[];
+}
+interface VerticalProfileAxes {
+    x: SingleValueAxis;
+    y: SingleValueAxis;
+    z: AxisValues;
+    t?: SingleTimeValueAxis;
+}
+export interface VerticalProfileDomain {
+    type: 'Domain';
+    domainType: 'VerticalProfile';
+    axes: VerticalProfileAxes;
+    referencing?: Referencing[];
+}
+interface GridAxes {
+    x: SingleValueAxis;
+    y: SingleValueAxis;
+    z: AxisValues;
+    t?: SingleTimeValueAxis;
+}
+export interface GridDomain {
+    type: 'Domain';
+    domainType: 'Grid';
+    axes: GridAxes;
+    referencing?: Referencing[];
+}
+export type CoverageDomain = VerticalProfileDomain | PointDomain | PointSeriesDomain | GridDomain;
+interface NdArray {
+    type: 'NdArray';
+    dataType: 'float' | 'integer' | 'string';
+    axisNames?: string[];
+    shape?: number[];
+    values: number[] | string[];
+}
+type Ranges = Record<string, NdArray>;
+type Description = Record<string, string>;
+type Label = Record<string, string>;
+interface Parameter {
+    type: 'Parameter';
+    id?: string;
+    label?: Label;
+    description?: Description;
+    unit?: {
+        label?: Label;
+        symbol?: Record<string, string>;
+    };
+    observedProperty: {
+        id?: string;
+        label: Label;
+        description?: Description;
+    };
+}
+export interface Coverage<T extends CoverageDomain> {
+    type: 'Coverage';
+    domain: T;
+    ranges: Ranges;
+}
+export interface CoverageCollection<T extends CoverageDomain> {
+    type: 'CoverageCollection';
+    domainType: string;
+    parameters: Record<string, Parameter>;
+    ranges: Record<string, NdArray>;
+    coverages: Coverage<T>[];
+    referencing: Referencing[];
+}
+export {};

package/dist/src/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export type * from './edr-coverage-types';