@opengeoweb/soundings 12.1.2 → 12.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/soundings",
-  "version": "12.1.2",
+  "version": "12.3.0",
   "description": "GeoWeb soundings library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -8,7 +8,18 @@
     "url": "git@gitlab.com:opengeoweb/opengeoweb.git"
   },
   "dependencies": {
-    "react": "^18.3.1"
+    "@opengeoweb/api": "12.3.0",
+    "@tanstack/react-query": "^5.69.2",
+    "react": "^18.3.1",
+    "d3": "^7.9.0",
+    "react-i18next": "^15.1.1",
+    "i18next": "^23.11.5",
+    "@opengeoweb/shared": "12.3.0",
+    "@mui/material": "^7.0.1",
+    "@opengeoweb/store": "12.3.0",
+    "react-redux": "^9.2.0",
+    "@opengeoweb/theme": "12.3.0",
+    "@reduxjs/toolkit": "^2.6.1"
   },
   "module": "./index.esm.js",
   "type": "module",

package/src/index.d.ts

@@ -1 +1,7 @@
-export * from './lib/components/Sounding';
+import soundingsTranslations from '../locales/soundingsTranslations.json';
+export { soundingsTranslations };
+export * from './lib/components';
+export * from './lib/utils/soundingsLookUp';
+export * from './lib/api/edr-api/types';
+export * from './lib/store/store';
+export * from './lib/i18n';

package/src/lib/api/edr-api/api.d.ts

@@ -0,0 +1,6 @@
+import { CollectionsResponseFromBE, LocationsResponseFromBE, SoundingsInstances, CoverageCollection } from './types';
+export declare const getCollections: () => Promise<CollectionsResponseFromBE>;
+export declare const getCollectionLocations: (collectionId: string) => Promise<LocationsResponseFromBE>;
+export declare const getCollectionInstance: (baseURL: string, collectionId: string) => Promise<SoundingsInstances>;
+export declare const getEdrCollectionForLocation: (collectionId: string, instanceId: string | undefined, locationId: string, parameters: string[], datetime: string) => Promise<CoverageCollection>;
+export declare const getEdrCollectionForPosition: (collectionId: string, instanceId: string | undefined, coordinates: [number, number], parameters: string[], datetime: string) => Promise<CoverageCollection>;

package/src/lib/api/edr-api/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/src/lib/api/edr-api/fakeApi.d.ts

@@ -0,0 +1 @@
+export declare const fmiEdrCollectionsHandlers: import("msw").HttpHandler[];

package/src/lib/api/edr-api/hooks.d.ts

@@ -0,0 +1,5 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { SoundingFeature } from './types';
+type Coordinates = [number, number];
+export declare const useEdrCollectionForLocationPosition: (collectionId: string, instanceId: string | undefined, location: string | Coordinates, datetime: string, parameters?: string[]) => UseQueryResult<SoundingFeature[]>;
+export {};

package/src/lib/api/edr-api/types.d.ts

@@ -0,0 +1,118 @@
+import { Geometry } from 'geojson';
+import { Referencing } from './crss-types';
+interface LinksFromBE {
+    title: string;
+    href: string;
+    rel: string;
+    type: string;
+}
+export interface CollectionsFromBE {
+    id: string;
+    title: string;
+    description: string;
+    links: LinksFromBE[];
+    output_formats: string[];
+    keywords: string[];
+    crs: string[];
+    data_queries: object;
+    extent: object;
+    parameter_names: object;
+}
+/** These types can be expanded as needed */
+export interface CollectionsResponseFromBE {
+    links: LinksFromBE[];
+    collections: CollectionsFromBE[];
+}
+export interface FeaturesFromBE {
+    id: string;
+    type: string;
+    geometry: Geometry;
+    properties: {
+        datetime: string;
+        detail: string;
+        name: string;
+    };
+}
+export interface LocationsResponseFromBE {
+    features: FeaturesFromBE[];
+    type: string;
+}
+interface AxisValues {
+    values: number[] | string[];
+}
+interface SingleValueAxis {
+    values: [number];
+}
+interface SingleTimeValueAxis {
+    values: [string];
+}
+interface VerticalProfileAxes {
+    x: SingleValueAxis;
+    y: SingleValueAxis;
+    z: AxisValues;
+    t?: SingleTimeValueAxis;
+}
+export interface VerticalProfileDomain {
+    type: 'Domain';
+    domainType: 'VerticalProfile';
+    axes: VerticalProfileAxes;
+    referencing?: Referencing[];
+}
+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 {
+    type: 'Coverage';
+    domain: VerticalProfileDomain;
+    ranges: Ranges;
+}
+export interface CoverageCollection {
+    type: 'CoverageCollection';
+    domainType: VerticalProfileDomain;
+    parameters: Record<string, Parameter>;
+    ranges: Record<string, NdArray>;
+    coverages: Coverage[];
+    referencing: Referencing[];
+}
+export interface SoundingFeatureProperties {
+    time: string;
+    temp: number;
+    dewpoint: number;
+    pressure: number;
+    windSpeed: number;
+    windDirection: number;
+}
+export interface SoundingFeature {
+    type: 'Feature';
+    geometry: Geometry;
+    properties: SoundingFeatureProperties;
+}
+export interface SoundingsInstance {
+    id: string;
+}
+export interface SoundingsInstances {
+    instances: SoundingsInstance[];
+}
+export {};

package/src/lib/components/DrawUtils.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import * as d3 from 'd3';
+export declare const SOUNDING_COLORS: string[];
+export interface Margin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface InitializeSvg {
+    svgRef: React.MutableRefObject<SVGSVGElement | null>;
+    width: number;
+    height: number;
+    margin: Margin;
+}
+export interface AddLegends {
+    width: number;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, undefined>;
+}
+export interface DrawAxis {
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, undefined>;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    height: number;
+}
+export interface PlotSounding {
+    temperatureValues: number[];
+    pressureValues: number[];
+    color: string;
+    lineStyle: string;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    height: number;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, undefined>;
+}
+export declare const initializeSvg: ({ svgRef, width, height, margin, }: InitializeSvg) => d3.Selection<SVGGElement, unknown, null, undefined>;
+export declare const drawAxes: ({ svg, xScale, yScale, height }: DrawAxis) => void;
+export declare const addLegends: ({ svg, width }: AddLegends) => void;
+export declare const plotSounding: ({ temperatureValues, pressureValues, color, lineStyle, xScale, yScale, height, svg, }: PlotSounding) => void;

package/src/lib/components/EDRFetchAndParse.stories.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Meta } from '@storybook/react/*';
+import { Soundings } from './Soundings';
+declare const meta: Meta<typeof Soundings>;
+export default meta;
+export declare const VerticalProfileFetchingByLocExample: React.FC;
+export declare const VerticalProfileFetchingByPosExample: React.FC;

package/src/lib/components/MenuBar/LocationsMenu.d.ts

@@ -0,0 +1,13 @@
+import { LocationsResponseFromBE } from '../../api/edr-api/types';
+export type ServicesWithId = LocationsResponseFromBE & {
+    id: string;
+};
+interface Props {
+    services: ServicesWithId[];
+    selectedLocations: Record<string, string | undefined>;
+    isOpen: boolean;
+    onClose: () => void;
+    updateSelectedLocation: (sourceId: string, locationId: string | undefined) => void;
+}
+export declare const LocationsMenu: ({ services, selectedLocations, isOpen, onClose, updateSelectedLocation, }: Props) => React.ReactElement;
+export {};

package/src/lib/components/MenuBar/LocationsMenuConnect.d.ts

@@ -0,0 +1,6 @@
+import { SoundingsCollection } from '@opengeoweb/shared';
+interface Props {
+    soundingsCollections: SoundingsCollection[];
+}
+export declare const LocationsMenuConnect: ({ soundingsCollections, }: Props) => React.ReactElement;
+export {};

package/src/lib/components/MenuBar/MenuBar.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare enum MenuOptions {
+    sources = "sources",
+    locations = "locations"
+}
+interface SoundingsMenuBarProps {
+    handleClick: (menuType: MenuOptions) => void;
+    isOpen: Record<MenuOptions, boolean>;
+    selectedSourcesAmount?: number;
+}
+export declare const SoundingsMenuBar: ({ handleClick, isOpen, selectedSourcesAmount, }: SoundingsMenuBarProps) => React.ReactElement;
+export {};

package/src/lib/components/MenuBar/MenuBar.stories.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { StoryObj } from '@storybook/react';
+import { MenuOptions } from './MenuBar';
+interface Props {
+    menu?: MenuOptions;
+    isDefaultOpen?: boolean;
+    selectedSourcesAmount?: number;
+}
+declare const SoundingsMenuBarStory: ({ menu, isDefaultOpen, selectedSourcesAmount, }: Props) => React.ReactElement;
+declare const _default: {
+    title: string;
+    component: ({ menu, isDefaultOpen, selectedSourcesAmount, }: Props) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+};
+export default _default;
+type Story = StoryObj<typeof SoundingsMenuBarStory>;
+export declare const LocationsLight: Story;
+export declare const LocationsDark: Story;
+export declare const SourcesLight: Story;
+export declare const SourcesDark: Story;
+export declare const SourcesSelected: Story;

package/src/lib/components/MenuBar/MenuBarConnect.d.ts

@@ -0,0 +1,8 @@
+import { uiTypes } from '@opengeoweb/store';
+import React from 'react';
+interface MenuBarConnectProps {
+    viewId: string;
+    source?: uiTypes.Source;
+}
+export declare const MenuBarConnect: ({ viewId, source, }: MenuBarConnectProps) => React.ReactElement;
+export {};

package/src/lib/components/MenuBar/MenuBarConnect.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/lib/components/MenuBar/SoundingsSourceDialogConnect.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { SoundingsCollection } from '@opengeoweb/shared';
+interface SoundingsSourceDialogConnectProps {
+    soundingsCollections: SoundingsCollection[] | undefined;
+}
+export declare const SoundingsSourceDialogConnect: ({ soundingsCollections, }: SoundingsSourceDialogConnectProps) => React.ReactElement;
+export {};

package/src/lib/components/MenuBar/SoundingsSourceMenu.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { SoundingsCollectionsWithInstances } from '../types';
+import { SourceSelection } from '../../store/types';
+interface SoundingsSourceMenuProps {
+    soundingsCollections: SoundingsCollectionsWithInstances[] | undefined;
+    isOpen?: boolean;
+    handleClose: () => void;
+    updateCollection: (sourceId: string, value: SourceSelection) => void;
+    sourceSelections: Record<string, SourceSelection>;
+}
+export declare const SoundingsSourceMenu: ({ soundingsCollections, isOpen, handleClose, updateCollection, sourceSelections, }: SoundingsSourceMenuProps) => React.ReactElement;
+export {};

package/src/lib/components/Providers/Providers.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Store } from '@reduxjs/toolkit';
+interface SoundingsTranslationsWrapperProps {
+    children: React.ReactNode;
+}
+export declare const SoundingsI18nProvider: React.FC<SoundingsTranslationsWrapperProps>;
+interface SoundingsStoreWrapperProps {
+    children: React.ReactNode;
+    store: Store;
+}
+export declare const SoundingsStoreProvider: React.FC<SoundingsStoreWrapperProps>;
+export {};

package/src/lib/components/Soundings.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Margin } from './DrawUtils';
+import { SoundingFeature } from '../api/edr-api/types';
+export interface SoundingProps {
+    data: {
+        features: SoundingFeature[];
+    };
+    svgDimensions: {
+        width: number;
+        height: number;
+        margin: Margin;
+    };
+}
+export declare const Soundings: React.FC<SoundingProps>;

package/src/lib/components/Soundings.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/lib/components/Soundings.stories.d.ts

@@ -0,0 +1,7 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { Soundings } from './Soundings';
+declare const meta: Meta<typeof Soundings>;
+export default meta;
+type Story = StoryObj<typeof Soundings>;
+export declare const SoundingsExample: Story;
+export declare const SoundingsExampleDark: Story;

package/src/lib/components/SoundingsConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface SoundingsConnectProps {
+    viewId: string;
+}
+declare const SoundingsConnect: ({ viewId, }: SoundingsConnectProps) => React.ReactElement;
+export default SoundingsConnect;

package/src/lib/components/StaticLines/drawDryAdiabats.d.ts

@@ -0,0 +1,11 @@
+import * as d3 from 'd3';
+interface DrawDryAdiabatsProps {
+    staticPressureArray: number[];
+    height: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    dp: number;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawDryAdiabats: ({ staticPressureArray, height, xScale, yScale, svg, dp, }: DrawDryAdiabatsProps) => void;
+export {};

package/src/lib/components/StaticLines/drawIsobars.d.ts

@@ -0,0 +1,11 @@
+import * as d3 from 'd3';
+export declare const isobarValues: number[];
+interface DrawIsobarsProps {
+    minTemperature: number;
+    maxTemperature: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawIsobars: ({ minTemperature, maxTemperature, xScale, yScale, svg, }: DrawIsobarsProps) => void;
+export {};

package/src/lib/components/StaticLines/drawIsohumes.d.ts

@@ -0,0 +1,10 @@
+import * as d3 from 'd3';
+interface DrawIsohumesProps {
+    staticPressureArray: number[];
+    height: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawIsohumes: ({ staticPressureArray, height, xScale, yScale, svg, }: DrawIsohumesProps) => void;
+export {};

package/src/lib/components/StaticLines/drawIsotherms.d.ts

@@ -0,0 +1,10 @@
+import * as d3 from 'd3';
+interface DrawIsothermsProps {
+    staticPressureArray: number[];
+    height: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawIsotherms: ({ staticPressureArray, height, xScale, yScale, svg, }: DrawIsothermsProps) => void;
+export {};

package/src/lib/components/StaticLines/drawMoistAdiabats.d.ts

@@ -0,0 +1,16 @@
+import * as d3 from 'd3';
+interface DrawMoistAdiabatsProps {
+    staticPressureArray: number[];
+    minTemperature: number;
+    maxTemperature: number;
+    minPressure: number;
+    maxPressure: number;
+    width: number;
+    height: number;
+    dp: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawMoistAdiabats: ({ staticPressureArray, minTemperature, maxTemperature, minPressure, maxPressure, width, height, xScale, yScale, svg, dp, }: DrawMoistAdiabatsProps) => void;
+export {};

package/src/lib/components/StaticLines/utils.d.ts

@@ -0,0 +1,15 @@
+interface DrawStaticLinesProps {
+    dp: number;
+    staticPressureArray: number[];
+    minTemperature: number;
+    maxTemperature: number;
+    minPressure: number;
+    maxPressure: number;
+    width: number;
+    height: number;
+    xScale: d3.ScaleLinear<number, number>;
+    yScale: d3.ScaleLogarithmic<number, number>;
+    svg: d3.Selection<SVGElement, unknown, HTMLElement, unknown>;
+}
+export declare const drawStaticLines: ({ dp, staticPressureArray, minTemperature, maxTemperature, height, width, xScale, yScale, minPressure, maxPressure, svg, }: DrawStaticLinesProps) => void;
+export {};

package/src/lib/components/WindBarbs/utils.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { Margin } from '../DrawUtils';
+export interface WindDataType {
+    pressure: number;
+    windSpeed: number;
+    windDirection: number;
+}
+export interface DrawWindBarbsProps {
+    svgRef: React.MutableRefObject<SVGSVGElement | null>;
+    data: WindDataType[];
+    width: number;
+    height: number;
+    margin: Margin;
+    minPressure: number;
+    maxPressure: number;
+    barbColor?: string;
+}
+export declare const drawWindBarbs: ({ svgRef, data, width, height, margin, minPressure, maxPressure, barbColor, }: DrawWindBarbsProps) => void;
+export declare const GrowthType: {
+    readonly LINEAR: "LINEAR";
+    readonly EXPONENTIAL: "EXPONENTIAL";
+    readonly CUBIC: "CUBIC";
+};
+export declare const removeItemsByGrowthType: (array: WindDataType[], growthType?: keyof typeof GrowthType, base?: number, initial?: number) => WindDataType[];
+export declare const getWindSymbol: (value: number) => Node | null;

package/src/lib/components/WindBarbs/windsymbols.d.ts

@@ -0,0 +1,5 @@
+export declare const windSpeedRanges: {
+    min: number;
+    max: number;
+    symbol: string;
+}[];

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

@@ -0,0 +1,3 @@
+export * from './Soundings';
+export * from './MenuBar/SoundingsSourceDialogConnect';
+export * from './MenuBar/LocationsMenuConnect';

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

@@ -0,0 +1,5 @@
+import { SoundingsCollection } from '@opengeoweb/shared';
+import { SoundingsInstance } from '../api/edr-api/types';
+export interface SoundingsCollectionsWithInstances extends SoundingsCollection {
+    instances: SoundingsInstance[];
+}

package/src/lib/i18n.d.ts

@@ -0,0 +1,7 @@
+import i18n from 'i18next';
+import { UseTranslationResponse } from 'react-i18next';
+export declare const SOUNDINGS_NAMESPACE = "soundings";
+export declare const initSoundingsI18n: () => void;
+export declare const translateKeyOutsideComponents: (key: string, params?: Record<string, string | number> | undefined) => string;
+export declare const useSoundingsTranslation: () => UseTranslationResponse<typeof SOUNDINGS_NAMESPACE, typeof i18n>;
+export { i18n };

package/src/lib/parser/coverages.d.ts

@@ -0,0 +1,2 @@
+import { CoverageCollection, SoundingFeature } from '../api/edr-api/types';
+export declare function parseCoverageCollection(response: CoverageCollection): SoundingFeature[];

package/src/lib/store/reducer.d.ts

@@ -0,0 +1,7 @@
+import { Draft, PayloadAction } from '@reduxjs/toolkit';
+import { SoundingsStore, UpdateLocationPayload, UpdateSourcePayload } from './types';
+export declare const initialSoundingsState: SoundingsStore;
+export declare const soundingsReducer: import("redux").Reducer<SoundingsStore>, soundingsActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    updateSelectedSource: (draft: Draft<SoundingsStore>, payloadAction: PayloadAction<UpdateSourcePayload>) => void;
+    updateSelectedLocation: (draft: Draft<SoundingsStore>, payloadAction: PayloadAction<UpdateLocationPayload>) => void;
+}, "soundings">;

package/src/lib/store/selectors.d.ts

@@ -0,0 +1,105 @@
+import { SoundingsModuleState, SoundingsStore, SourceSelection, SourceType } from './types';
+export declare const getSourceSelections: ((state: SoundingsModuleState) => Record<string, SourceSelection>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SoundingsStore) => Record<string, SourceSelection>;
+    memoizedResultFunc: ((resultFuncArgs_0: SoundingsStore) => Record<string, SourceSelection>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, SourceSelection>;
+    dependencies: [(store: SoundingsModuleState) => SoundingsStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getLocationSelections: ((state: SoundingsModuleState) => Record<string, string | undefined>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SoundingsStore) => Record<string, string | undefined>;
+    memoizedResultFunc: ((resultFuncArgs_0: SoundingsStore) => Record<string, string | undefined>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, string | undefined>;
+    dependencies: [(store: SoundingsModuleState) => SoundingsStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSelectedSources: ((state: SoundingsModuleState) => SourceType[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SoundingsStore) => SourceType[];
+    memoizedResultFunc: ((resultFuncArgs_0: SoundingsStore) => SourceType[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => SourceType[];
+    dependencies: [(store: SoundingsModuleState) => SoundingsStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSelectedSourcesAmount: ((state: SoundingsModuleState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: SourceType[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: SourceType[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: SoundingsModuleState) => SourceType[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: SoundingsStore) => SourceType[];
+        memoizedResultFunc: ((resultFuncArgs_0: SoundingsStore) => SourceType[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => SourceType[];
+        dependencies: [(store: SoundingsModuleState) => SoundingsStore];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

package/src/lib/store/selectors.spec.d.ts

@@ -0,0 +1 @@
+export {};