@elliemae/pui-app-sdk 4.10.0 → 4.11.0-beta.1

package/dist/cjs/view/modals/wait-message/wait-message-launcher.js

@@ -22,10 +22,10 @@ __export(wait_message_launcher_exports, {
 });
 module.exports = __toCommonJS(wait_message_launcher_exports);
 var import_react = require("react");
-var import_react_redux = require("../../../data/react-redux.js");
+var import_react2 = require("../../../data/react.js");
 var import_actions = require("../../../data/wait-message/actions.js");
 const WaitMessageLauncher = () => {
-  const dispatch = (0, import_react_redux.useAppDispatch)();
+  const dispatch = (0, import_react2.useAppDispatch)();
   (0, import_react.useEffect)(() => {
     dispatch(import_actions.waitMessage.open());
     return () => {

package/dist/cjs/view/session-timeout/index.js

@@ -23,12 +23,12 @@ __export(session_timeout_exports, {
 module.exports = __toCommonJS(session_timeout_exports);
 var import_jsx_runtime = require("react/jsx-runtime");
 var import_react = require("react");
-var import_react_redux = require("../../data/react-redux.js");
+var import_react2 = require("../../data/react.js");
 var import_actions = require("../../data/logout/actions.js");
 var import_session = require("../../utils/session.js");
 var import_session_expiry = require("../modals/session-expiry/index.js");
 const SessionTimeout = () => {
-  const dispatch = (0, import_react_redux.useAppDispatch)();
+  const dispatch = (0, import_react2.useAppDispatch)();
   const [showSessionExpiryWarning, setSessionExpiryWarning] = (0, import_react.useState)(false);
   const [warningNotifiedAt, setwarningNotifiedAt] = (0, import_react.useState)();
   (0, import_react.useEffect)(() => {

package/dist/esm/communication/http-client/baseQuery.js

@@ -0,0 +1,22 @@
+import { getAuthHTTPClient } from "./index.js";
+const sdkBaseQuery = ({ baseUrl } = {}) => async ({ url, method, data, params, headers }) => {
+  try {
+    const result = await getAuthHTTPClient({
+      baseURL: baseUrl,
+      headers
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    }).request({ url, method, data, params });
+    return { data: result.data };
+  } catch (axiosError) {
+    const err = axiosError;
+    return {
+      error: {
+        status: err.response?.status,
+        data: err.response?.data || err.message
+      }
+    };
+  }
+};
+export {
+  sdkBaseQuery
+};

package/dist/esm/data/appMiddleware.js

@@ -0,0 +1,31 @@
+import { compose } from "redux";
+const middlewareDispatchFns = /* @__PURE__ */ new Map();
+let store;
+const appMiddleware = (_store) => {
+  store = _store;
+  const dispatchFns = Array.from(middlewareDispatchFns.values());
+  return (next) => (action) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    compose(...dispatchFns)(next)(action)
+  );
+};
+const addMiddleware = ({
+  key,
+  middleware
+}) => {
+  if (middlewareDispatchFns.has(key) || !store)
+    return;
+  middlewareDispatchFns.set(key, middleware(store));
+};
+const removeMiddleware = (key) => {
+  middlewareDispatchFns.delete(key);
+};
+const resetMiddlewares = () => {
+  middlewareDispatchFns.clear();
+};
+export {
+  addMiddleware,
+  appMiddleware,
+  removeMiddleware,
+  resetMiddlewares
+};

package/dist/esm/data/errorMiddleware.js

@@ -0,0 +1,11 @@
+import { isRejectedWithValue } from "@reduxjs/toolkit";
+import { actions as error } from "./error/index.js";
+const errorMiddleware = (api) => (next) => (action) => {
+  if (isRejectedWithValue(action)) {
+    api.dispatch(error.set({ messageText: action?.error?.data?.message }));
+  }
+  return next(action);
+};
+export {
+  errorMiddleware
+};

package/dist/esm/data/index.js

@@ -3,7 +3,7 @@ import {
   useInjectSaga,
   createManager
 } from "redux-injectors";
-import { useAppDispatch, useAppSelector } from "./react-redux.js";
+import { useAppDispatch, useAppSelector } from "./react.js";
 import { createAppStore, getStore } from "./store.js";
 export {
   createAppStore as configureStore,

package/dist/esm/data/listenerMiddleware.js

@@ -0,0 +1,38 @@
+import { createListenerMiddleware } from "@reduxjs/toolkit";
+let listenerAPI;
+const rtkListenerMiddleware = createListenerMiddleware();
+const listenerDispatchFns = /* @__PURE__ */ new Map();
+const listenerMiddleware = (_listenerAPI) => {
+  listenerAPI = _listenerAPI;
+  return rtkListenerMiddleware.middleware(listenerAPI);
+};
+const addListener = ({
+  key,
+  listener
+}) => {
+  if (listenerDispatchFns.has(key) && listenerAPI) {
+    listenerDispatchFns.set(key, listener);
+    return rtkListenerMiddleware.startListening(listener);
+  }
+  return null;
+};
+const removeListener = (key) => {
+  const listener = listenerDispatchFns.get(key);
+  if (listener) {
+    listenerDispatchFns.delete(key);
+    return rtkListenerMiddleware.stopListening(listener);
+  }
+  return true;
+};
+const resetListeners = () => {
+  listenerDispatchFns.forEach((listener) => {
+    rtkListenerMiddleware.stopListening(listener);
+  });
+  listenerDispatchFns.clear();
+};
+export {
+  addListener,
+  listenerMiddleware,
+  removeListener,
+  resetListeners
+};

package/dist/esm/data/queryMiddleware.js

@@ -0,0 +1,30 @@
+import { compose } from "redux";
+const middlewareDispatchFns = /* @__PURE__ */ new Map();
+let store;
+const queryMiddleware = (_store) => {
+  store = _store;
+  return (next) => (action) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    compose(...middlewareDispatchFns.values())(next)(action)
+  );
+};
+const addMiddleware = ({
+  reducerPath,
+  middleware
+}) => {
+  if (middlewareDispatchFns.has(reducerPath) || !store)
+    return;
+  middlewareDispatchFns.set(reducerPath, middleware(store));
+};
+const removeMiddleware = (reducerPath) => {
+  middlewareDispatchFns.delete(reducerPath);
+};
+const resetMiddlewares = () => {
+  middlewareDispatchFns.clear();
+};
+export {
+  addMiddleware,
+  queryMiddleware,
+  removeMiddleware,
+  resetMiddlewares
+};

package/dist/esm/data/react.js

@@ -0,0 +1,12 @@
+import { useInjectQuery } from "./useInjectQuery.js";
+import { useInjectListener } from "./useInjectListener.js";
+import { useAppDispatch } from "./useAppDispatch.js";
+import { useAppSelector } from "./useAppSelector.js";
+import { useAppMiddleware } from "./useAppMiddleware.js";
+export {
+  useAppDispatch,
+  useAppMiddleware,
+  useAppSelector,
+  useInjectListener,
+  useInjectQuery
+};

package/dist/esm/data/store.js

@@ -1,17 +1,18 @@
 import { configureStore } from "@reduxjs/toolkit";
-import {
-  createInjectorsEnhancer
-} from "redux-injectors";
+import { setupListeners } from "@reduxjs/toolkit/query/react";
+import { createInjectorsEnhancer } from "redux-injectors";
 import createSagaMiddleware from "redux-saga";
 import { createReducer } from "./reducers.js";
 import { enableHotReloading } from "./webpack-hmr.js";
+import { queryMiddleware } from "./queryMiddleware.js";
+import { listenerMiddleware } from "./listenerMiddleware.js";
 const rootReducer = createReducer();
 let appStore = null;
 const setStore = (store) => {
   appStore = store;
 };
 const getStore = () => appStore;
-const createStore = (initialState, sagaMiddleware, history, middlewareConfig = { thunk: false }) => {
+const createStore = (initialState, sagaMiddleware, history, middlewareConfig = {}) => {
   const { run: runSaga } = sagaMiddleware;
   const enhancers = [
     createInjectorsEnhancer({
@@ -21,11 +22,12 @@ const createStore = (initialState, sagaMiddleware, history, middlewareConfig = {
   ];
   const baseStore = configureStore({
     reducer: rootReducer,
-    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).concat(sagaMiddleware),
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).prepend(listenerMiddleware).concat([sagaMiddleware, queryMiddleware]),
     devTools: true,
     preloadedState: initialState,
     enhancers
   });
+  setupListeners(baseStore.dispatch);
   enableHotReloading(baseStore);
   return baseStore;
 };

package/dist/esm/data/useAppDispatch.js

@@ -0,0 +1,5 @@
+import { useDispatch } from "react-redux";
+const useAppDispatch = () => useDispatch();
+export {
+  useAppDispatch
+};

package/dist/esm/data/useAppMiddleware.js

@@ -0,0 +1,14 @@
+import { useEffect } from "react";
+import { addMiddleware, removeMiddleware } from "./appMiddleware.js";
+const useAppMiddleware = ({
+  key,
+  middleware
+}) => useEffect(() => {
+  addMiddleware({ key, middleware });
+  return () => {
+    removeMiddleware(key);
+  };
+}, [key, middleware]);
+export {
+  useAppMiddleware
+};

package/dist/esm/data/useAppSelector.js

@@ -0,0 +1,5 @@
+import { useSelector } from "react-redux";
+const useAppSelector = useSelector;
+export {
+  useAppSelector
+};

package/dist/esm/data/useInjectListener.js

@@ -0,0 +1,17 @@
+import { useEffect } from "react";
+import {
+  addListener,
+  removeListener
+} from "./listenerMiddleware.js";
+const useInjectListener = ({
+  key,
+  listener
+}) => useEffect(() => {
+  addListener({ key, listener });
+  return () => {
+    removeListener(key);
+  };
+}, [key, listener]);
+export {
+  useInjectListener
+};

package/dist/esm/data/useInjectQuery.js

@@ -0,0 +1,15 @@
+import { useInjectReducer } from "redux-injectors";
+import {
+  addMiddleware
+} from "./queryMiddleware.js";
+const useInjectQuery = ({
+  reducerPath,
+  reducer,
+  middleware
+}) => {
+  useInjectReducer({ key: reducerPath, reducer });
+  addMiddleware({ reducerPath, middleware });
+};
+export {
+  useInjectQuery
+};

package/dist/esm/index.js

@@ -3,17 +3,25 @@ import {
   getHTTPClient,
   getAuthHTTPClient
 } from "./communication/http-client/index.js";
+import { sdkBaseQuery } from "./communication/http-client/baseQuery.js";
 import { onAuthorizationFailure } from "./communication/http-client/response-interceptor.js";
 import { auth } from "./data/auth/actions.js";
 import { RequireAuth } from "./view/require-auth.js";
 import { Page } from "./view/page.js";
 import { default as default2 } from "./utils/constants.js";
-import { useAppDispatch, useAppSelector } from "./data/react-redux.js";
 import {
   useInjectReducer,
   useInjectSaga,
   createManager
 } from "redux-injectors";
+import {
+  useInjectQuery,
+  useInjectListener,
+  useAppDispatch,
+  useAppSelector,
+  useAppMiddleware
+} from "./data/react.js";
+import { errorMiddleware } from "./data/errorMiddleware.js";
 import { getAuthorizationHeader } from "./utils/auth/helper.js";
 import { getRedirectUrl, removeDoubleSlash } from "./utils/url.js";
 import { createAppStore } from "./data/store.js";
@@ -158,6 +166,7 @@ export {
   createManager,
   enableReactAppForHostIntegration,
   actions2 as error,
+  errorMiddleware,
   fetchHostAppData,
   getUser as fetchUserSettings,
   getApiActionCreator,
@@ -195,6 +204,7 @@ export {
   renderWithRouter,
   renderWithRouterRedux,
   resetUserIdleTime,
+  sdkBaseQuery,
   sendBAEvent,
   sendMessageToHost,
   setAppConfig,
@@ -207,7 +217,10 @@ export {
   trackActivity,
   updateBAEventParameters,
   useAppDispatch,
+  useAppMiddleware,
   useAppSelector,
+  useInjectListener,
+  useInjectQuery,
   useInjectReducer,
   useInjectSaga,
   useMediaQueryList,

package/dist/esm/view/breakpoint/use-breakpoint.js

@@ -1,7 +1,7 @@
 import { useEffect, useContext } from "react";
 import { ThemeContext } from "styled-components";
 import { publish } from "pubsub-js";
-import { useAppDispatch } from "../../data/react-redux.js";
+import { useAppDispatch } from "../../data/react.js";
 import { breakpoint } from "../../data/breakpoint/index.js";
 import { useMediaQueryList } from "./use-media-query-list.js";
 import { HOST_WINDOW_BREAKPOINT_CHANGED } from "../../utils/constants.js";

package/dist/esm/view/error-toast/index.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
 import { useEffect, memo } from "react";
 import { ToastPosition, ToastType, DSToast, toast } from "@elliemae/ds-toast";
-import { useAppSelector, useAppDispatch } from "../../data/react-redux.js";
+import { useAppSelector, useAppDispatch } from "../../data/react.js";
 import { actions as error } from "../../data/error/index.js";
 const ErrorToast = memo((props) => {
   const storeError = useAppSelector((state) => state?.error);

package/dist/esm/view/live-message/index.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { LiveMessage as AriaLiveMessage } from "react-aria-live";
-import { useAppSelector } from "../../data/react-redux.js";
+import { useAppSelector } from "../../data/react.js";
 const LiveMessage = () => {
   const message = useAppSelector((state) => state.liveMessage?.message);
   const ariaLive = useAppSelector((state) => state.liveMessage?.ariaLive);

package/dist/esm/view/login/index.js

@@ -1,6 +1,6 @@
 import { Fragment, jsx } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
-import { useAppDispatch } from "../../data/react-redux.js";
+import { useAppDispatch } from "../../data/react.js";
 import { login } from "../../utils/auth/index.js";
 import { LOGIN_SUCCESS } from "../../data/auth/actions.js";
 const Login = ({

package/dist/esm/view/modals/navigation-prompt/index.js

@@ -10,7 +10,7 @@ import {
   DSDialogSeparator,
   DSDialogAddon
 } from "@elliemae/ds-dialog";
-import { useAppDispatch } from "../../../data/react-redux.js";
+import { useAppDispatch } from "../../../data/react.js";
 import { navigationPrompt } from "../../../data/navigation-prompt/actions.js";
 const NavigationPrompt = memo(
   ({ open = false }) => {

package/dist/esm/view/modals/session-expiry/index.js

@@ -11,7 +11,7 @@ import {
   DSDialogFooter,
   DSDialogSeparator
 } from "@elliemae/ds-dialog";
-import { useAppDispatch } from "../../../data/react-redux.js";
+import { useAppDispatch } from "../../../data/react.js";
 import { logout } from "../../../data/logout/actions.js";
 import {
   resetUserIdleTime,

package/dist/esm/view/modals/wait-message/index.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
 import { memo, useEffect } from "react";
 import { DSLoadingIndicator } from "@elliemae/ds-loading-indicator";
-import { useAppSelector } from "../../../data/react-redux.js";
+import { useAppSelector } from "../../../data/react.js";
 import { useHTMLWaitMessage } from "./use-html-wait-message.js";
 import {
   waitStartEvent,

package/dist/esm/view/modals/wait-message/wait-message-launcher.js

@@ -1,5 +1,5 @@
 import { useEffect } from "react";
-import { useAppDispatch } from "../../../data/react-redux.js";
+import { useAppDispatch } from "../../../data/react.js";
 import { waitMessage } from "../../../data/wait-message/actions.js";
 const WaitMessageLauncher = () => {
   const dispatch = useAppDispatch();

package/dist/esm/view/session-timeout/index.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
-import { useAppDispatch } from "../../data/react-redux.js";
+import { useAppDispatch } from "../../data/react.js";
 import { logout } from "../../data/logout/actions.js";
 import {
   initSessionMonitoring,

package/dist/types/lib/communication/http-client/baseQuery.d.ts

@@ -0,0 +1,14 @@
+import { BaseQueryFn } from '@reduxjs/toolkit/query';
+import { AxiosRequestConfig } from 'axios';
+import { RequestConfig } from './index.js';
+type BaseQueryFunction = BaseQueryFn<{
+    url: string;
+    method: AxiosRequestConfig['method'];
+    data?: AxiosRequestConfig['data'];
+    params?: AxiosRequestConfig['params'];
+    headers?: RequestConfig;
+}, unknown, unknown>;
+export declare const sdkBaseQuery: ({ baseUrl }?: {
+    baseUrl?: string | undefined;
+}) => BaseQueryFunction;
+export {};

package/dist/types/lib/communication/http-client/index.d.ts

@@ -1,6 +1,6 @@
 import { AxiosInstance, RawAxiosRequestHeaders, HeadersDefaults } from 'axios';
 type AxiosRequestHeaders = RawAxiosRequestHeaders | Partial<HeadersDefaults>;
-type RequestConfig = {
+export type RequestConfig = {
     Authorization?: string;
 } & AxiosRequestHeaders;
 export declare const getHTTPClient: ({ baseURL, headers, }?: {

package/dist/types/lib/data/appMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { Middleware } from 'redux';
+export declare const appMiddleware: Middleware<any, any>;
+export declare const addMiddleware: ({ key, middleware, }: {
+    key: string;
+    middleware: Middleware<any, any>;
+}) => void;
+export declare const removeMiddleware: (key: string) => void;
+export declare const resetMiddlewares: () => void;

package/dist/types/lib/data/errorMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware } from '@reduxjs/toolkit';
+export declare const errorMiddleware: Middleware;

package/dist/types/lib/data/index.d.ts

@@ -1,4 +1,4 @@
 export { useInjectReducer, useInjectSaga, createManager, } from 'redux-injectors';
-export { useAppDispatch, useAppSelector } from './react-redux.js';
+export { useAppDispatch, useAppSelector } from './react.js';
 export { createAppStore as configureStore, getStore } from './store.js';
 export type { RootState, AppStore } from './store.js';

package/dist/types/lib/data/listenerMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { Middleware, AnyAction } from 'redux';
+declare const rtkListenerMiddleware: import("@reduxjs/toolkit").ListenerMiddlewareInstance<unknown, import("@reduxjs/toolkit").ThunkDispatch<unknown, unknown, AnyAction>, unknown>;
+export type ListenerDispatchFn = Parameters<typeof rtkListenerMiddleware.startListening>[0];
+export declare const listenerMiddleware: Middleware<any, any>;
+export declare const addListener: ({ key, listener, }: {
+    key: string;
+    listener: Parameters<typeof rtkListenerMiddleware.startListening>[0];
+}) => import("@reduxjs/toolkit").UnsubscribeListener | null;
+export declare const removeListener: (key: string) => boolean;
+export declare const resetListeners: () => void;
+export {};

package/dist/types/lib/data/queryMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+export type QueryMiddleware = ReturnType<typeof createApi>['middleware'];
+export type QueryReducerPath = ReturnType<typeof createApi>['reducerPath'];
+export type QueryReducer = ReturnType<typeof createApi>['reducer'];
+export declare const queryMiddleware: QueryMiddleware;
+export declare const addMiddleware: ({ reducerPath, middleware, }: {
+    reducerPath: QueryReducerPath;
+    middleware: QueryMiddleware;
+}) => void;
+export declare const removeMiddleware: (reducerPath: string) => void;
+export declare const resetMiddlewares: () => void;

package/dist/types/lib/data/react.d.ts

@@ -0,0 +1,5 @@
+export { useInjectQuery } from './useInjectQuery.js';
+export { useInjectListener } from './useInjectListener.js';
+export { useAppDispatch } from './useAppDispatch.js';
+export { useAppSelector } from './useAppSelector.js';
+export { useAppMiddleware } from './useAppMiddleware.js';

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

@@ -1,3 +1,4 @@
+import { Middleware } from 'redux';
 import { History } from 'history';
 declare const rootReducer: import("redux").Reducer<import("redux").CombinedState<{
     waitMessage: import("./wait-message/reducer.js").WaitMessageState;
@@ -15,7 +16,7 @@ export type RootState = ReturnType<typeof rootReducer>;
 export declare const setStore: <T>(store: T) => void;
 export declare const getStore: () => unknown;
 type MiddlewareConfig = {
-    thunk: boolean;
+    thunk?: boolean;
 };
 export declare const createAppStore: (initialState: import("redux").CombinedState<{
     waitMessage: import("./wait-message/reducer.js").WaitMessageState;
@@ -33,11 +34,11 @@ export declare const createAppStore: (initialState: import("redux").CombinedStat
 } | import("redux").AnyAction | {
     payload: import("./breakpoint/index.js").Breakpoints;
     type: string;
-}, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
+}, import("@reduxjs/toolkit").MiddlewareArray<[Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>, import("@reduxjs/toolkit").ThunkMiddleware<import("redux").CombinedState<{
     waitMessage: import("./wait-message/reducer.js").WaitMessageState;
     error: import("./error/index.js").ErrorState;
     breakpoint: import("./breakpoint/index.js").BreakpointState;
     liveMessage: import("./live-message/index.js").LiveMessageState;
-}>, import("redux").AnyAction, undefined>, import("redux-saga").SagaMiddleware<object>]>>;
+}>, import("redux").AnyAction, undefined>, ...Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>[]]>>;
 export type AppStore = ReturnType<typeof createAppStore>;
 export {};

package/dist/types/lib/data/{react-redux.d.ts → useAppDispatch.d.ts}

@@ -1,11 +1,8 @@
 import { Dispatch, PayloadAction, AnyAction } from '@reduxjs/toolkit';
-import { TypedUseSelectorHook } from 'react-redux';
-import { RootState } from './store.js';
 import { WaitMessageState } from './wait-message/reducer.js';
 import { BreakpointState } from './breakpoint/index.js';
 import { ErrorState } from './error/index.js';
 import { LiveMessageState } from './live-message/index.js';
 type AppDispatch = Dispatch<PayloadAction<WaitMessageState> | PayloadAction<BreakpointState> | PayloadAction<ErrorState> | PayloadAction<LiveMessageState> | AnyAction>;
 export declare const useAppDispatch: () => AppDispatch;
-export declare const useAppSelector: TypedUseSelectorHook<RootState>;
 export {};

package/dist/types/lib/data/useAppMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { Middleware } from 'redux';
+export declare const useAppMiddleware: ({ key, middleware, }: {
+    key: string;
+    middleware: Middleware<any, any>;
+}) => void;

package/dist/types/lib/data/useAppSelector.d.ts

@@ -0,0 +1,3 @@
+import { TypedUseSelectorHook } from 'react-redux';
+import { RootState } from './store.js';
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/dist/types/lib/data/useInjectListener.d.ts

@@ -0,0 +1,5 @@
+import { ListenerDispatchFn } from './listenerMiddleware.js';
+export declare const useInjectListener: ({ key, listener, }: {
+    key: string;
+    listener: ListenerDispatchFn;
+}) => void;

package/dist/types/lib/data/useInjectQuery.d.ts

@@ -0,0 +1,7 @@
+import { Reducer, AnyAction } from 'redux';
+import { QueryMiddleware, QueryReducerPath } from './queryMiddleware.js';
+export declare const useInjectQuery: ({ reducerPath, reducer, middleware, }: {
+    reducerPath: QueryReducerPath;
+    reducer: Reducer<any, AnyAction>;
+    middleware: QueryMiddleware;
+}) => void;

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

@@ -1,12 +1,14 @@
 export { isUserAuthorized, login, authorize } from './utils/auth/index.js';
 export { getHTTPClient, getAuthHTTPClient, } from './communication/http-client/index.js';
+export { sdkBaseQuery } from './communication/http-client/baseQuery.js';
 export { onAuthorizationFailure } from './communication/http-client/response-interceptor.js';
 export { auth } from './data/auth/actions.js';
 export { RequireAuth } from './view/require-auth.js';
 export { Page } from './view/page.js';
 export { default as globalConstants } from './utils/constants.js';
-export { useAppDispatch, useAppSelector } from './data/react-redux.js';
 export { useInjectReducer, useInjectSaga, createManager, } from 'redux-injectors';
+export { useInjectQuery, useInjectListener, useAppDispatch, useAppSelector, useAppMiddleware, } from './data/react.js';
+export { errorMiddleware } from './data/errorMiddleware.js';
 export { getAuthorizationHeader } from './utils/auth/helper.js';
 export { getRedirectUrl, removeDoubleSlash } from './utils/url.js';
 export { createAppStore as configureStore } from './data/store.js';

package/dist/types/lib/utils/testing/render-with-redux.d.ts

@@ -16,12 +16,12 @@ export declare const renderWithRedux: (ui: React.ReactElement, { initialState, s
     } | import("redux").AnyAction | {
         payload: import("../../data/breakpoint/index.js").Breakpoints;
         type: string;
-    }, import("@reduxjs/toolkit").MiddlewareArray<[import("redux-thunk").ThunkMiddleware<import("redux").CombinedState<{
+    }, import("@reduxjs/toolkit").MiddlewareArray<[import("redux").Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>, import("redux-thunk").ThunkMiddleware<import("redux").CombinedState<{
         waitMessage: import("../../data/wait-message/reducer.js").WaitMessageState;
         error: import("../../data/error/index.js").ErrorState;
         breakpoint: import("../../data/breakpoint/index.js").BreakpointState;
         liveMessage: import("../../data/live-message/index.js").LiveMessageState;
-    }>, import("redux").AnyAction, undefined>, import("redux-saga").SagaMiddleware<object>]>>;
+    }>, import("redux").AnyAction, undefined>, ...import("redux").Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>[]]>>;
     container: HTMLElement;
     baseElement: HTMLElement;
     debug: (baseElement?: Element | DocumentFragment | (Element | DocumentFragment)[] | undefined, maxLength?: number | undefined, options?: import("pretty-format").PrettyFormatOptions | undefined) => void;

package/dist/types/lib/utils/testing/render-with-router-redux.d.ts

@@ -19,12 +19,12 @@ export declare const renderWithRouterRedux: (ui: React.ReactElement, { route, hi
     } | import("redux").AnyAction | {
         payload: import("../../data/breakpoint/index.js").Breakpoints;
         type: string;
-    }, import("@reduxjs/toolkit").MiddlewareArray<[import("redux-thunk").ThunkMiddleware<import("redux").CombinedState<{
+    }, import("@reduxjs/toolkit").MiddlewareArray<[import("redux").Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>, import("redux-thunk").ThunkMiddleware<import("redux").CombinedState<{
         waitMessage: import("../../data/wait-message/reducer.js").WaitMessageState;
         error: import("../../data/error/index.js").ErrorState;
         breakpoint: import("../../data/breakpoint/index.js").BreakpointState;
         liveMessage: import("../../data/live-message/index.js").LiveMessageState;
-    }>, import("redux").AnyAction, undefined>, import("redux-saga").SagaMiddleware<object>]>>;
+    }>, import("redux").AnyAction, undefined>, ...import("redux").Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>>[]]>>;
     container: HTMLElement;
     baseElement: HTMLElement;
     debug: (baseElement?: Element | DocumentFragment | (Element | DocumentFragment)[] | undefined, maxLength?: number | undefined, options?: import("pretty-format").PrettyFormatOptions | undefined) => void;