@opengeoweb/cap 9.6.0

package/index.esm.js

@@ -0,0 +1,990 @@
+import React from 'react';
+import { useApiContext, useApi, createNonAuthApiInstance, ApiProvider } from '@opengeoweb/api';
+import { Grid, Typography, Box, Card, CircularProgress } from '@mui/material';
+import { Box as Box$1 } from '@mui/system';
+import { dateUtils, AlertBanner, withEggs } from '@opengeoweb/shared';
+import { useTranslation } from 'react-i18next';
+import { useSelector, useDispatch } from 'react-redux';
+import { createEntityAdapter, createSlice, createSelector } from '@reduxjs/toolkit';
+import 'i18next';
+import { ConfigurableMapConnect } from '@opengeoweb/core';
+import { mapSelectors, coreModuleConfig } from '@opengeoweb/store';
+import { webmapUtils } from '@opengeoweb/webmap';
+import { MapViewLayer, MapWarningProperties } from '@opengeoweb/webmap-react';
+import { fromUnixTime } from 'date-fns';
+import { ThemeWrapper } from '@opengeoweb/theme';
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const feedAdapter = createEntityAdapter();
+const feedInitialState = feedAdapter.getInitialState();
+const alertAdapter = createEntityAdapter({
+  // we use identifier as id
+  selectId: capAlert => capAlert.identifier
+});
+const alertInitialState = alertAdapter.getInitialState();
+const initialState = {
+  feeds: feedInitialState,
+  alerts: alertInitialState
+};
+const slice = createSlice({
+  initialState,
+  name: 'capReducer',
+  reducers: {
+    addManyAlerts: (draft, action) => {
+      alertAdapter.upsertMany(draft.alerts, action.payload);
+    },
+    addManyAlertsToFeed: (draft, action) => {
+      feedAdapter.upsertOne(draft.feeds, {
+        id: action.payload.feedId,
+        lastUpdated: Date.now(),
+        alertIds: action.payload.alertIds
+      });
+    },
+    setFeedLastUpdatedTimes: (draft, action) => {
+      feedAdapter.updateMany(draft.feeds, action.payload);
+    }
+  }
+});
+const {
+  reducer
+} = slice;
+const capActions = slice.actions;
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const {
+  selectById: getCapFeedById,
+  selectAll: getCapFeeds
+} = feedAdapter.getSelectors(state => state.capStore.feeds);
+const {
+  selectById: getAlertById,
+  selectAll: getAlerts,
+  selectIds: getAlertIds
+} = alertAdapter.getSelectors(state => state.capStore.alerts);
+const getAlertsInEffect = createSelector(getAlerts, (_state, selectedTime) => selectedTime, (alerts, selectedTime) => {
+  return alerts.filter(alert => dateUtils.isBetween(dateUtils.createDate(selectedTime), dateUtils.createDate(alert.onset), dateUtils.createDate(alert.expires), '[)'));
+});
+const getLastUpdatedTimes = createSelector(getCapFeeds, feeds => {
+  return feeds.map(feed => feed.lastUpdated);
+});
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const findEventIndexInLanguage = (languages, capWarningPresets, feedAddressFromProps) => {
+  const correctFeedIndex = capWarningPresets.feeds.findIndex(({
+    feedAddress
+  }) => feedAddress === feedAddressFromProps);
+  if (correctFeedIndex === -1) {
+    return 0;
+  }
+  const languageIndex = languages.findIndex(object => object.language === (capWarningPresets === null || capWarningPresets === void 0 ? void 0 : capWarningPresets.feeds[correctFeedIndex].languagePriority));
+  if (languageIndex === -1) {
+    const fallbackLanguage = languages.findIndex(object => object.language.startsWith('en'));
+    if (fallbackLanguage === -1) {
+      return 0;
+    }
+    return fallbackLanguage;
+  }
+  return languageIndex;
+};
+
+var en = {
+	"map-view-cap-error-title": "Something went wrong with loading the configuration file",
+	"warning-list-cap-alert-banner-title": "Note: Only map is affected by timeslider based filtering",
+	"warning-list-cap-error-title": "Something went wrong with loading the configuration file",
+	"warning-list-row-event": "Event",
+	"warning-list-row-severity": "Severity",
+	"warning-list-row-expires": "Expires",
+	"warning-list-row-not-expired": "(not expired)"
+};
+var fi = {
+	"map-view-cap-error-title": "🚧 ei käännetty",
+	"warning-list-cap-alert-banner-title": "🚧 ei käännetty",
+	"warning-list-cap-error-title": "🚧 ei käännetty",
+	"warning-list-row-event": "🚧 ei käännetty",
+	"warning-list-row-severity": "🚧 ei käännetty",
+	"warning-list-row-expires": "🚧 ei käännetty",
+	"warning-list-row-not-expired": "🚧 ei käännetty"
+};
+var capTrans = {
+	en: en,
+	fi: fi
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+const CAP_NAMESPACE = 'cap';
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const severityStyles = {
+  Extreme: {
+    border: 'solid 5px rgb(255, 9, 9)',
+    background: 'rgba(255, 9, 9, 0.15)'
+  },
+  Severe: {
+    border: 'solid 5px rgb(255, 165, 0)',
+    background: 'rgba(255, 165, 0, 0.15)'
+  },
+  Moderate: {
+    border: 'solid 5px rgb(248, 248, 0)',
+    background: 'rgba(248, 248, 0, 0.15)'
+  },
+  Minor: {
+    border: 'solid 5px rgb(106, 248, 108)',
+    background: 'rgba(106, 248, 108, 0.15)'
+  }
+};
+const WarningListRowCap = ({
+  event,
+  severity,
+  expires
+}) => {
+  const {
+    t
+  } = useTranslation(CAP_NAMESPACE);
+  return React.createElement(Grid, {
+    container: true,
+    sx: {
+      border: severityStyles[severity].border,
+      background: severityStyles[severity].background,
+      padding: '5px',
+      marginTop: '20px',
+      marginBottom: '20px',
+      width: '100%'
+    }
+  }, React.createElement(Grid, {
+    item: true,
+    xs: 4
+  }, React.createElement(Typography, {
+    variant: "overline"
+  }, t('warning-list-row-event')), React.createElement(Typography, {
+    variant: "subtitle2",
+    sx: {
+      fontWeight: 'normal'
+    },
+    "data-testid": "event"
+  }, event ? `${event}` : '')), React.createElement(Grid, {
+    item: true,
+    xs: 4
+  }, React.createElement(Typography, {
+    variant: "overline"
+  }, t('warning-list-row-severity')), React.createElement(Typography, {
+    variant: "subtitle2",
+    sx: {
+      fontWeight: 'normal'
+    },
+    "data-testid": "severity"
+  }, severity ? `${severity}` : '')), React.createElement(Grid, {
+    item: true,
+    xs: 4
+  }, React.createElement(Typography, {
+    variant: "overline"
+  }, t('warning-list-row-expires')), React.createElement(Typography, {
+    variant: "subtitle2",
+    sx: {
+      fontWeight: 'normal'
+    },
+    "data-testid": "expires"
+  }, expires ? dateUtils.dateToString(dateUtils.createDate(expires), "dd MMM yyyy, HH:mm 'UTC'") : t('warning-list-row-not-expired'))));
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const WarningListRowCapConnect = ({
+  alertId,
+  capWarningPresets
+}) => {
+  const [languageIndex, setLanguageIndex] = React.useState(0);
+  const alert = useSelector(store => getAlertById(store, alertId));
+  React.useEffect(() => {
+    if (alert) {
+      const foundLanguageIndex = findEventIndexInLanguage(alert.languages, capWarningPresets, alert.feedAddress);
+      setLanguageIndex(foundLanguageIndex);
+    }
+  }, [alert, capWarningPresets]);
+  return React.createElement("div", null, alert && React.createElement(WarningListRowCap, {
+    event: alert.languages[languageIndex].event,
+    severity: alert.severity,
+    expires: alert.expires
+  }));
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const WarningListCap = ({
+  capWarningPresets,
+  alertIds
+}) => {
+  const {
+    t
+  } = useTranslation(CAP_NAMESPACE);
+  return React.createElement(Box, {
+    sx: {
+      width: '100%',
+      height: '100%',
+      display: 'flex'
+    }
+  }, React.createElement(Card, {
+    sx: {
+      justifyContent: 'center',
+      alignItems: 'center',
+      overflow: 'auto',
+      height: '95%',
+      width: '100%',
+      padding: '10px',
+      margin: '20px',
+      marginBottom: '10px',
+      position: 'relative'
+    },
+    "data-testid": "warningList"
+  }, alertIds.length > 0 && React.createElement(Box, {
+    sx: {
+      position: 'sticky',
+      top: 0,
+      width: '100%',
+      display: 'flex',
+      justifyContent: 'center'
+    }
+  }, React.createElement(AlertBanner, {
+    title: t('warning-list-cap-alert-banner-title')
+  })), alertIds.length === 0 ? React.createElement(Box, {
+    sx: {
+      position: 'absolute',
+      left: '50%',
+      top: '20%',
+      zIndex: '100'
+    }
+  }, React.createElement(CircularProgress, null)) : null, alertIds.map(id => React.createElement(WarningListRowCapConnect, {
+    key: id,
+    alertId: id,
+    capWarningPresets: capWarningPresets
+  }))));
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const WarningListCapConnect = ({
+  capWarningPresets
+}) => {
+  const alertIDs = useSelector(store => getAlertIds(store));
+  return React.createElement(WarningListCap, {
+    capWarningPresets: capWarningPresets,
+    alertIds: alertIDs
+  });
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+const WarningListCapConnectWrapper = ({
+  productConfigKey
+}) => {
+  const {
+    api
+  } = useApiContext();
+  const {
+    t
+  } = useTranslation(CAP_NAMESPACE);
+  const {
+    result: productConfig,
+    isLoading: isConfigLoading,
+    error
+  } = useApi(api.getCapConfiguration, productConfigKey);
+  if (isConfigLoading) {
+    return React.createElement(Box$1, {
+      sx: {
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center'
+      }
+    }, React.createElement(CircularProgress, {
+      "data-testid": "loadingSpinner"
+    }));
+  }
+  if (error) {
+    return React.createElement(AlertBanner, {
+      title: t('warning-list-cap-error-title'),
+      info: error.message
+    });
+  }
+  return React.createElement(WarningListCapConnect, {
+    capWarningPresets: productConfig
+  });
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+const getApiRoutes = (axiosInstance, nonAuthAxiosInstance) => ({
+  getCapConfiguration: productConfigKey => {
+    return nonAuthAxiosInstance.get(`/assets/${productConfigKey}`);
+  },
+  getAllAlerts: thirdPartyApiUrl => {
+    return axiosInstance.get(`/allalerts?url=${thirdPartyApiUrl}`);
+  },
+  getFeedLinks: thirdPartyApiUrl => {
+    return axiosInstance.get(`/feedlinks?url=${thirdPartyApiUrl}`);
+  },
+  getSingleAlert: alertUrl => {
+    return axiosInstance.get(`/singlealert?url=${alertUrl}`);
+  },
+  getLastUpdated: thirdPartyApiUrl => {
+    return axiosInstance.get(`/poll_feed?url=${thirdPartyApiUrl}`);
+  }
+});
+const createApi = props => {
+  const axiosInstance = createNonAuthApiInstance(props);
+  const nonAuthAxiosInstance = createNonAuthApiInstance({});
+  return getApiRoutes(axiosInstance, nonAuthAxiosInstance);
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const highlightGeoJson = (currentFeatures, featureResults) => Object.entries(currentFeatures).reduce((byId, [alertId, features]) => {
+  const isSelected = alertId === (featureResults === null || featureResults === void 0 ? void 0 : featureResults.feature.properties.details.identifier);
+  return Object.assign(Object.assign({}, byId), {
+    [alertId]: features.map(feature => {
+      const recoloredFeature = Object.assign({}, feature);
+      recoloredFeature.properties.fill = isSelected ? feature.properties.fill.replace('0.10', '0.25') : recoloredFeature.properties.fill = feature.properties.fill.replace('0.25', '0.10');
+      recoloredFeature.properties['stroke-width'] = isSelected ? 3 : 2;
+      return recoloredFeature;
+    })
+  });
+}, {});
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const addColors = features => {
+  const severityStyles = {
+    Extreme: {
+      stroke: 'rgb(255, 9, 9)',
+      fill: 'rgba(255, 9, 9, 0.10)'
+    },
+    Severe: {
+      stroke: 'rgb(255, 165, 0)',
+      fill: 'rgba(255, 165, 0, 0.10)'
+    },
+    Moderate: {
+      stroke: 'rgb(248, 248, 0)',
+      fill: 'rgba(248, 248, 0, 0.10)'
+    },
+    Minor: {
+      stroke: 'rgb(106, 248, 108)',
+      fill: 'rgba(106, 248, 108, 0.10)'
+    }
+  };
+  for (const feature of features) {
+    const {
+      severity
+    } = feature.properties.details;
+    feature.properties.stroke = severityStyles[severity].stroke;
+    feature.properties.fill = severityStyles[severity].fill;
+    feature.properties['stroke-opacity'] = 1;
+    feature.properties['stroke-width'] = 2;
+  }
+  return features;
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+const addFeedAdressToCustomGeoJSonFeature = (feedAddress, features) => {
+  return features.reduce((list, feature) => {
+    return list.concat(Object.assign(Object.assign({}, feature), {
+      properties: Object.assign(Object.assign({}, feature.properties), {
+        details: Object.assign(Object.assign({}, feature.properties.details), {
+          feedAddress
+        })
+      })
+    }));
+  }, []);
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+const isPromiseFulfilled = result => result.status === 'fulfilled';
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
+const promiseSuccesses = results => results.reduce((acc, result) => isPromiseFulfilled(result) ? [...acc, result.value] : acc, []);
+const MapViewCapConnect = ({
+  id,
+  title,
+  bbox,
+  srs,
+  capWarningPresets,
+  layers
+}) => {
+  const {
+    api
+  } = useApiContext();
+  const dispatch = useDispatch();
+  const previousFeatures = React.useRef(null);
+  const [featuresByAlert, setFeaturesByAlert] = React.useState({});
+  const [selectedFeatureEvent, setSelectedFeatureEvent] = React.useState(null);
+  const mapIdRef = React.useRef(id || webmapUtils.generateMapId());
+  const layerIdRef = React.useRef(webmapUtils.generateLayerId());
+  const currentLastUpdatedTimes = useSelector(store => getLastUpdatedTimes(store));
+  const fetchData = (links, feedAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    const alertsAndFeaturesPromises = links.map(alertUrl => __awaiter(void 0, void 0, void 0, function* () {
+      const {
+        data
+      } = yield api.getSingleAlert(alertUrl);
+      const alert = Object.assign(Object.assign({}, data.alert), {
+        feedAddress
+      });
+      const features = addFeedAdressToCustomGeoJSonFeature(feedAddress, data.features.features);
+      return {
+        alert,
+        features
+      };
+    }));
+    const alertsAndFeatures = yield Promise.allSettled(alertsAndFeaturesPromises);
+    const realAlertsAndFeatures = alertsAndFeatures.reduce((alerts, result) =>
+    // endpoints may throttle requests and return empty alerts
+    isPromiseFulfilled(result) && result.value.alert ? [...alerts, result.value] : alerts, []);
+    const alerts = realAlertsAndFeatures.map(({
+      alert
+    }) => Object.assign({}, alert));
+    dispatch(capActions.addManyAlerts(alerts));
+    dispatch(capActions.addManyAlertsToFeed({
+      feedId: feedAddress,
+      alertIds: alerts.map(alert => alert.identifier)
+    }));
+    const featuresByAlert = realAlertsAndFeatures.reduce((byId, {
+      alert,
+      features
+    }) => Object.assign(Object.assign({}, byId), {
+      [alert.identifier]: addColors(features)
+    }), {});
+    const combinedFeatures = Object.assign(Object.assign({}, previousFeatures.current), featuresByAlert);
+    setFeaturesByAlert(combinedFeatures);
+    previousFeatures.current = combinedFeatures;
+  });
+  const fetchDataFromAllFeeds = () => __awaiter(void 0, void 0, void 0, function* () {
+    const feedPromises = capWarningPresets === null || capWarningPresets === void 0 ? void 0 : capWarningPresets.feeds.map(({
+      feedAddress
+    }) => __awaiter(void 0, void 0, void 0, function* () {
+      const {
+        data: links
+      } = yield api.getFeedLinks(feedAddress);
+      return {
+        links,
+        feedAddress
+      };
+    }));
+    const feedLinks = promiseSuccesses(yield Promise.allSettled(feedPromises));
+    feedLinks.forEach(({
+      links,
+      feedAddress
+    }) => {
+      fetchData(links, feedAddress);
+    });
+  });
+  const pollAndUpdate = React.useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+    const lastUpdatedPromises = capWarningPresets === null || capWarningPresets === void 0 ? void 0 : capWarningPresets.feeds.map(feed => __awaiter(void 0, void 0, void 0, function* () {
+      const {
+        data: updated
+      } = yield api.getLastUpdated(feed.feedAddress);
+      return {
+        id: feed.feedAddress,
+        changes: {
+          lastUpdated: updated.lastUpdated
+        }
+      };
+    }));
+    if (lastUpdatedPromises) {
+      const lastUpdateTimes = promiseSuccesses(yield Promise.allSettled(lastUpdatedPromises));
+      lastUpdateTimes.forEach((feed, i) => __awaiter(void 0, void 0, void 0, function* () {
+        if (dateUtils.isAfter(feed.changes.lastUpdated, currentLastUpdatedTimes[i])) {
+          const {
+            data: links
+          } = yield api.getFeedLinks(feed.id);
+          fetchData(links, feed.id);
+        }
+      }));
+      dispatch(capActions.setFeedLastUpdatedTimes(lastUpdateTimes));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), [currentLastUpdatedTimes]);
+  React.useEffect(() => {
+    fetchDataFromAllFeeds();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  React.useEffect(() => {
+    var _a;
+    const pollInterval = (_a = capWarningPresets === null || capWarningPresets === void 0 ? void 0 : capWarningPresets.pollInterval) !== null && _a !== void 0 ? _a : 300000;
+    const timer = setInterval(() => {
+      pollAndUpdate();
+    }, pollInterval);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [capWarningPresets === null || capWarningPresets === void 0 ? void 0 : capWarningPresets.pollInterval, currentLastUpdatedTimes, pollAndUpdate]);
+  const parentSizeRef = React.useRef(null);
+  const [parentSize, setParentSize] = React.useState(window.innerWidth / 2);
+  React.useEffect(() => {
+    const handleWindowResize = () => {
+      setParentSize(parentSizeRef.current.parentElement.offsetWidth);
+    };
+    window.addEventListener('resize', handleWindowResize);
+    return () => {
+      window.removeEventListener('resize', handleWindowResize);
+    };
+  }, []);
+  const highLightGeoJsonOnClick = featureResults => {
+    const nextState = highlightGeoJson(featuresByAlert, featureResults);
+    setSelectedFeatureEvent(featureResults);
+    setFeaturesByAlert(nextState);
+  };
+  const selectedTime = useSelector(store => mapSelectors.getSelectedTime(store, mapIdRef.current));
+  const alertIdsInEffect = useSelector(store => getAlertsInEffect(store, fromUnixTime(selectedTime).toISOString())).map(({
+    identifier
+  }) => identifier);
+  const featuresInEffect = Object.keys(featuresByAlert).filter(id => alertIdsInEffect.includes(id)).flatMap(id => featuresByAlert[id]);
+  const geoJsonObject = {
+    type: 'FeatureCollection',
+    features: featuresInEffect
+  };
+  return React.createElement("div", {
+    "data-testid": "mapViewCap",
+    style: {
+      height: '100%',
+      width: '100%'
+    },
+    ref: parentSizeRef
+  }, React.createElement(ConfigurableMapConnect, {
+    id: mapIdRef.current,
+    title: title,
+    layers: layers || [],
+    "data-testid": "capWarningMap",
+    bbox: bbox,
+    srs: srs
+  }, React.createElement(MapViewLayer, {
+    id: layerIdRef.current,
+    geojson: geoJsonObject,
+    onClickFeature: highLightGeoJsonOnClick,
+    "data-testid": "polygonLayer"
+  }), selectedFeatureEvent && React.createElement(MapWarningProperties, {
+    "data-testid": "mapWarnings",
+    selectedFeatureProperties: selectedFeatureEvent.feature.properties.details,
+    languageIndex: findEventIndexInLanguage(selectedFeatureEvent.feature.properties.details.languages, capWarningPresets, selectedFeatureEvent.feature.properties.details.feedAddress),
+    parentSize: parentSize
+  })));
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+const MapViewCapConnectWrapper = ({
+  id,
+  title,
+  bbox,
+  srs,
+  productConfigKey,
+  layers
+}) => {
+  const {
+    api
+  } = useApiContext();
+  const {
+    t
+  } = useTranslation(CAP_NAMESPACE);
+  const {
+    result: capWarningPresets,
+    isLoading: isConfigLoading,
+    error
+  } = useApi(api.getCapConfiguration, productConfigKey);
+  if (isConfigLoading) {
+    return React.createElement(Box$1, {
+      sx: {
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center'
+      }
+    }, React.createElement(CircularProgress, {
+      "data-testid": "loadingSpinner"
+    }));
+  }
+  if (error) {
+    return React.createElement(AlertBanner, {
+      title: t('map-view-cap-error-title'),
+      info: error.message
+    });
+  }
+  return React.createElement(MapViewCapConnect, {
+    capWarningPresets: capWarningPresets,
+    id: id,
+    title: title,
+    bbox: bbox,
+    srs: srs,
+    layers: layers
+  });
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const capModuleConfig = {
+  id: 'capStore-module',
+  reducersMap: {
+    capStore: reducer
+  }
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2022 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2022 - Finnish Meteorological Institute (FMI)
+ * */
+const CapThemeWrapper = ({
+  theme,
+  children
+}) => React.createElement(ThemeWrapper, {
+  theme: theme
+}, children);
+withEggs([capModuleConfig, ...coreModuleConfig])(({
+  theme,
+  children
+}) => React.createElement(CapThemeWrapper, {
+  theme: theme
+}, children));
+const CapTranslationsWrapper = ({
+  children
+}) => {
+  const {
+    i18n
+  } = useTranslation();
+  React.useEffect(() => {
+    i18n.addResourceBundle('en', CAP_NAMESPACE, capTrans.en);
+    i18n.addResourceBundle('fi', CAP_NAMESPACE, capTrans.fi);
+  }, [i18n]);
+  return children;
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+/**
+ * The lookup table is for registering your own components with the workspace.
+ * @param payload
+ * @returns
+ */
+const ComponentsLookUp = ({
+  componentType,
+  initialProps,
+  productConfigKey,
+  config,
+  id
+}) => {
+  // TODO: implement polling when backend is ready
+  // TODO: fetch new data using feedLanguage if previous response indicates there are new warnings
+  var _a, _b;
+  // NOTE: Fetching data inside this component might not work, as using React Hooks causes Invalid Hook Call -errors in tests.
+  switch (componentType) {
+    case 'CapWarningMap':
+      {
+        return React.createElement(CapTranslationsWrapper, null, React.createElement(ApiProvider, {
+          config: {
+            baseURL: config.baseURL
+          },
+          createApi: createApi
+        }, React.createElement(MapViewCapConnectWrapper, {
+          id: id,
+          bbox: (_a = initialProps.mapPreset.proj) === null || _a === void 0 ? void 0 : _a.bbox,
+          srs: (_b = initialProps.mapPreset.proj) === null || _b === void 0 ? void 0 : _b.srs,
+          layers: initialProps.mapPreset.layers,
+          productConfigKey: productConfigKey
+        })));
+      }
+    case 'CapWarningList':
+      {
+        return React.createElement(CapTranslationsWrapper, null, React.createElement(ApiProvider, {
+          config: {
+            baseURL: config.baseURL
+          },
+          createApi: createApi
+        }, React.createElement(WarningListCapConnectWrapper, {
+          productConfigKey: productConfigKey
+        })));
+      }
+    default:
+      return null;
+  }
+};
+
+export { ComponentsLookUp, capModuleConfig, reducer as capReducer };