@opengeoweb/snackbar 19.1.0 → 19.2.0

package/dist/README.md

@@ -0,0 +1,11 @@
+# snackbar
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test snackbar` to execute the unit tests via [Jest](https://jestjs.io).
+
+### TypeScript Documentation
+
+- [TypeScript Docs](https://opengeoweb.gitlab.io/opengeoweb/typescript-docs/snackbar/)

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.esm.js

@@ -0,0 +1,458 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { useDispatch, useSelector } from 'react-redux';
+import { Snackbar } from '@mui/material';
+import { CustomIconButton } from '@opengeoweb/shared';
+import { Close } from '@opengeoweb/theme';
+import { createEntityAdapter, createSlice, createSelector, createListenerMiddleware, combineReducers, configureStore } from '@reduxjs/toolkit';
+import 'i18next';
+import { useTranslation } from 'react-i18next';
+
+var en = {
+	"snackbar-close": "Close"
+};
+var fi = {
+	"snackbar-close": "Sulje"
+};
+var no = {
+	"snackbar-close": "Lukk"
+};
+var nl = {
+	"snackbar-close": "Sluiten"
+};
+var snackbarTranslations = {
+	en: en,
+	fi: fi,
+	no: no,
+	nl: nl
+};
+
+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 _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+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);
+}
+
+/* *
+ * 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 snackbarAdapter = createEntityAdapter();
+var initialState = snackbarAdapter.getInitialState();
+var slice = createSlice({
+  initialState: initialState,
+  name: 'snackbar',
+  reducers: {
+    // To open the snackbar call this action
+    openSnackbar: function openSnackbar(_draft, _action) {},
+    // triggerOpenSnackbarByListener is triggered by the listener to open the snackbar after the current snackbars have all been closed
+    // DO NOT CALL THIS ACTION DIRECTLY!
+    triggerOpenSnackbarByListener: function triggerOpenSnackbarByListener(draft, action) {
+      var snackbarContent = action.payload.snackbarContent;
+      // Ensure we have an id before proceeding
+      if (snackbarContent.id === undefined) {
+        return;
+      }
+      snackbarAdapter.setOne(draft, snackbarContent);
+    },
+    closeSnackbar: function closeSnackbar(draft) {
+      snackbarAdapter.removeAll(draft);
+    }
+  }
+});
+var snackbarReducer = slice.reducer,
+  snackbarActions = 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)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var getSnackbarStore = function getSnackbarStore(store) {
+  if (store != null && store.snackbar) {
+    return store.snackbar;
+  }
+  return null;
+};
+var EMPTY_SNACKBAR_STATE = {
+  entities: {},
+  ids: []
+};
+var _snackbarAdapter$getS = snackbarAdapter.getSelectors(function (state) {
+    var _state$snackbar;
+    return (_state$snackbar = state == null ? void 0 : state.snackbar) != null ? _state$snackbar : EMPTY_SNACKBAR_STATE;
+  }),
+  getCurrentSnackbarMessages = _snackbarAdapter$getS.selectAll;
+var getFirstSnackbarMessage = createSelector(getCurrentSnackbarMessages, function (currentMessages) {
+  return currentMessages.length > 0 ? currentMessages[0] : undefined;
+});
+
+var selectors = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getCurrentSnackbarMessages: getCurrentSnackbarMessages,
+  getFirstSnackbarMessage: getFirstSnackbarMessage,
+  getSnackbarStore: getSnackbarStore
+});
+
+/* *
+ * 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 SnackbarMessageType;
+(function (SnackbarMessageType) {
+  SnackbarMessageType["TRANSLATABLE_MESSAGE"] = "TRANSLATABLE_MESSAGE";
+  SnackbarMessageType["VERBATIM_MESSAGE"] = "VERBATIM_MESSAGE";
+})(SnackbarMessageType || (SnackbarMessageType = {}));
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  get SnackbarMessageType () { return SnackbarMessageType; }
+});
+
+var hideTime = 4000;
+var snackbarListener = createListenerMiddleware();
+snackbarListener.startListening({
+  actionCreator: snackbarActions.openSnackbar,
+  effect: function () {
+    var _effect = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref, listenerApi) {
+      var payload, currentSnackbarMessages, id, currentSnackbarMessagesOpen;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            payload = _ref.payload;
+            listenerApi.cancelActiveListeners();
+            currentSnackbarMessages = getCurrentSnackbarMessages(listenerApi.getState()); // If there are currently opened snackbars we need to close these first
+            if (currentSnackbarMessages.length) {
+              listenerApi.dispatch(snackbarActions.closeSnackbar());
+            }
+            // Generate a unique id
+            id = "snackbar" + Date.now().toString();
+            listenerApi.dispatch(snackbarActions.triggerOpenSnackbarByListener({
+              snackbarContent: {
+                message: payload,
+                id: id
+              }
+            }));
+            // If no new snackbar is triggered cancelling this listener, hide the snackbar after X seconds
+            _context.n = 1;
+            return listenerApi.delay(hideTime);
+          case 1:
+            currentSnackbarMessagesOpen = getCurrentSnackbarMessages(listenerApi.getState());
+            if (currentSnackbarMessagesOpen.length) {
+              listenerApi.dispatch(snackbarActions.closeSnackbar());
+            }
+          case 2:
+            return _context.a(2);
+        }
+      }, _callee);
+    }));
+    function effect(_x, _x2) {
+      return _effect.apply(this, arguments);
+    }
+    return effect;
+  }()
+});
+
+/* *
+ * 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 snackbarReducersMap = {
+  snackbar: snackbarReducer
+};
+var snackbarMiddlewares = [snackbarListener.middleware];
+var snackbarRootReuducer = combineReducers(snackbarReducersMap);
+var createMockStore = function createMockStore(mockState) {
+  return configureStore({
+    reducer: snackbarRootReuducer,
+    preloadedState: mockState,
+    middleware: function middleware(getDefaultMiddleware) {
+      return getDefaultMiddleware().concat(snackbarListener.middleware);
+    }
+  });
+};
+
+/* *
+ * 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 SNACKBAR_NAMESPACE = 'snackbar';
+var WORKSPACE_NAMESPACE = 'workspace';
+var WARN_NAMESPACE = 'warn';
+var LAYER_SELECT_NAMESPACE = 'layerselect';
+var AUTH_NAMESPACE = 'auth';
+var useSnackbarTranslation = function useSnackbarTranslation() {
+  return useTranslation([SNACKBAR_NAMESPACE, WORKSPACE_NAMESPACE, WARN_NAMESPACE, LAYER_SELECT_NAMESPACE, AUTH_NAMESPACE], {
+    nsMode: 'fallback'
+  });
+};
+
+var _excluded = ["children", "isOpen", "onCloseSnackbar", "id", "snackbarMessage"];
+var getMessageString = function getMessageString(t, snackbarMessage) {
+  if (!snackbarMessage) {
+    return '';
+  }
+  return snackbarMessage.type === SnackbarMessageType.TRANSLATABLE_MESSAGE ? t(snackbarMessage.key, snackbarMessage.params) : snackbarMessage.message;
+};
+var SnackbarWrapper = function SnackbarWrapper(_ref) {
+  var children = _ref.children,
+    isOpen = _ref.isOpen,
+    onCloseSnackbar = _ref.onCloseSnackbar,
+    id = _ref.id,
+    snackbarMessage = _ref.snackbarMessage,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  var _useSnackbarTranslati = useSnackbarTranslation(),
+    t = _useSnackbarTranslati.t;
+  var messageString = getMessageString(t, snackbarMessage);
+  return jsxs(Fragment, {
+    children: [children, jsx(Snackbar, Object.assign({
+      action: jsx(CustomIconButton, {
+        "aria-label": t('snackbar-close'),
+        "data-testid": "snackbarCloseButton",
+        onClick: onCloseSnackbar,
+        size: "large",
+        sx: {
+          '&.MuiButtonBase-root': {
+            borderRadius: 20,
+            color: 'geowebColors.snackbar.action',
+            '&:hover': {
+              color: 'geowebColors.snackbar.action',
+              backgroundColor: 'geowebColors.snackbar.actionHover.rgba'
+            }
+          }
+        },
+        children: jsx(Close, {})
+      }),
+      autoHideDuration: null,
+      "data-testid": "snackbarComponent",
+      message: messageString,
+      onClose: onCloseSnackbar,
+      open: isOpen,
+      slotProps: {
+        clickAwayListener: function clickAwayListener() {
+          return {
+            mouseEvent: false
+          };
+        }
+      }
+    }, props), id)]
+  });
+};
+
+var SnackbarWrapperConnect = function SnackbarWrapperConnect(props) {
+  var dispatch = useDispatch();
+  var onCloseSnackbar = function onCloseSnackbar() {
+    dispatch(snackbarActions.closeSnackbar());
+  };
+  var currentSnackbarMessage = useSelector(function (store) {
+    return getFirstSnackbarMessage(store);
+  });
+  return jsx(SnackbarWrapper, Object.assign({
+    id: currentSnackbarMessage ? currentSnackbarMessage.id : '',
+    isOpen: !!currentSnackbarMessage,
+    onCloseSnackbar: onCloseSnackbar,
+    snackbarMessage: currentSnackbarMessage == null ? void 0 : currentSnackbarMessage.message
+  }, props));
+};
+
+export { SNACKBAR_NAMESPACE, SnackbarWrapperConnect, createMockStore, hideTime, snackbarActions, snackbarListener, snackbarMiddlewares, snackbarReducer, snackbarReducersMap, selectors as snackbarSelectors, snackbarTranslations, types as snackbarTypes };

package/dist/src/index.d.ts

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

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

@@ -0,0 +1,11 @@
+import type { Store } from '@reduxjs/toolkit';
+interface SnackbarTranslationsWrapperProps {
+    children?: React.ReactNode;
+}
+export declare const DemoWrapper: React.FC<SnackbarTranslationsWrapperProps>;
+interface ProviderProps {
+    children?: React.ReactNode;
+    store: Store;
+}
+export declare const DemoWrapperConnect: React.FC<ProviderProps>;
+export {};

package/dist/src/lib/components/Snackbar/SnackbarWrapper.d.ts

@@ -0,0 +1,11 @@
+import type { SnackbarProps } from '@mui/material';
+import React from 'react';
+import { snackbarTypes } from '../../store';
+interface SnackBarWrapperProps extends SnackbarProps {
+    isOpen: boolean;
+    id: string;
+    snackbarMessage?: snackbarTypes.SnackbarMessage;
+    onCloseSnackbar: () => void;
+}
+export declare const SnackbarWrapper: React.FC<SnackBarWrapperProps>;
+export {};

package/dist/src/lib/components/Snackbar/SnackbarWrapperConnect.d.ts

@@ -0,0 +1,3 @@
+import type { SnackbarProps } from '@mui/material';
+import React from 'react';
+export declare const SnackbarWrapperConnect: React.FC<SnackbarProps>;

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

@@ -0,0 +1 @@
+export { SnackbarWrapperConnect } from './SnackbarWrapperConnect';

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

@@ -0,0 +1,5 @@
+import snackbarTranslations from './locales/snackbar.json';
+export * from './components/Snackbar';
+export * from './store';
+export { SNACKBAR_NAMESPACE } from './utils/i18n';
+export { snackbarTranslations };

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

@@ -0,0 +1,7 @@
+export { snackbarActions } from './reducer';
+export * as snackbarSelectors from './selectors';
+export * as snackbarTypes from './types';
+export * from './store';
+export { snackbarReducer } from './reducer';
+export * from './listener';
+export type { SnackbarModuleStore } from './types';

package/dist/src/lib/store/listener.d.ts

@@ -0,0 +1,3 @@
+import type { SnackbarModuleStore } from './types';
+export declare const hideTime = 4000;
+export declare const snackbarListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<SnackbarModuleStore, import("redux-thunk").ThunkDispatch<SnackbarModuleStore, unknown, import("redux").UnknownAction>, unknown>;

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

@@ -0,0 +1,10 @@
+import type { PayloadAction, Draft } from '@reduxjs/toolkit';
+import type { OpenSnackbarPayload, SnackbarItem, SnackbarState, TriggerOpenSnackbarByListenerPayload } from './types';
+export declare const snackbarAdapter: import("@reduxjs/toolkit").EntityAdapter<SnackbarItem, string>;
+export declare const initialState: SnackbarState;
+export declare const snackbarReducer: import("redux").Reducer<SnackbarState>, snackbarActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    openSnackbar: (_draft: Draft<SnackbarState>, _action: PayloadAction<OpenSnackbarPayload>) => void;
+    triggerOpenSnackbarByListener: (draft: Draft<SnackbarState>, action: PayloadAction<TriggerOpenSnackbarByListenerPayload>) => void;
+    closeSnackbar: (draft: Draft<SnackbarState>) => void;
+}, "snackbar">;
+export type SnackbarActions = ReturnType<typeof snackbarActions.openSnackbar> | ReturnType<typeof snackbarActions.triggerOpenSnackbarByListener> | ReturnType<typeof snackbarActions.closeSnackbar>;

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

@@ -0,0 +1,24 @@
+import type { SnackbarModuleStore, SnackbarState } from './types';
+export declare const getSnackbarStore: (store: SnackbarModuleStore) => SnackbarState;
+export declare const getCurrentSnackbarMessages: (state: SnackbarModuleStore) => import("./types").SnackbarItem[];
+export declare const getFirstSnackbarMessage: ((state: SnackbarModuleStore) => import("./types").SnackbarItem | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./types").SnackbarItem[]) => import("./types").SnackbarItem | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./types").SnackbarItem[]) => import("./types").SnackbarItem | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").SnackbarItem | undefined;
+    dependencies: [(state: SnackbarModuleStore) => import("./types").SnackbarItem[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,7 @@
+import type { Store } from '@reduxjs/toolkit';
+import type { SnackbarModuleStore } from './types';
+export declare const snackbarReducersMap: {
+    snackbar: import("redux").Reducer<import("./types").SnackbarState>;
+};
+export declare const snackbarMiddlewares: import("@reduxjs/toolkit").ListenerMiddleware<SnackbarModuleStore, import("redux-thunk").ThunkDispatch<SnackbarModuleStore, unknown, import("redux").UnknownAction>, unknown>[];
+export declare const createMockStore: (mockState?: SnackbarModuleStore) => Store;

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

@@ -0,0 +1,27 @@
+import type { EntityState } from '@reduxjs/toolkit';
+export interface SnackbarItem {
+    message: SnackbarMessage;
+    id: string;
+}
+export type SnackbarState = EntityState<SnackbarItem, string>;
+export interface SnackbarModuleStore {
+    snackbar?: SnackbarState;
+}
+export declare enum SnackbarMessageType {
+    TRANSLATABLE_MESSAGE = "TRANSLATABLE_MESSAGE",
+    VERBATIM_MESSAGE = "VERBATIM_MESSAGE"
+}
+export interface TranslatableMessage {
+    type: SnackbarMessageType.TRANSLATABLE_MESSAGE;
+    key: string;
+    params?: Record<string, string | number> | undefined;
+}
+export interface VerbatimMessage {
+    type: SnackbarMessageType.VERBATIM_MESSAGE;
+    message: string;
+}
+export type SnackbarMessage = TranslatableMessage | VerbatimMessage;
+export type OpenSnackbarPayload = SnackbarMessage;
+export interface TriggerOpenSnackbarByListenerPayload {
+    snackbarContent: SnackbarItem;
+}

package/dist/src/lib/utils/i18n.d.ts

@@ -0,0 +1,5 @@
+import i18n from 'i18next';
+import type { UseTranslationResponse } from 'react-i18next';
+export declare const SNACKBAR_NAMESPACE = "snackbar";
+export declare const initSnackbarI18n: () => void;
+export declare const useSnackbarTranslation: () => UseTranslationResponse<typeof SNACKBAR_NAMESPACE, typeof i18n>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/snackbar",
-  "version": "19.1.0",
+  "version": "19.2.0",
   "description": "GeoWeb snackbar library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -38,6 +38,7 @@
   },
   "files": [
     "dist",
+    "!dist/package.json",
     "README.md",
     "package.json"
   ]