@opengeoweb/cap 19.0.0 → 19.1.1

package/dist/index.esm.js

@@ -0,0 +1,1120 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { CircularProgress, Grid, Typography, Box as Box$1, LinearProgress, Card } from '@mui/material';
+import { Box } from '@mui/system';
+import { sessionStorageProvider, dateUtils, usePrevious, AlertBanner } from '@opengeoweb/shared';
+import i18n from 'i18next';
+import { GeoJSON } from 'ol/format';
+import React, { useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import { ConfigurableMapConnect } from '@opengeoweb/core';
+import { mapSelectors, mapListener, serviceListener, layersListener, syncGroupsListener, genericListener, openlayersListener, syncGroupsReducer, layerReducer, serviceReducer, mapReducer } from '@opengeoweb/store';
+import { webmapUtils } from '@opengeoweb/webmap';
+import { OpenLayersFeatureLayer, genericOpenLayersFeatureStyle, MapWarningProperties } from '@opengeoweb/webmap-react';
+import { useQuery, useQueries } from '@tanstack/react-query';
+import { handleResponse } from '@opengeoweb/api';
+import { useTranslation } from 'react-i18next';
+import '@opengeoweb/time-slider';
+import { combineReducers, configureStore } from '@reduxjs/toolkit';
+
+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": "Jotain meni pieleen asetustiedostoa ladattaessa",
+	"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 no = {
+	"map-view-cap-error-title": "Noe gikk galt med innlesing av konfigurasjonsfilen",
+	"warning-list-cap-alert-banner-title": "NB: Bare kartet er påvirket av timeslider basert filtrering",
+	"warning-list-cap-error-title": "Noe gikk galt med innlesing av konfigurasjonsfilen",
+	"warning-list-row-event": "Event",
+	"warning-list-row-severity": "Viktighet",
+	"warning-list-row-expires": "Utløpt",
+	"warning-list-row-not-expired": "(ikke utløpt)"
+};
+var nl = {
+	"map-view-cap-error-title": "Er ging iets mis met het laden van het configuratie bestand",
+	"warning-list-cap-alert-banner-title": "Let op: Alleen de kaart wordt beïnvloed door filteren op basis van timeslider",
+	"warning-list-cap-error-title": "Er ging iets mis met het laden van het configuratie bestand",
+	"warning-list-row-event": "Event",
+	"warning-list-row-severity": "Hevigheid",
+	"warning-list-row-expires": "Verloopt",
+	"warning-list-row-not-expired": "(niet verlopen)"
+};
+var capTrans = {
+	en: en,
+	fi: fi,
+	no: no,
+	nl: nl
+};
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+/* *
+ * 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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var addColors = function addColors(features) {
+  var 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)'
+    }
+  };
+  var _iterator = _createForOfIteratorHelper(features),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var feature = _step.value;
+      var severity = feature.properties.details.severity;
+      feature.properties.stroke = severityStyles[severity].stroke;
+      feature.properties.fill = severityStyles[severity].fill;
+      feature.properties['stroke-opacity'] = 1;
+      feature.properties['stroke-width'] = 2;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var addFeedAddressToCustomGeoJSonFeature = function addFeedAddressToCustomGeoJSonFeature(feedAddress, features) {
+  return features.reduce(function (list, feature) {
+    return list.concat(_objectSpread2(_objectSpread2({}, feature), {}, {
+      properties: _objectSpread2(_objectSpread2({}, feature.properties), {}, {
+        details: _objectSpread2(_objectSpread2({}, feature.properties.details), {}, {
+          feedAddress: feedAddress
+        })
+      })
+    }));
+  }, []);
+};
+
+var _config$GW_CAP_BASE_U;
+var config = sessionStorageProvider.getConfig();
+var capBaseUrl = (_config$GW_CAP_BASE_U = config.GW_CAP_BASE_URL) !== null && _config$GW_CAP_BASE_U !== void 0 ? _config$GW_CAP_BASE_U : '';
+var getConfig = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(productConfigKey) {
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          return _context.a(2,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          fetch("assets/".concat(encodeURIComponent(productConfigKey))).then(handleResponse));
+      }
+    }, _callee);
+  }));
+  return function getConfig(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var getFeedLinks = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(feedAddress) {
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          return _context2.a(2, fetch("".concat(capBaseUrl, "/feedlinks?url=").concat(encodeURIComponent(feedAddress))).then(handleResponse).then(function (result) {
+            return result.map(function (link) {
+              return {
+                link: link,
+                feedAddress: feedAddress
+              };
+            });
+          }));
+      }
+    }, _callee2);
+  }));
+  return function getFeedLinks(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var getSingleAlert = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(alertUrl) {
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 0:
+          return _context3.a(2, fetch("".concat(capBaseUrl, "/singlealert?url=").concat(encodeURIComponent(alertUrl.link))).then(handleResponse).then(function (result) {
+            var alert = _objectSpread2(_objectSpread2({}, result.alert), {}, {
+              feedAddress: alertUrl.feedAddress
+            });
+            var features = addFeedAddressToCustomGeoJSonFeature(alertUrl.feedAddress, result.features.features);
+            return {
+              alert: alert,
+              features: features
+            };
+          }));
+      }
+    }, _callee3);
+  }));
+  return function getSingleAlert(_x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+var useGetConfig = function useGetConfig(productConfigKey) {
+  return useQuery({
+    queryKey: ['cap-config', productConfigKey],
+    queryFn: function () {
+      var _queryFn = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              return _context.a(2, getConfig(productConfigKey));
+          }
+        }, _callee);
+      }));
+      function queryFn() {
+        return _queryFn.apply(this, arguments);
+      }
+      return queryFn;
+    }()
+  });
+};
+var useAllFeedLinks = function useAllFeedLinks(capPresets) {
+  var queries = useMemo(function () {
+    return capPresets.feeds.map(function (feed) {
+      return {
+        queryKey: ['feedLinks', feed.feedAddress],
+        queryFn: function () {
+          var _queryFn2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+            return _regenerator().w(function (_context2) {
+              while (1) switch (_context2.n) {
+                case 0:
+                  return _context2.a(2, getFeedLinks(feed.feedAddress));
+              }
+            }, _callee2);
+          }));
+          function queryFn() {
+            return _queryFn2.apply(this, arguments);
+          }
+          return queryFn;
+        }(),
+        refetchInterval: capPresets.pollInterval
+      };
+    });
+  }, [capPresets]);
+  var results = useQueries({
+    queries: queries,
+    combine: function combine(results) {
+      return {
+        results: results.flatMap(function (result) {
+          return result.data;
+        }).filter(function (result) {
+          return !!result;
+        }),
+        pending: results.some(function (result) {
+          return result.isPending;
+        })
+      };
+    }
+  });
+  return results;
+};
+var useAllFeedAlerts = function useAllFeedAlerts(capPresets) {
+  var _useAllFeedLinks = useAllFeedLinks(capPresets),
+    allFeeds = _useAllFeedLinks.results,
+    allFeedPending = _useAllFeedLinks.pending;
+  var queries = useMemo(function () {
+    return allFeeds.map(function (feed) {
+      return {
+        queryKey: ['feedAlert', feed],
+        queryFn: function () {
+          var _queryFn3 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+            return _regenerator().w(function (_context3) {
+              while (1) switch (_context3.n) {
+                case 0:
+                  return _context3.a(2, getSingleAlert(feed));
+              }
+            }, _callee3);
+          }));
+          function queryFn() {
+            return _queryFn3.apply(this, arguments);
+          }
+          return queryFn;
+        }()
+      };
+    });
+  }, [allFeeds]);
+  var _useQueries = useQueries({
+      queries: queries,
+      combine: function combine(results) {
+        return {
+          alertResults: results.map(function (result) {
+            return result.data;
+          }).filter(function (result) {
+            return !!result;
+          }),
+          pending: results.some(function (result) {
+            return result.isPending;
+          })
+        };
+      }
+    }),
+    alertResults = _useQueries.alertResults,
+    alertsPending = _useQueries.pending;
+  return {
+    results: alertResults,
+    pending: allFeedPending || alertsPending
+  };
+};
+
+/* *
+ * 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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var findEventIndexInLanguage = function findEventIndexInLanguage(language, languages, capWarningPresets, feedAddressFromProps) {
+  var correctFeedIndex = capWarningPresets.feeds.findIndex(function (_ref) {
+    var feedAddress = _ref.feedAddress;
+    return feedAddress === feedAddressFromProps;
+  });
+  if (correctFeedIndex === -1) {
+    return 0;
+  }
+  var languageIndex = languages.findIndex(function (lang) {
+    return lang.language.startsWith(language);
+  });
+  if (languageIndex === -1) {
+    var fallbackLanguage = languages.findIndex(function (object) {
+      return object.language.startsWith('en');
+    });
+    if (fallbackLanguage === -1) {
+      return 0;
+    }
+    return fallbackLanguage;
+  }
+  return languageIndex;
+};
+
+/* *
+ * 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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var highlightGeoJson = function highlightGeoJson(currentFeatures, featureResults) {
+  return Object.entries(currentFeatures).reduce(function (byId, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      alertId = _ref2[0],
+      features = _ref2[1];
+    var isSelected = alertId === (featureResults === null || featureResults === void 0 ? void 0 : featureResults.feature.properties.details.identifier);
+    return _objectSpread2(_objectSpread2({}, byId), {}, _defineProperty({}, alertId, features.map(function (feature) {
+      var recoloredFeature = _objectSpread2({}, 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;
+    })));
+  }, {});
+};
+
+var MapViewCapConnect = function MapViewCapConnect(_ref) {
+  var id = _ref.id,
+    title = _ref.title,
+    bbox = _ref.bbox,
+    srs = _ref.srs,
+    capWarningPresets = _ref.capWarningPresets,
+    layers = _ref.layers,
+    children = _ref.children;
+  var _useAllFeedAlerts = useAllFeedAlerts(capWarningPresets),
+    feedAlertsResult = _useAllFeedAlerts.results;
+  var _React$useState = React.useState({}),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    featuresByAlert = _React$useState2[0],
+    setFeaturesByAlert = _React$useState2[1];
+  var _React$useState3 = React.useState(undefined),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    selectedFeatureEvent = _React$useState4[0],
+    setSelectedFeatureEvent = _React$useState4[1];
+  var mapIdRef = React.useRef(id || webmapUtils.generateMapId());
+  var parentSizeRef = React.useRef(null);
+  var _React$useState5 = React.useState(window.innerWidth / 2),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    parentSize = _React$useState6[0],
+    setParentSize = _React$useState6[1];
+  React.useEffect(function () {
+    var handleWindowResize = function handleWindowResize() {
+      setParentSize(parentSizeRef.current.parentElement.offsetWidth);
+    };
+    window.addEventListener('resize', handleWindowResize);
+    return function () {
+      window.removeEventListener('resize', handleWindowResize);
+    };
+  }, []);
+  var selectedTime = useSelector(function (store) {
+    return mapSelectors.getSelectedTime(store, mapIdRef.current);
+  });
+  var selectedDate = useMemo(function () {
+    return dateUtils.createDate(dateUtils.fromUnix(selectedTime).toISOString());
+  }, [selectedTime]);
+  var alertsInEffect = useMemo(function () {
+    return feedAlertsResult.filter(function (alert) {
+      return dateUtils.isBetween(selectedDate, dateUtils.createDate(alert.alert.onset), dateUtils.createDate(alert.alert.expires), '[)');
+    });
+  }, [feedAlertsResult, selectedDate]);
+  var alertIdsInEffect = useMemo(function () {
+    return alertsInEffect.map(function (_ref2) {
+      var alert = _ref2.alert;
+      return alert.identifier;
+    });
+  }, [alertsInEffect]);
+  var previousAlertIdsInEffect = usePrevious(alertIdsInEffect);
+  var clickOnFeature = useMemo(function () {
+    return {
+      onClick: function onClick(feature) {
+        var featureResults = feature.length === 0 ? undefined : {
+          feature: new GeoJSON().writeFeatureObject(feature[0]),
+          coordinateIndexInFeature: null,
+          featureIndex: null,
+          screenCoords: null,
+          mouseX: null,
+          mouseY: null,
+          isInEditMode: null
+        };
+        setSelectedFeatureEvent(featureResults);
+        setFeaturesByAlert(function (previous) {
+          return highlightGeoJson(previous, featureResults);
+        });
+      }
+    };
+  }, []);
+  React.useEffect(function () {
+    if (JSON.stringify(alertIdsInEffect) !== JSON.stringify(previousAlertIdsInEffect)) {
+      var _featuresByAlert = alertsInEffect.reduce(function (byId, _ref3) {
+        var alert = _ref3.alert,
+          features = _ref3.features;
+        return _objectSpread2(_objectSpread2({}, byId), {}, _defineProperty({}, alert.identifier, addColors(features)));
+      }, {});
+      setFeaturesByAlert(_featuresByAlert);
+    }
+  }, [alertIdsInEffect, alertsInEffect, previousAlertIdsInEffect]);
+  var geoJsonObject = useMemo(function () {
+    var featuresInEffect = Object.keys(featuresByAlert).filter(function (id) {
+      return alertIdsInEffect.includes(id);
+    }).flatMap(function (id) {
+      return featuresByAlert[id];
+    });
+    return {
+      type: 'FeatureCollection',
+      features: featuresInEffect
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [featuresByAlert]);
+  return jsx("div", {
+    "data-testid": "mapViewCap",
+    ref: parentSizeRef,
+    style: {
+      height: '100%',
+      width: '100%'
+    },
+    children: jsxs(ConfigurableMapConnect, {
+      "data-testid": "capWarningMap",
+      id: mapIdRef.current,
+      initialBbox: bbox,
+      layers: layers !== null && layers !== void 0 ? layers : [],
+      srs: srs,
+      title: title,
+      children: [jsx(OpenLayersFeatureLayer, {
+        clickOnFeature: clickOnFeature,
+        featureCollection: geoJsonObject,
+        style: genericOpenLayersFeatureStyle,
+        testId: "MapViewCap-features",
+        zIndex: 1000
+      }), selectedFeatureEvent ? jsx(MapWarningProperties, {
+        "data-testid": "mapWarnings",
+        languageIndex: findEventIndexInLanguage(i18n.language, selectedFeatureEvent.feature.properties.details.languages, capWarningPresets, selectedFeatureEvent.feature.properties.details.feedAddress),
+        parentSize: parentSize,
+        selectedFeatureProperties: selectedFeatureEvent.feature.properties.details
+      }) : null, 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 2024 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2024 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var CAP_NAMESPACE = 'cap';
+var useCapTranslation = function useCapTranslation() {
+  return useTranslation(CAP_NAMESPACE);
+};
+
+var MapViewCapConnectWrapper = function MapViewCapConnectWrapper(_ref) {
+  var id = _ref.id,
+    title = _ref.title,
+    bbox = _ref.bbox,
+    srs = _ref.srs,
+    productConfigKey = _ref.productConfigKey,
+    layers = _ref.layers;
+  var _useCapTranslation = useCapTranslation(),
+    t = _useCapTranslation.t;
+  var _useGetConfig = useGetConfig(productConfigKey),
+    capWarningPresets = _useGetConfig.data,
+    isPending = _useGetConfig.isPending,
+    error = _useGetConfig.error;
+  if (isPending) {
+    return jsx(Box, {
+      sx: {
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center'
+      },
+      children: jsx(CircularProgress, {
+        "data-testid": "loadingSpinner"
+      })
+    });
+  }
+  if (error) {
+    return jsx(AlertBanner, {
+      info: error.message,
+      title: t('map-view-cap-error-title')
+    });
+  }
+  return jsx(MapViewCapConnect, {
+    bbox: bbox,
+    capWarningPresets: capWarningPresets,
+    id: id,
+    layers: layers,
+    srs: srs,
+    title: title
+  });
+};
+
+var 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)'
+  }
+};
+var WarningListRowCap = function WarningListRowCap(_ref) {
+  var event = _ref.event,
+    severity = _ref.severity,
+    expires = _ref.expires;
+  var _useCapTranslation = useCapTranslation(),
+    t = _useCapTranslation.t;
+  return jsxs(Grid, {
+    container: true,
+    sx: {
+      border: severityStyles[severity].border,
+      background: severityStyles[severity].background,
+      padding: '5px',
+      marginTop: '20px',
+      marginBottom: '20px',
+      width: '100%'
+    },
+    children: [jsxs(Grid, {
+      size: {
+        xs: 4
+      },
+      children: [jsx(Typography, {
+        variant: "overline",
+        children: t('warning-list-row-event')
+      }), jsx(Typography, {
+        "data-testid": "event",
+        sx: {
+          fontWeight: 'normal'
+        },
+        variant: "subtitle2",
+        children: event || ''
+      })]
+    }), jsxs(Grid, {
+      size: {
+        xs: 4
+      },
+      children: [jsx(Typography, {
+        variant: "overline",
+        children: t('warning-list-row-severity')
+      }), jsx(Typography, {
+        "data-testid": "severity",
+        sx: {
+          fontWeight: 'normal'
+        },
+        variant: "subtitle2",
+        children: severity || ''
+      })]
+    }), jsxs(Grid, {
+      size: {
+        xs: 4
+      },
+      children: [jsx(Typography, {
+        variant: "overline",
+        children: t('warning-list-row-expires')
+      }), jsx(Typography, {
+        "data-testid": "expires",
+        sx: {
+          fontWeight: 'normal'
+        },
+        variant: "subtitle2",
+        children: expires ? dateUtils.dateToString(dateUtils.createDate(expires), "dd MMM yyyy, HH:mm 'UTC'") : t('warning-list-row-not-expired')
+      })]
+    })]
+  });
+};
+
+var WarningListRowCapConnect = function WarningListRowCapConnect(_ref) {
+  var _alert$languages;
+  var alert = _ref.alert,
+    capWarningPresets = _ref.capWarningPresets;
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    languageIndex = _React$useState2[0],
+    setLanguageIndex = _React$useState2[1];
+  var alertHasLanguages = Boolean(alert === null || alert === void 0 || (_alert$languages = alert.languages) === null || _alert$languages === void 0 ? void 0 : _alert$languages.length);
+  var language = i18n.language;
+  React.useEffect(function () {
+    if (alert && alertHasLanguages) {
+      var foundLanguageIndex = findEventIndexInLanguage(language, alert.languages, capWarningPresets, alert.feedAddress);
+      setLanguageIndex(foundLanguageIndex);
+    }
+  }, [alert, language, alertHasLanguages, capWarningPresets]);
+  return jsx("div", {
+    children: alert && alertHasLanguages ? jsx(WarningListRowCap, {
+      event: alert.languages[languageIndex].event,
+      expires: alert.expires,
+      severity: alert.severity
+    }) : null
+  });
+};
+
+var WarningListCap = function WarningListCap(_ref) {
+  var capWarningPresets = _ref.capWarningPresets,
+    alerts = _ref.alerts,
+    _ref$isPending = _ref.isPending,
+    isPending = _ref$isPending === void 0 ? false : _ref$isPending;
+  var _useCapTranslation = useCapTranslation(),
+    t = _useCapTranslation.t;
+  return jsxs(Box$1, {
+    sx: {
+      width: '100%',
+      height: '100%',
+      display: 'flex'
+    },
+    children: [isPending ? jsx(LinearProgress, {
+      color: "secondary",
+      sx: {
+        position: 'absolute',
+        width: '100%'
+      }
+    }) : null, jsxs(Card, {
+      "data-testid": "warningList",
+      sx: {
+        justifyContent: 'center',
+        alignItems: 'center',
+        overflow: 'auto',
+        height: '95%',
+        width: '100%',
+        padding: '10px',
+        margin: '20px',
+        marginBottom: '10px',
+        position: 'relative'
+      },
+      children: [!isPending && !alerts.length && jsx(AlertBanner, {
+        severity: "warning",
+        title: "No results"
+      }), alerts.length > 0 && jsx(Box$1, {
+        sx: {
+          position: 'sticky',
+          top: 0,
+          width: '100%',
+          display: 'flex',
+          justifyContent: 'center'
+        },
+        children: jsx(AlertBanner, {
+          severity: "info",
+          title: t('warning-list-cap-alert-banner-title')
+        })
+      }), alerts.map(function (alert) {
+        return jsx(WarningListRowCapConnect, {
+          alert: alert,
+          capWarningPresets: capWarningPresets
+        }, alert.identifier);
+      })]
+    })]
+  });
+};
+
+var WarningListCapConnect = function WarningListCapConnect(_ref) {
+  var capWarningPresets = _ref.capWarningPresets;
+  var _useAllFeedAlerts = useAllFeedAlerts(capWarningPresets),
+    feedAlerts = _useAllFeedAlerts.results,
+    pending = _useAllFeedAlerts.pending;
+  return jsx(WarningListCap, {
+    alerts: feedAlerts.map(function (fa) {
+      return fa.alert;
+    }),
+    capWarningPresets: capWarningPresets,
+    isPending: pending
+  });
+};
+
+var WarningListCapConnectWrapper = function WarningListCapConnectWrapper(_ref) {
+  var productConfigKey = _ref.productConfigKey;
+  var _useCapTranslation = useCapTranslation(),
+    t = _useCapTranslation.t;
+  var _useGetConfig = useGetConfig(productConfigKey),
+    productConfig = _useGetConfig.data,
+    isPending = _useGetConfig.isPending,
+    error = _useGetConfig.error;
+  if (isPending) {
+    return jsx(Box, {
+      sx: {
+        display: 'flex',
+        justifyContent: 'center',
+        alignItems: 'center'
+      },
+      children: jsx(CircularProgress, {
+        "data-testid": "loadingSpinner"
+      })
+    });
+  }
+  if (error) {
+    return jsx(AlertBanner, {
+      info: error.message,
+      title: t('warning-list-cap-error-title')
+    });
+  }
+  return jsx(WarningListCapConnect, {
+    capWarningPresets: productConfig
+  });
+};
+
+/**
+ * The lookup table is for registering your own components with the workspace.
+ * @param payload
+ * @returns
+ */
+var ComponentsLookUp = function ComponentsLookUp(_ref) {
+  var componentType = _ref.componentType,
+    initialProps = _ref.initialProps,
+    productConfigKey = _ref.productConfigKey,
+    id = _ref.id;
+  switch (componentType) {
+    case 'CapWarningMap':
+      {
+        var _initialProps$mapPres, _initialProps$mapPres2;
+        return jsx(MapViewCapConnectWrapper, {
+          bbox: (_initialProps$mapPres = initialProps.mapPreset.proj) === null || _initialProps$mapPres === void 0 ? void 0 : _initialProps$mapPres.bbox,
+          id: id,
+          layers: initialProps.mapPreset.layers,
+          productConfigKey: productConfigKey,
+          srs: (_initialProps$mapPres2 = initialProps.mapPreset.proj) === null || _initialProps$mapPres2 === void 0 ? void 0 : _initialProps$mapPres2.srs
+        });
+      }
+    case 'CapWarningList':
+      {
+        return jsx(WarningListCapConnectWrapper, {
+          productConfigKey: productConfigKey
+        });
+      }
+    default:
+      return null;
+  }
+};
+
+/* *
+ * 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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var capReducersMap = {
+  webmap: mapReducer,
+  services: serviceReducer,
+  layers: layerReducer,
+  syncGroups: syncGroupsReducer
+};
+var capMiddlewares = [mapListener.middleware, serviceListener.middleware, layersListener.middleware, syncGroupsListener.middleware, genericListener.middleware, openlayersListener.middleware];
+var capRootReducer = combineReducers(capReducersMap);
+var createMockStore = function createMockStore(mockState) {
+  return configureStore({
+    reducer: capRootReducer,
+    preloadedState: mockState,
+    middleware: function middleware(getDefaultMiddleware) {
+      return getDefaultMiddleware().concat(capMiddlewares);
+    },
+    devTools: true
+  });
+};
+
+export { CAP_NAMESPACE, ComponentsLookUp, capTrans as capTranslations, createMockStore };