diff --git a/docs/plugins/bounds.md b/docs/plugins/bounds.md
new file mode 100644
index 0000000000000000000000000000000000000000..a9863e90f417737c0f37cbf9799ba3d9e4f0cf2f
--- /dev/null
+++ b/docs/plugins/bounds.md
@@ -0,0 +1,43 @@
+### Bounds
+
+#### Get Bounds
+
+To get bounds of the current active map, plugins can use the `getBounds` method defined in `window.minerva.map.data` object available globally. It returns object with properties x1, y1, x2, y2
+
+- x1, y1 - top left corner coordinates
+- x2, y2 - right bottom corner coordinates
+
+Example of returned object:
+
+```javascript
+{
+ x1: 12853,
+ y1: 4201,
+ x2: 23327,
+ y2: 9575
+}
+```
+
+##### Example of getBounds method usage:
+
+```javascript
+window.minerva.map.data.getBounds();
+```
+
+#### Fit bounds
+
+To zoom in the map in a way that rectangle defined by coordinates is visible, plugins can use the `fitBounds` method defined in `window.minerva.map` object available globally. This method takes one argument: object with properties x1, y1, x2, y2.
+
+- x1, y1 - top left corner coordinates
+- x2, y2 - right bottom corner coordinates
+
+##### Example of fitBounds method usage:
+
+```javascript
+window.minerva.map.fitBounds({
+ x1: 14057.166666666668,
+ y1: 6805.337365980873,
+ x2: 14057.166666666668,
+ y2: 6805.337365980873,
+});
+```
diff --git a/docs/plugins/errors.md b/docs/plugins/errors.md
index 2795ec513330d084028e1cfe6cc7daee6c522687..fca95f8b1558a7e48087d53b5a8b736cc549eea8 100644
--- a/docs/plugins/errors.md
+++ b/docs/plugins/errors.md
@@ -4,13 +4,15 @@
- **Map with provided id does not exist**: This error occurs when the provided map id does not correspond to any existing map.
+- **Unable to retrieve the id of the active map: the modelId is not a number**: This error occurs when the modelId parameter provided from store to retrieve the id of the active map is not a number.
+
## Search Errors
- **Invalid query type. The query should be of string type**: This error occurs when the query parameter is not of string type.
- **Invalid coordinates type or values**: This error occurs when the coordinates parameter is missing keys, or its values are not of number type.
-- **Invalid model id type. The model should be of number type**: This error occurs when the modelId parameter is not of number type.
+- **Invalid model id type. The model id should be a number**: This error occurs when the modelId parameter is not of number type.
## Project Errors
diff --git a/docs/plugins/submaps.md b/docs/plugins/submaps.md
index 54c6a340857d14e1e45fc1cdbd7d70c2d11c7f62..aab6dc23ce8b15e9b7d06273f188104a2dc4282a 100644
--- a/docs/plugins/submaps.md
+++ b/docs/plugins/submaps.md
@@ -1,5 +1,15 @@
### Submaps
+#### Get current open map id
+
+To get current open map id, plugins can use the `getOpenMapId` method defined in `window.minerva.map.data` object available globally. It returns id of current open map.
+
+##### Example of getOpenMapId method usage:
+
+```javascript
+window.minerva.map.data.getOpenMapId();
+```
+
#### Get Models
To get data about all available submaps, plugins can use the `getModels` method defined in `window.minerva.map.data`. This method returns array with data about all submaps.
diff --git a/index.d.ts b/index.d.ts
index db769bd296186e97e8d09c6adc0460de5f166242..3cd0efd1a8805d41f089cca9aa3f9a7fd87171d8 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -1,3 +1,9 @@
+import { getBounds } from '@/services/pluginsManager/map/data/getBounds';
+import { fitBounds } from '@/services/pluginsManager/map/fitBounds';
+import { getOpenMapId } from '@/services/pluginsManager/map/getOpenMapId';
+import { triggerSearch } from '@/services/pluginsManager/map/triggerSearch';
+import { MinervaConfiguration } from '@/services/pluginsManager/pluginsManager';
+import { MapInstance } from '@/types/map';
import { getModels } from '@/services/pluginsManager/map/models/getModels';
import { OpenMapArgs, openMap } from '@/services/pluginsManager/map/openMap';
import { triggerSearch } from '@/services/pluginsManager/map/triggerSearch';
@@ -36,8 +42,11 @@ declare global {
};
map: {
data: {
+ getBounds: typeof getBounds;
+ getOpenMapId: typeof getOpenMapId;
getModels: typeof getModels;
};
+ fitBounds: typeof fitBounds;
openMap: typeof openMap;
triggerSearch: typeof triggerSearch;
};
diff --git a/src/components/Map/MapAdditionalActions/MapAdditionalActions.component.test.tsx b/src/components/Map/MapAdditionalActions/MapAdditionalActions.component.test.tsx
index f65f5b605510ad4afb566e763c886fddbc9b1225..06bd09feed567c3515c7d3f305bc8eecb9426e78 100644
--- a/src/components/Map/MapAdditionalActions/MapAdditionalActions.component.test.tsx
+++ b/src/components/Map/MapAdditionalActions/MapAdditionalActions.component.test.tsx
@@ -54,7 +54,7 @@ const renderComponentWithMapInstance = (initialStore?: InitialStoreState): { sto
const { Wrapper, store } = getReduxWrapperWithStore(initialStore, {
mapInstanceContextValue: {
mapInstance,
- setMapInstance: () => {},
+ handleSetMapInstance: () => {},
},
});
diff --git a/src/components/Map/MapAdditionalActions/utils/useAdditionalActions.test.ts b/src/components/Map/MapAdditionalActions/utils/useAdditionalActions.test.ts
index f711b392c959c975ed207dccd23b09365166ed6b..b862beaed3dfc2d687978f9d6a586b8925c986b7 100644
--- a/src/components/Map/MapAdditionalActions/utils/useAdditionalActions.test.ts
+++ b/src/components/Map/MapAdditionalActions/utils/useAdditionalActions.test.ts
@@ -99,7 +99,7 @@ describe('useAddtionalActions - hook', () => {
{
mapInstanceContextValue: {
mapInstance,
- setMapInstance: () => {},
+ handleSetMapInstance: () => {},
},
},
);
diff --git a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleAliasResults.ts b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleAliasResults.ts
index b14875831efa1192261f2f9dc7f3099a87c41a03..cd7aefe90caeee8e5270d58052dd2442a7a14672 100644
--- a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleAliasResults.ts
+++ b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleAliasResults.ts
@@ -1,11 +1,12 @@
import { getMultiBioEntity } from '@/redux/bioEntity/bioEntity.thunks';
import { openBioEntityDrawerById } from '@/redux/drawer/drawer.slice';
import { AppDispatch } from '@/redux/store';
+import { searchFitBounds } from '@/services/pluginsManager/map/triggerSearch/searchFitBounds';
import { ElementSearchResult } from '@/types/models';
/* prettier-ignore */
export const handleAliasResults =
- (dispatch: AppDispatch) =>
+ (dispatch: AppDispatch, hasFitBounds?: boolean, fitBoundsZoom?: number) =>
async ({ id }: ElementSearchResult): Promise<void> => {
dispatch(openBioEntityDrawerById(id));
@@ -14,5 +15,12 @@ export const handleAliasResults =
searchQueries: [id.toString()],
isPerfectMatch: true
}),
- );
+ )
+ .unwrap().then(() => {
+ if (hasFitBounds) {
+ searchFitBounds(fitBoundsZoom);
+ }
+ }).catch(() => {
+ // TODO to discuss manage state of failure
+ });
};
diff --git a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleReactionResults.ts b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleReactionResults.ts
index 55c244ad04bd1a9cb6021085247101025742fa68..d82828178e0319f6b6176e2ae6764820f55ff7f4 100644
--- a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleReactionResults.ts
+++ b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleReactionResults.ts
@@ -3,12 +3,13 @@ import { getMultiBioEntity } from '@/redux/bioEntity/bioEntity.thunks';
import { openReactionDrawerById } from '@/redux/drawer/drawer.slice';
import { getReactionsByIds } from '@/redux/reactions/reactions.thunks';
import { AppDispatch } from '@/redux/store';
+import { searchFitBounds } from '@/services/pluginsManager/map/triggerSearch/searchFitBounds';
import { ElementSearchResult, Reaction } from '@/types/models';
import { PayloadAction } from '@reduxjs/toolkit';
/* prettier-ignore */
export const handleReactionResults =
- (dispatch: AppDispatch) =>
+ (dispatch: AppDispatch, hasFitBounds?: boolean, fitBoundsZoom?: number) =>
async ({ id }: ElementSearchResult): Promise<void> => {
const data = await dispatch(getReactionsByIds([id])) as PayloadAction<Reaction[] | undefined>;
const payload = data?.payload;
@@ -28,6 +29,12 @@ export const handleReactionResults =
getMultiBioEntity({
searchQueries: bioEntitiesIds,
isPerfectMatch: true },
- ),
- );
+ )
+ ).unwrap().then(() => {
+ if (hasFitBounds) {
+ searchFitBounds(fitBoundsZoom);
+ }
+ }).catch(() => {
+ // TODO to discuss manage state of failure
+ });
};
diff --git a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleSearchResultAction.ts b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleSearchResultAction.ts
index 23ae912e98c9d24124f0c61be6ff6fa655ed6ca9..c3663e417a6d055fcaf2f6e8e787c4bcf99fabad 100644
--- a/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleSearchResultAction.ts
+++ b/src/components/Map/MapViewer/utils/listeners/mapSingleClick/handleSearchResultAction.ts
@@ -8,11 +8,15 @@ import { handleReactionResults } from './handleReactionResults';
interface HandleSearchResultActionInput {
searchResults: ElementSearchResult[];
dispatch: AppDispatch;
+ hasFitBounds?: boolean;
+ fitBoundsZoom?: number;
}
export const handleSearchResultAction = async ({
searchResults,
dispatch,
+ hasFitBounds,
+ fitBoundsZoom,
}: HandleSearchResultActionInput): Promise<void> => {
const closestSearchResult = searchResults[FIRST_ARRAY_ELEMENT];
const { type } = closestSearchResult;
@@ -21,7 +25,7 @@ export const handleSearchResultAction = async ({
REACTION: handleReactionResults,
}[type];
- await action(dispatch)(closestSearchResult);
+ await action(dispatch, hasFitBounds, fitBoundsZoom)(closestSearchResult);
if (type === 'ALIAS') {
PluginsEventBus.dispatchEvent('onBioEntityClick', closestSearchResult);
diff --git a/src/components/Map/MapViewer/utils/useOlMap.ts b/src/components/Map/MapViewer/utils/useOlMap.ts
index 326e8ec8822585de8fe9397ec380143a7f040016..49ec30027077460bfdde9b9ff2b6e89961c0273a 100644
--- a/src/components/Map/MapViewer/utils/useOlMap.ts
+++ b/src/components/Map/MapViewer/utils/useOlMap.ts
@@ -19,7 +19,7 @@ type UseOlMap = (input?: UseOlMapInput) => UseOlMapOutput;
export const useOlMap: UseOlMap = ({ target } = {}) => {
const mapRef = React.useRef<null | HTMLDivElement>(null);
- const { mapInstance, setMapInstance } = useMapInstance();
+ const { mapInstance, handleSetMapInstance } = useMapInstance();
const view = useOlMapView({ mapInstance });
useOlMapLayers({ mapInstance });
useOlMapListeners({ view, mapInstance });
@@ -41,8 +41,8 @@ export const useOlMap: UseOlMap = ({ target } = {}) => {
}
});
- setMapInstance(currentMap => currentMap || map);
- }, [target, setMapInstance]);
+ handleSetMapInstance(map);
+ }, [target, handleSetMapInstance]);
return {
mapRef,
diff --git a/src/services/pluginsManager/errorMessages.ts b/src/services/pluginsManager/errorMessages.ts
index 7d35649435f1f99a73a8f6b84b267ac76b01143e..753b06f04cadabf975857a4a773c8574f3b1befb 100644
--- a/src/services/pluginsManager/errorMessages.ts
+++ b/src/services/pluginsManager/errorMessages.ts
@@ -1,6 +1,7 @@
export const ERROR_MAP_NOT_FOUND = 'Map with provided id does not exist';
export const ERROR_INVALID_QUERY_TYPE = 'Invalid query type. The query should be of string type';
export const ERROR_INVALID_COORDINATES = 'Invalid coordinates type or values';
-export const ERROR_INVALID_MODEL_ID_TYPE =
- 'Invalid model id type. The model should be of number type';
+export const ERROR_INVALID_MODEL_ID_TYPE = 'Invalid model id type. The model id should be a number';
export const ERROR_PROJECT_NOT_FOUND = 'Project does not exist';
+export const ERROR_INVALID_MODEL_ID_TYPE_FOR_RETRIEVAL =
+ 'Unable to retrieve the id of the active map: the modelId is not a number';
diff --git a/src/services/pluginsManager/map/data/getBounds.test.ts b/src/services/pluginsManager/map/data/getBounds.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99f587dab60eacdc703580964f06e5333f4f559c
--- /dev/null
+++ b/src/services/pluginsManager/map/data/getBounds.test.ts
@@ -0,0 +1,60 @@
+/* eslint-disable no-magic-numbers */
+import { MAP_DATA_INITIAL_STATE } from '@/redux/map/map.constants';
+import { store } from '@/redux/store';
+import { Map } from 'ol';
+import { MapManager } from '../mapManager';
+import { getBounds } from './getBounds';
+
+describe('getBounds', () => {
+ it('should return undefined if map instance does not exist', () => {
+ expect(getBounds()).toEqual(undefined);
+ });
+ it('should return current bounds if map instance exist', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ MapManager.setMapInstance(mapInstance);
+
+ jest.spyOn(mapInstance, 'getView').mockImplementation(
+ () =>
+ ({
+ calculateExtent: () => [
+ -14409068.309137221, 17994265.029590994, -13664805.690862779, 18376178.970409006,
+ ],
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) as any,
+ );
+
+ const getStateSpy = jest.spyOn(store, 'getState');
+ getStateSpy.mockImplementation(
+ () =>
+ ({
+ map: {
+ data: {
+ ...MAP_DATA_INITIAL_STATE,
+ size: {
+ width: 26779.25,
+ height: 13503,
+ tileSize: 256,
+ minZoom: 2,
+ maxZoom: 9,
+ },
+ },
+ loading: 'idle',
+ error: {
+ name: '',
+ message: '',
+ },
+ openedMaps: [],
+ },
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) as any,
+ );
+
+ expect(getBounds()).toEqual({
+ x1: 15044,
+ y1: 4441,
+ x2: 17034,
+ y2: 5461,
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/data/getBounds.ts b/src/services/pluginsManager/map/data/getBounds.ts
new file mode 100644
index 0000000000000000000000000000000000000000..626e13f705c08dcf163ed1a1017e99d857a7723b
--- /dev/null
+++ b/src/services/pluginsManager/map/data/getBounds.ts
@@ -0,0 +1,37 @@
+import { mapDataSizeSelector } from '@/redux/map/map.selectors';
+import { store } from '@/redux/store';
+import { latLngToPoint } from '@/utils/map/latLngToPoint';
+import { toLonLat } from 'ol/proj';
+import { MapManager } from '../mapManager';
+
+type GetBoundsReturnType =
+ | {
+ x1: number;
+ x2: number;
+ y1: number;
+ y2: number;
+ }
+ | undefined;
+
+export const getBounds = (): GetBoundsReturnType => {
+ const mapInstance = MapManager.getMapInstance();
+
+ if (!mapInstance) return undefined;
+
+ const [minx, miny, maxx, maxy] = mapInstance.getView().calculateExtent(mapInstance.getSize());
+
+ const mapSize = mapDataSizeSelector(store.getState());
+
+ const [lngX1, latY1] = toLonLat([minx, maxy]);
+ const [lngX2, latY2] = toLonLat([maxx, miny]);
+
+ const { x: x1, y: y1 } = latLngToPoint([latY1, lngX1], mapSize, { rounded: true });
+ const { x: x2, y: y2 } = latLngToPoint([latY2, lngX2], mapSize, { rounded: true });
+
+ return {
+ x1,
+ y1,
+ x2,
+ y2,
+ };
+};
diff --git a/src/services/pluginsManager/map/fitBounds/fitBounds.constants.ts b/src/services/pluginsManager/map/fitBounds/fitBounds.constants.ts
new file mode 100644
index 0000000000000000000000000000000000000000..af85941c3340682b1b2644705b7e7c887e12182f
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/fitBounds.constants.ts
@@ -0,0 +1,5 @@
+import { HALF } from '@/constants/dividers';
+import { DEFAULT_TILE_SIZE } from '@/constants/map';
+
+const BOUNDS_PADDING = DEFAULT_TILE_SIZE / HALF;
+export const DEFAULT_PADDING = [BOUNDS_PADDING, BOUNDS_PADDING, BOUNDS_PADDING, BOUNDS_PADDING];
diff --git a/src/services/pluginsManager/map/fitBounds/fitBounds.test.ts b/src/services/pluginsManager/map/fitBounds/fitBounds.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1f45aecfb1e53db5f3d515fdbe3c3722a1ff0f2e
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/fitBounds.test.ts
@@ -0,0 +1,122 @@
+/* eslint-disable no-magic-numbers */
+import { MAP_DATA_INITIAL_STATE } from '@/redux/map/map.constants';
+import { Map } from 'ol';
+import { store } from '@/redux/store';
+import { fitBounds } from './fitBounds';
+import { MapManager } from '../mapManager';
+
+jest.mock('../../../../redux/store');
+
+describe('fitBounds', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ MapManager.mapInstance = null;
+ });
+ it('fitBounds should return undefined', () => {
+ expect(
+ fitBounds({
+ x1: 5,
+ y1: 10,
+ x2: 15,
+ y2: 20,
+ }),
+ ).toBe(undefined);
+ });
+
+ describe('when mapInstance is set', () => {
+ it('should call and set map instance view properly', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ MapManager.setMapInstance(mapInstance);
+ const view = mapInstance.getView();
+ const getViewSpy = jest.spyOn(mapInstance, 'getView');
+ const fitSpy = jest.spyOn(view, 'fit');
+ const getStateSpy = jest.spyOn(store, 'getState');
+ getStateSpy.mockImplementation(
+ () =>
+ ({
+ map: {
+ data: {
+ ...MAP_DATA_INITIAL_STATE,
+ size: {
+ width: 256,
+ height: 256,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 1,
+ },
+ },
+ loading: 'idle',
+ error: {
+ name: '',
+ message: '',
+ },
+ openedMaps: [],
+ },
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) as any,
+ );
+
+ fitBounds({
+ x1: 10,
+ y1: 10,
+ x2: 15,
+ y2: 20,
+ });
+
+ expect(getViewSpy).toHaveBeenCalledTimes(1);
+ expect(fitSpy).toHaveBeenCalledWith([-18472078, 16906648, -17689363, 18472078], {
+ maxZoom: 1,
+ padding: [128, 128, 128, 128],
+ size: undefined,
+ });
+ });
+ it('should use max zoom value', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ MapManager.setMapInstance(mapInstance);
+ const view = mapInstance.getView();
+ const getViewSpy = jest.spyOn(mapInstance, 'getView');
+ const fitSpy = jest.spyOn(view, 'fit');
+ const getStateSpy = jest.spyOn(store, 'getState');
+ getStateSpy.mockImplementation(
+ () =>
+ ({
+ map: {
+ data: {
+ ...MAP_DATA_INITIAL_STATE,
+ size: {
+ width: 256,
+ height: 256,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 99,
+ },
+ },
+ loading: 'idle',
+ error: {
+ name: '',
+ message: '',
+ },
+ openedMaps: [],
+ },
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) as any,
+ );
+
+ fitBounds({
+ x1: 10,
+ y1: 10,
+ x2: 15,
+ y2: 20,
+ });
+
+ expect(getViewSpy).toHaveBeenCalledTimes(1);
+ expect(fitSpy).toHaveBeenCalledWith([-18472078, 16906648, -17689363, 18472078], {
+ maxZoom: 99,
+ padding: [128, 128, 128, 128],
+ size: undefined,
+ });
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/fitBounds/fitBounds.ts b/src/services/pluginsManager/map/fitBounds/fitBounds.ts
new file mode 100644
index 0000000000000000000000000000000000000000..079c6d9cc5c50bd5f1f5150a4e907de157a81498
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/fitBounds.ts
@@ -0,0 +1,45 @@
+import { FitOptions } from 'ol/View';
+import { boundingExtent } from 'ol/extent';
+import { mapDataSizeSelector } from '@/redux/map/map.selectors';
+import { store } from '@/redux/store';
+import { MapManager } from '../mapManager';
+import { pointToProjection } from './fitBounds.utils';
+import { DEFAULT_PADDING } from './fitBounds.constants';
+
+type FitBoundsArgs = {
+ x1: number;
+ x2: number;
+ y1: number;
+ y2: number;
+};
+
+export const fitBounds = ({ x1, y1, x2, y2 }: FitBoundsArgs): void => {
+ const mapInstance = MapManager.getMapInstance();
+
+ if (!mapInstance) return;
+
+ const mapSize = mapDataSizeSelector(store.getState());
+
+ const points = [
+ {
+ x: x1,
+ y: y2,
+ },
+ {
+ x: x2,
+ y: y1,
+ },
+ ];
+
+ const coordinates = points.map(point => pointToProjection(point, mapSize));
+
+ const extent = boundingExtent(coordinates);
+
+ const options: FitOptions = {
+ size: mapInstance.getSize(),
+ padding: DEFAULT_PADDING,
+ maxZoom: mapSize.maxZoom,
+ };
+
+ mapInstance.getView().fit(extent, options);
+};
diff --git a/src/services/pluginsManager/map/fitBounds/fitBounds.utils.test.ts b/src/services/pluginsManager/map/fitBounds/fitBounds.utils.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d2f5cace7114605d75e196fed183c2521c477f0
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/fitBounds.utils.test.ts
@@ -0,0 +1,66 @@
+/* eslint-disable no-magic-numbers */
+import { pointToProjection } from './fitBounds.utils';
+
+describe('pointToProjection - util', () => {
+ describe('when mapSize arg is invalid', () => {
+ const validPoint = {
+ x: 0,
+ y: 0,
+ };
+
+ const invalidMapSize = {
+ width: -256 * 10,
+ height: -256 * 10,
+ tileSize: -256,
+ minZoom: -1,
+ maxZoom: -10,
+ };
+
+ it('should return fallback value on function call', () => {
+ expect(pointToProjection(validPoint, invalidMapSize)).toStrictEqual([0, -0]);
+ });
+ });
+
+ describe('when point and map size is valid', () => {
+ const validPoint = {
+ x: 256 * 100,
+ y: 256 * 100,
+ };
+
+ const validMapSize = {
+ width: 256 * 10,
+ height: 256 * 10,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 10,
+ };
+
+ const results = [380712659, -238107693];
+
+ it('should return valid lat lng value on function call', () => {
+ const [x, y] = pointToProjection(validPoint, validMapSize);
+
+ expect(x).toBe(results[0]);
+ expect(y).toBe(results[1]);
+ });
+ });
+ describe('when point arg is invalid', () => {
+ const invalidPoint = {
+ x: 'x',
+ y: 'y',
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ } as any;
+
+ const validMapSize = {
+ width: 256 * 10,
+ height: 256 * 10,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 10,
+ };
+
+ it('should return fallback value on function call', () => {
+ expect(pointToProjection(invalidPoint, validMapSize)).toStrictEqual([0, 0]);
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/fitBounds/fitBounds.utils.ts b/src/services/pluginsManager/map/fitBounds/fitBounds.utils.ts
new file mode 100644
index 0000000000000000000000000000000000000000..de206bd4204bf1b3b86a36b2b95fed66f25621b9
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/fitBounds.utils.ts
@@ -0,0 +1,14 @@
+import { LATLNG_FALLBACK } from '@/constants/map';
+import { MapSize } from '@/redux/map/map.types';
+import { Point } from '@/types/map';
+import { pointToLngLat } from '@/utils/map/pointToLatLng';
+import { fromLonLat } from 'ol/proj';
+
+export const pointToProjection = (point: Point, mapSize: MapSize): number[] => {
+ const [lng, lat] = pointToLngLat(point, mapSize);
+ const projection = fromLonLat([lng, lat]);
+ const projectionRounded = projection.map(v => Math.round(v));
+ const isValid = !projectionRounded.some(v => Number.isNaN(v));
+
+ return isValid ? projectionRounded : LATLNG_FALLBACK;
+};
diff --git a/src/services/pluginsManager/map/fitBounds/index.ts b/src/services/pluginsManager/map/fitBounds/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..28bd7717581efd4f6b5cb49e47cc974f9d5082e9
--- /dev/null
+++ b/src/services/pluginsManager/map/fitBounds/index.ts
@@ -0,0 +1 @@
+export { fitBounds } from './fitBounds';
diff --git a/src/services/pluginsManager/map/getOpenMapId.test.ts b/src/services/pluginsManager/map/getOpenMapId.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cdbe214786e9e884bf49fa1f70003e0569b018d5
--- /dev/null
+++ b/src/services/pluginsManager/map/getOpenMapId.test.ts
@@ -0,0 +1,40 @@
+import { RootState, store } from '@/redux/store';
+import { initialMapStateFixture } from '@/redux/map/map.fixtures';
+import { getOpenMapId } from './getOpenMapId';
+import { ERROR_INVALID_MODEL_ID_TYPE_FOR_RETRIEVAL } from '../errorMessages';
+
+describe('getOpenMapId', () => {
+ const getStateMock = jest.spyOn(store, 'getState');
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+ it('should return the modelId of the current map', () => {
+ getStateMock.mockImplementation(
+ () =>
+ ({
+ map: initialMapStateFixture,
+ }) as RootState,
+ );
+
+ expect(getOpenMapId()).toEqual(initialMapStateFixture.data.modelId);
+ });
+
+ it('should throw an error if modelId is not a number', () => {
+ getStateMock.mockImplementation(
+ () =>
+ ({
+ map: {
+ ...initialMapStateFixture,
+ data: {
+ ...initialMapStateFixture.data,
+ modelId: null,
+ },
+ },
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ }) as any,
+ );
+
+ expect(() => getOpenMapId()).toThrowError(ERROR_INVALID_MODEL_ID_TYPE_FOR_RETRIEVAL);
+ });
+});
diff --git a/src/services/pluginsManager/map/getOpenMapId.ts b/src/services/pluginsManager/map/getOpenMapId.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dd3cc808d3f66f423719c5dc0e4f84c54e55ad54
--- /dev/null
+++ b/src/services/pluginsManager/map/getOpenMapId.ts
@@ -0,0 +1,13 @@
+import { store } from '@/redux/store';
+import { ERROR_INVALID_MODEL_ID_TYPE_FOR_RETRIEVAL } from '../errorMessages';
+
+export const getOpenMapId = (): number => {
+ const currentMap = store.getState().map.data;
+ const openMapId = currentMap.modelId;
+
+ if (typeof openMapId !== 'number') {
+ throw new Error(ERROR_INVALID_MODEL_ID_TYPE_FOR_RETRIEVAL);
+ }
+
+ return openMapId;
+};
diff --git a/src/services/pluginsManager/map/mapManager.test.ts b/src/services/pluginsManager/map/mapManager.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9f3349c99af786ee65b9ca85a57e8ae3e45415e8
--- /dev/null
+++ b/src/services/pluginsManager/map/mapManager.test.ts
@@ -0,0 +1,34 @@
+import { Map } from 'ol';
+
+import { MapInstance } from '@/types/map';
+import { MapManager } from './mapManager';
+
+describe('MapManager', () => {
+ describe('getMapInstance', () => {
+ it('should return null if no map instance is set', () => {
+ expect(MapManager.getMapInstance()).toBeNull();
+ });
+
+ it('should return the set map instance', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ MapManager.setMapInstance(mapInstance);
+ expect(MapManager.getMapInstance()).toEqual(mapInstance);
+ });
+ });
+
+ describe('setMapInstance', () => {
+ beforeEach(() => {
+ MapManager.mapInstance = null;
+ });
+ it('should set the map instance', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ MapManager.setMapInstance(mapInstance);
+ expect(MapManager.mapInstance).toEqual(mapInstance);
+ });
+ it('should throw error if map instance is not valid', () => {
+ expect(() => MapManager.setMapInstance({} as MapInstance)).toThrow('Not valid map instance');
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/mapManager.ts b/src/services/pluginsManager/map/mapManager.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a710f208d99e0f8fbf8bdfd521eba778b0708bc4
--- /dev/null
+++ b/src/services/pluginsManager/map/mapManager.ts
@@ -0,0 +1,18 @@
+import { MapInstance } from '@/types/map';
+import { Map } from 'ol';
+
+type MapManagerType = {
+ mapInstance: null | MapInstance;
+ setMapInstance: (mapInstance: MapInstance) => void;
+ getMapInstance: () => MapInstance | null;
+};
+
+export const MapManager: MapManagerType = {
+ mapInstance: null,
+
+ setMapInstance: (mapInstance: MapInstance) => {
+ if (!(mapInstance instanceof Map)) throw new Error('Not valid map instance');
+ MapManager.mapInstance = mapInstance;
+ },
+ getMapInstance: () => MapManager.mapInstance,
+};
diff --git a/src/services/pluginsManager/map/triggerSearch/getPolygonPoints.ts b/src/services/pluginsManager/map/triggerSearch/getPolygonPoints.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce27f4ba68a74409e4623fa2c737161df54c4261
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/getPolygonPoints.ts
@@ -0,0 +1,33 @@
+import { allVisibleBioEntitiesSelector } from '@/redux/bioEntity/bioEntity.selectors';
+import { store } from '@/redux/store';
+import { isPointValid } from '@/utils/point/isPointValid';
+
+type Points = {
+ x: number;
+ y: number;
+}[];
+
+export const getPolygonPoints = (): Points => {
+ const allVisibleBioEntities = allVisibleBioEntitiesSelector(store.getState());
+ const allX = allVisibleBioEntities.map(({ x }) => x);
+ const allY = allVisibleBioEntities.map(({ y }) => y);
+
+ const minX = Math.min(...allX);
+ const maxX = Math.max(...allX);
+
+ const minY = Math.min(...allY);
+ const maxY = Math.max(...allY);
+
+ const points = [
+ {
+ x: minX,
+ y: maxY,
+ },
+ {
+ x: maxX,
+ y: minY,
+ },
+ ];
+
+ return points.filter(isPointValid);
+};
diff --git a/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.test.ts b/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..47fc1165f558c948e10f02c45d7f274f045372fa
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.test.ts
@@ -0,0 +1,158 @@
+/* eslint-disable no-magic-numbers */
+import { MAP_INITIAL_STATE } from '@/redux/map/map.constants';
+import { RootState, store } from '@/redux/store';
+import { bioEntityContentFixture } from '@/models/fixtures/bioEntityContentsFixture';
+import { DRAWER_INITIAL_STATE } from '@/redux/drawer/drawer.constants';
+
+import { MODELS_DATA_MOCK_WITH_MAIN_MAP } from '@/redux/models/models.mock';
+import { getVisibleBioEntitiesPolygonCoordinates } from './getVisibleBioEntitiesPolygonCoordinates';
+
+jest.mock('../../../../redux/store');
+
+const getStateSpy = jest.spyOn(store, 'getState');
+
+describe('getVisibleBioEntitiesPolygonCoordinates', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+ it('should return undefined if received array does not contain bioEntities with current map id', () => {
+ getStateSpy.mockImplementation(
+ () =>
+ ({
+ models: MODELS_DATA_MOCK_WITH_MAIN_MAP,
+ map: {
+ ...MAP_INITIAL_STATE,
+ data: {
+ ...MAP_INITIAL_STATE.data,
+ modelId: 5052,
+ size: {
+ width: 256,
+ height: 256,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 1,
+ },
+ },
+ },
+ bioEntity: {
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drugs: {
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drawer: {
+ ...DRAWER_INITIAL_STATE,
+ bioEntityDrawerState: {
+ bioentityId: undefined,
+ drugs: {},
+ chemicals: {},
+ },
+ },
+ }) as RootState,
+ );
+
+ expect(getVisibleBioEntitiesPolygonCoordinates()).toBe(undefined);
+ });
+ it('should return coordinates, max zoom, and map instance if received array contain bioEntities with current map id and max zoom', () => {
+ getStateSpy.mockImplementation(
+ () =>
+ ({
+ models: MODELS_DATA_MOCK_WITH_MAIN_MAP,
+ map: {
+ ...MAP_INITIAL_STATE,
+ data: {
+ ...MAP_INITIAL_STATE.data,
+ modelId: 52,
+ size: {
+ width: 256,
+ height: 256,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 5,
+ },
+ },
+ },
+ bioEntity: {
+ data: [
+ {
+ searchQueryElement: bioEntityContentFixture.bioEntity.name,
+ loading: 'succeeded',
+ error: { name: '', message: '' },
+ data: [
+ {
+ ...bioEntityContentFixture,
+ bioEntity: {
+ ...bioEntityContentFixture.bioEntity,
+ model: 52,
+ x: 97,
+ y: 53,
+ z: 1,
+ },
+ },
+ {
+ ...bioEntityContentFixture,
+ bioEntity: {
+ ...bioEntityContentFixture.bioEntity,
+ model: 52,
+ x: 12,
+ y: 25,
+ z: 1,
+ },
+ },
+ ],
+ },
+ ],
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drugs: {
+ data: [
+ {
+ searchQueryElement: '',
+ loading: 'succeeded',
+ error: { name: '', message: '' },
+ data: undefined,
+ },
+ ],
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ chemicals: {
+ data: [
+ {
+ searchQueryElement: '',
+ loading: 'succeeded',
+ error: { name: '', message: '' },
+ data: undefined,
+ },
+ ],
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drawer: {
+ ...DRAWER_INITIAL_STATE,
+ bioEntityDrawerState: {
+ bioentityId: undefined,
+ drugs: {},
+ chemicals: {},
+ },
+ searchDrawerState: {
+ ...DRAWER_INITIAL_STATE.searchDrawerState,
+ selectedSearchElement: bioEntityContentFixture.bioEntity.name,
+ },
+ },
+ }) as RootState,
+ );
+
+ expect(getVisibleBioEntitiesPolygonCoordinates()).toEqual({
+ mapInstance: null,
+ maxZoom: 5,
+ polygonCoordinates: [
+ [-18158992, 11740728],
+ [-4852834, 16123932],
+ ],
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.ts b/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c1fba3388515df219601634b120ec9efef05e264
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/getVisibleBioEntitiesPolygonCoordinates.ts
@@ -0,0 +1,33 @@
+import { store } from '@/redux/store';
+import { mapDataSizeSelector } from '@/redux/map/map.selectors';
+import { MapInstance } from '@/types/map';
+import { MapManager } from '../mapManager';
+import { pointToProjection } from '../fitBounds/fitBounds.utils';
+import { getPolygonPoints } from './getPolygonPoints';
+
+const VALID_POLYGON_COORDINATES_LENGTH = 2;
+
+export const getVisibleBioEntitiesPolygonCoordinates = ():
+ | {
+ polygonCoordinates: number[][];
+ maxZoom: number;
+ mapInstance: MapInstance | null;
+ }
+ | undefined => {
+ const mapSize = mapDataSizeSelector(store.getState());
+ const { maxZoom } = mapDataSizeSelector(store.getState());
+
+ const polygonPoints = getPolygonPoints();
+
+ const polygonCoordinates = polygonPoints.map(point => pointToProjection(point, mapSize));
+
+ if (polygonCoordinates.length !== VALID_POLYGON_COORDINATES_LENGTH) {
+ return undefined;
+ }
+
+ return {
+ polygonCoordinates,
+ maxZoom,
+ mapInstance: MapManager.getMapInstance(),
+ };
+};
diff --git a/src/services/pluginsManager/map/triggerSearch/searchByCoordinates.ts b/src/services/pluginsManager/map/triggerSearch/searchByCoordinates.ts
index bdd6a539ddbfc7eca3934a8700061acc54d8de24..c04dfaace49cb9e95f3d76640e407b80a11c3ff1 100644
--- a/src/services/pluginsManager/map/triggerSearch/searchByCoordinates.ts
+++ b/src/services/pluginsManager/map/triggerSearch/searchByCoordinates.ts
@@ -8,6 +8,8 @@ import { Coordinates } from './triggerSearch.types';
export const searchByCoordinates = async (
coordinates: Coordinates,
modelId: number,
+ hasFitBounds?: boolean,
+ fitBoundsZoom?: number,
): Promise<void> => {
const { dispatch } = store;
// side-effect below is to prevent complications with data update - old data may conflict with new data
@@ -23,5 +25,5 @@ export const searchByCoordinates = async (
return;
}
- handleSearchResultAction({ searchResults, dispatch });
+ handleSearchResultAction({ searchResults, dispatch, hasFitBounds, fitBoundsZoom });
};
diff --git a/src/services/pluginsManager/map/triggerSearch/searchByQuery.test.ts b/src/services/pluginsManager/map/triggerSearch/searchByQuery.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e804a294f9ad4f681661e008f15897543d1db1d9
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/searchByQuery.test.ts
@@ -0,0 +1,119 @@
+import { RootState, store } from '@/redux/store';
+import { mockNetworkNewAPIResponse } from '@/utils/mockNetworkResponse';
+import { apiPath } from '@/redux/apiPath';
+import { HttpStatusCode } from 'axios';
+import { bioEntityResponseFixture } from '@/models/fixtures/bioEntityContentsFixture';
+import { drugsFixture } from '@/models/fixtures/drugFixtures';
+import { chemicalsFixture } from '@/models/fixtures/chemicalsFixture';
+import { DRAWER_INITIAL_STATE } from '@/redux/drawer/drawer.constants';
+import { MODELS_DATA_MOCK_WITH_MAIN_MAP } from '@/redux/models/models.mock';
+import { MAP_INITIAL_STATE } from '@/redux/map/map.constants';
+import { waitFor } from '@testing-library/react';
+import { searchByQuery } from './searchByQuery';
+import { searchFitBounds } from './searchFitBounds';
+
+const MOCK_SEARCH_BY_QUERY_STORE = {
+ models: MODELS_DATA_MOCK_WITH_MAIN_MAP,
+ map: {
+ ...MAP_INITIAL_STATE,
+ data: {
+ ...MAP_INITIAL_STATE.data,
+ modelId: 5052,
+ size: {
+ width: 256,
+ height: 256,
+ tileSize: 256,
+ minZoom: 1,
+ maxZoom: 1,
+ },
+ },
+ },
+ bioEntity: {
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drugs: {
+ loading: 'succeeded',
+ error: { message: '', name: '' },
+ },
+ drawer: {
+ ...DRAWER_INITIAL_STATE,
+ bioEntityDrawerState: {
+ bioentityId: undefined,
+ drugs: {},
+ chemicals: {},
+ },
+ },
+};
+
+const mockedAxiosClient = mockNetworkNewAPIResponse();
+const SEARCH_QUERY = 'park7';
+
+jest.mock('./searchFitBounds');
+jest.mock('../../../../redux/store');
+const dispatchSpy = jest.spyOn(store, 'dispatch');
+const getStateSpy = jest.spyOn(store, 'getState');
+
+describe('searchByQuery', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+ it('should fit bounds after search if hasFitBounds param is true', async () => {
+ dispatchSpy.mockImplementation(() => ({
+ unwrap: (): Promise<void> => Promise.resolve(),
+ }));
+
+ getStateSpy.mockImplementation(() => MOCK_SEARCH_BY_QUERY_STORE as RootState);
+ mockedAxiosClient
+ .onGet(
+ apiPath.getBioEntityContentsStringWithQuery({
+ searchQuery: SEARCH_QUERY,
+ isPerfectMatch: false,
+ }),
+ )
+ .reply(HttpStatusCode.Ok, bioEntityResponseFixture);
+
+ mockedAxiosClient
+ .onGet(apiPath.getDrugsStringWithQuery(SEARCH_QUERY))
+ .reply(HttpStatusCode.Ok, drugsFixture);
+
+ mockedAxiosClient
+ .onGet(apiPath.getChemicalsStringWithQuery(SEARCH_QUERY))
+ .reply(HttpStatusCode.Ok, chemicalsFixture);
+
+ searchByQuery(SEARCH_QUERY, false, true);
+
+ await waitFor(() => {
+ expect(searchFitBounds).toHaveBeenCalled();
+ });
+ });
+ it('should not fit bounds after search if hasFitBounds param is false', async () => {
+ dispatchSpy.mockImplementation(() => ({
+ unwrap: (): Promise<void> => Promise.resolve(),
+ }));
+
+ getStateSpy.mockImplementation(() => MOCK_SEARCH_BY_QUERY_STORE as RootState);
+ mockedAxiosClient
+ .onGet(
+ apiPath.getBioEntityContentsStringWithQuery({
+ searchQuery: SEARCH_QUERY,
+ isPerfectMatch: false,
+ }),
+ )
+ .reply(HttpStatusCode.Ok, bioEntityResponseFixture);
+
+ mockedAxiosClient
+ .onGet(apiPath.getDrugsStringWithQuery(SEARCH_QUERY))
+ .reply(HttpStatusCode.Ok, drugsFixture);
+
+ mockedAxiosClient
+ .onGet(apiPath.getChemicalsStringWithQuery(SEARCH_QUERY))
+ .reply(HttpStatusCode.Ok, chemicalsFixture);
+
+ searchByQuery(SEARCH_QUERY, false, false);
+
+ await waitFor(() => {
+ expect(searchFitBounds).not.toHaveBeenCalled();
+ });
+ });
+});
diff --git a/src/services/pluginsManager/map/triggerSearch/searchByQuery.ts b/src/services/pluginsManager/map/triggerSearch/searchByQuery.ts
index 01d0603743171cebd905be553cf7d61aa6824fc1..4f48c0a74b0ad1067c66bc99dfd539b0001a695d 100644
--- a/src/services/pluginsManager/map/triggerSearch/searchByQuery.ts
+++ b/src/services/pluginsManager/map/triggerSearch/searchByQuery.ts
@@ -2,13 +2,27 @@ import { getSearchValuesArrayAndTrimToSeven } from '@/components/FunctionalArea/
import { getSearchData } from '@/redux/search/search.thunks';
import { store } from '@/redux/store';
import { displaySearchDrawerWithSelectedDefaultTab } from './displaySearchDrawerWithSelectedDefaultTab';
+import { searchFitBounds } from './searchFitBounds';
-export const searchByQuery = (query: string, perfectSearch: boolean | undefined): void => {
+export const searchByQuery = (
+ query: string,
+ perfectSearch: boolean | undefined,
+ hasFitBounds?: boolean,
+): void => {
const { dispatch } = store;
const searchValues = getSearchValuesArrayAndTrimToSeven(query);
const isPerfectMatch = !!perfectSearch;
- dispatch(getSearchData({ searchQueries: searchValues, isPerfectMatch }));
+ dispatch(getSearchData({ searchQueries: searchValues, isPerfectMatch }))
+ ?.unwrap()
+ .then(() => {
+ if (hasFitBounds) {
+ searchFitBounds();
+ }
+ })
+ .catch(() => {
+ // TODO to discuss manage state of failure
+ });
displaySearchDrawerWithSelectedDefaultTab(searchValues);
};
diff --git a/src/services/pluginsManager/map/triggerSearch/searchFitBounds.test.ts b/src/services/pluginsManager/map/triggerSearch/searchFitBounds.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..25847a33e9a61f93189d4d8882e92d6a81d43eac
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/searchFitBounds.test.ts
@@ -0,0 +1,105 @@
+/* eslint-disable no-magic-numbers */
+import { handleSetBounds } from '@/utils/map/useSetBounds';
+import { Map } from 'ol';
+import * as getVisibleBioEntitiesPolygonCoordinates from './getVisibleBioEntitiesPolygonCoordinates';
+import { searchFitBounds } from './searchFitBounds';
+
+jest.mock('../../../../utils/map/useSetBounds');
+
+jest.mock('./getVisibleBioEntitiesPolygonCoordinates', () => ({
+ __esModule: true,
+ ...jest.requireActual('./getVisibleBioEntitiesPolygonCoordinates'),
+}));
+
+const getVisibleBioEntitiesPolygonCoordinatesSpy = jest.spyOn(
+ getVisibleBioEntitiesPolygonCoordinates,
+ 'getVisibleBioEntitiesPolygonCoordinates',
+);
+
+describe('searchFitBounds', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+ it('should not handle set bounds if data is not valid', () => {
+ getVisibleBioEntitiesPolygonCoordinatesSpy.mockImplementation(() => undefined);
+
+ searchFitBounds();
+
+ expect(handleSetBounds).not.toHaveBeenCalled();
+ });
+ it('should not handle set bounds if map instance is not valid', () => {
+ getVisibleBioEntitiesPolygonCoordinatesSpy.mockImplementation(() => ({
+ mapInstance: null,
+ maxZoom: 5,
+ polygonCoordinates: [
+ [231, 231],
+ [842, 271],
+ ],
+ }));
+
+ searchFitBounds();
+
+ expect(handleSetBounds).not.toHaveBeenCalled();
+ });
+ it('should handle set bounds if provided data is valid', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ const maxZoom = 5;
+ const polygonCoordinates = [
+ [231, 231],
+ [842, 271],
+ ];
+
+ getVisibleBioEntitiesPolygonCoordinatesSpy.mockImplementation(() => ({
+ mapInstance,
+ maxZoom,
+ polygonCoordinates,
+ }));
+
+ searchFitBounds();
+
+ expect(handleSetBounds).toHaveBeenCalled();
+ expect(handleSetBounds).toHaveBeenCalledWith(mapInstance, maxZoom, polygonCoordinates);
+ });
+ it('should handle set bounds with max zoom if zoom is not provided in argument', () => {
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ const maxZoom = 23;
+ const polygonCoordinates = [
+ [231, 231],
+ [842, 271],
+ ];
+
+ getVisibleBioEntitiesPolygonCoordinatesSpy.mockImplementation(() => ({
+ mapInstance,
+ maxZoom,
+ polygonCoordinates,
+ }));
+
+ searchFitBounds();
+
+ expect(handleSetBounds).toHaveBeenCalled();
+ expect(handleSetBounds).toHaveBeenCalledWith(mapInstance, maxZoom, polygonCoordinates);
+ });
+ it('should handle set bounds with zoom provided in argument instead of max zoom', () => {
+ const zoom = 12;
+ const dummyElement = document.createElement('div');
+ const mapInstance = new Map({ target: dummyElement });
+ const maxZoom = 23;
+ const polygonCoordinates = [
+ [231, 231],
+ [842, 271],
+ ];
+
+ getVisibleBioEntitiesPolygonCoordinatesSpy.mockImplementation(() => ({
+ mapInstance,
+ maxZoom,
+ polygonCoordinates,
+ }));
+
+ searchFitBounds(zoom);
+
+ expect(handleSetBounds).toHaveBeenCalled();
+ expect(handleSetBounds).toHaveBeenCalledWith(mapInstance, zoom, polygonCoordinates);
+ });
+});
diff --git a/src/services/pluginsManager/map/triggerSearch/searchFitBounds.ts b/src/services/pluginsManager/map/triggerSearch/searchFitBounds.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9c2954ebe5525040cb3550b085613b0b0b781153
--- /dev/null
+++ b/src/services/pluginsManager/map/triggerSearch/searchFitBounds.ts
@@ -0,0 +1,15 @@
+import { handleSetBounds } from '@/utils/map/useSetBounds';
+import { getVisibleBioEntitiesPolygonCoordinates } from './getVisibleBioEntitiesPolygonCoordinates';
+
+export const searchFitBounds = (zoom?: number): void => {
+ const data = getVisibleBioEntitiesPolygonCoordinates();
+
+ if (data) {
+ const { polygonCoordinates, maxZoom, mapInstance } = data;
+
+ if (!mapInstance) return;
+
+ const setBoundsZoom = zoom || maxZoom;
+ handleSetBounds(mapInstance, setBoundsZoom, polygonCoordinates);
+ }
+};
diff --git a/src/services/pluginsManager/map/triggerSearch/triggerSearch.test.ts b/src/services/pluginsManager/map/triggerSearch/triggerSearch.test.ts
index 3c7408ebf99514fc11abc6bd75118bae26192724..1b522bb065723a9ef78cf2d24e01869960c3c00a 100644
--- a/src/services/pluginsManager/map/triggerSearch/triggerSearch.test.ts
+++ b/src/services/pluginsManager/map/triggerSearch/triggerSearch.test.ts
@@ -10,6 +10,7 @@ import { bioEntityResponseFixture } from '@/models/fixtures/bioEntityContentsFix
import { waitFor } from '@testing-library/react';
import { handleSearchResultAction } from '@/components/Map/MapViewer/utils/listeners/mapSingleClick/handleSearchResultAction';
import { triggerSearch } from './triggerSearch';
+import { ERROR_INVALID_MODEL_ID_TYPE } from '../../errorMessages';
const mockedAxiosClient = mockNetworkNewAPIResponse();
const mockedAxiosOldClient = mockNetworkResponse();
@@ -148,9 +149,7 @@ describe('triggerSearch', () => {
modelId: '53' as any,
};
- await expect(triggerSearch(invalidParams)).rejects.toThrowError(
- 'Invalid model id type. The model should be of number type',
- );
+ await expect(triggerSearch(invalidParams)).rejects.toThrowError(ERROR_INVALID_MODEL_ID_TYPE);
});
it('should search result with proper data', async () => {
mockedAxiosOldClient
diff --git a/src/services/pluginsManager/map/triggerSearch/triggerSearch.ts b/src/services/pluginsManager/map/triggerSearch/triggerSearch.ts
index 8f1b42fe3f895d34ee15ea2beb690b16a8d2f202..8a69f07b6570907182960db7bd2e770d5b6e6644 100644
--- a/src/services/pluginsManager/map/triggerSearch/triggerSearch.ts
+++ b/src/services/pluginsManager/map/triggerSearch/triggerSearch.ts
@@ -12,7 +12,7 @@ export async function triggerSearch(params: SearchParams): Promise<void> {
if (typeof params.query !== 'string') {
throw new Error(ERROR_INVALID_QUERY_TYPE);
}
- searchByQuery(params.query, params.perfectSearch);
+ searchByQuery(params.query, params.perfectSearch, params.fitBounds);
} else {
const areCoordinatesInvalidType =
typeof params.coordinates !== 'object' || params.coordinates === null;
@@ -28,6 +28,6 @@ export async function triggerSearch(params: SearchParams): Promise<void> {
throw new Error(ERROR_INVALID_MODEL_ID_TYPE);
}
- searchByCoordinates(params.coordinates, params.modelId);
+ searchByCoordinates(params.coordinates, params.modelId, params.fitBounds, params.zoom);
}
}
diff --git a/src/services/pluginsManager/pluginsManager.ts b/src/services/pluginsManager/pluginsManager.ts
index 23a78ff89353268cccf150657ebb644f4c850259..c0b7bd2b474b3c61cce3aa8fdfcd2de6d3cf2e54 100644
--- a/src/services/pluginsManager/pluginsManager.ts
+++ b/src/services/pluginsManager/pluginsManager.ts
@@ -15,6 +15,10 @@ import { getOrganism } from './project/data/getOrganism';
import type { PluginsManagerType } from './pluginsManager.types';
import { configurationMapper } from './pluginsManager.utils';
+import { getBounds } from './map/data/getBounds';
+import { fitBounds } from './map/fitBounds';
+import { getOpenMapId } from './map/getOpenMapId';
+
export const PluginsManager: PluginsManagerType = {
hashedPlugins: {},
setHashedPlugin({ pluginUrl, pluginScript }) {
@@ -34,8 +38,11 @@ export const PluginsManager: PluginsManagerType = {
},
map: {
data: {
+ getBounds,
+ getOpenMapId,
getModels,
},
+ fitBounds,
openMap,
triggerSearch,
},
diff --git a/src/utils/context/mapInstanceContext.tsx b/src/utils/context/mapInstanceContext.tsx
index 1c0982d8e55a4bcbafdf1416b473b43afcf9f9b9..85fe8fc8f6f02db14da4a38b6933a197c1fddee9 100644
--- a/src/utils/context/mapInstanceContext.tsx
+++ b/src/utils/context/mapInstanceContext.tsx
@@ -1,14 +1,15 @@
+import { MapManager } from '@/services/pluginsManager/map/mapManager';
import { MapInstance } from '@/types/map';
-import { Dispatch, SetStateAction, createContext, useContext, useMemo, useState } from 'react';
+import { createContext, useCallback, useContext, useMemo, useState } from 'react';
export interface MapInstanceContext {
mapInstance: MapInstance;
- setMapInstance: Dispatch<SetStateAction<MapInstance>>;
+ handleSetMapInstance: (mapInstance: MapInstance) => void;
}
export const MapInstanceContext = createContext<MapInstanceContext>({
mapInstance: undefined,
- setMapInstance: () => {},
+ handleSetMapInstance: () => {},
});
export const useMapInstance = (): MapInstanceContext => useContext(MapInstanceContext);
@@ -24,12 +25,22 @@ export const MapInstanceProvider = ({
}: MapInstanceProviderProps): JSX.Element => {
const [mapInstance, setMapInstance] = useState<MapInstance>(initialValue?.mapInstance);
+ const handleSetMapInstance = useCallback(
+ (map: MapInstance) => {
+ if (!mapInstance) {
+ setMapInstance(map);
+ MapManager.setMapInstance(map);
+ }
+ },
+ [mapInstance],
+ );
+
const mapInstanceContextValue = useMemo(
() => ({
mapInstance,
- setMapInstance,
+ handleSetMapInstance,
}),
- [mapInstance],
+ [mapInstance, handleSetMapInstance],
);
return (
diff --git a/src/utils/map/useSetBounds.test.ts b/src/utils/map/useSetBounds.test.ts
index 4e00469d4c7df59c3b33135a5c6da8182b1e0db5..71ee12602b0c344b7276446cb952b1dbb1d687d9 100644
--- a/src/utils/map/useSetBounds.test.ts
+++ b/src/utils/map/useSetBounds.test.ts
@@ -39,7 +39,7 @@ describe('useSetBounds - hook', () => {
{
mapInstanceContextValue: {
mapInstance: undefined,
- setMapInstance: () => {},
+ handleSetMapInstance: () => {},
},
},
);
@@ -84,7 +84,7 @@ describe('useSetBounds - hook', () => {
{
mapInstanceContextValue: {
mapInstance,
- setMapInstance: () => {},
+ handleSetMapInstance: () => {},
},
},
);