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

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

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var baseQuery_exports = {};
+__export(baseQuery_exports, {
+  sdkBaseQuery: () => sdkBaseQuery
+});
+module.exports = __toCommonJS(baseQuery_exports);
+var import_index = require("./index.js");
+const sdkBaseQuery = ({ baseUrl } = {}) => async ({ url, method, data, params, headers }) => {
+  try {
+    const result = await (0, import_index.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
+      }
+    };
+  }
+};

package/dist/cjs/data/errorMiddleware.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errorMiddleware_exports = {};
+__export(errorMiddleware_exports, {
+  errorMiddleware: () => errorMiddleware
+});
+module.exports = __toCommonJS(errorMiddleware_exports);
+var import_toolkit = require("@reduxjs/toolkit");
+var import_error = require("./error/index.js");
+const errorMiddleware = (api) => (next) => (action) => {
+  if ((0, import_toolkit.isRejectedWithValue)(action)) {
+    api.dispatch(import_error.actions.set({ messageText: action?.error?.data?.message }));
+  }
+  return next(action);
+};

package/dist/cjs/data/listenerMiddleware.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var listenerMiddleware_exports = {};
+__export(listenerMiddleware_exports, {
+  addListener: () => addListener,
+  listenerMiddleware: () => listenerMiddleware,
+  removeListener: () => removeListener,
+  resetListeners: () => resetListeners
+});
+module.exports = __toCommonJS(listenerMiddleware_exports);
+var import_toolkit = require("@reduxjs/toolkit");
+let listenerAPI;
+const rtkListenerMiddleware = (0, import_toolkit.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();
+};

package/dist/cjs/data/queryMiddleware.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var queryMiddleware_exports = {};
+__export(queryMiddleware_exports, {
+  addMiddleware: () => addMiddleware,
+  queryMiddleware: () => queryMiddleware,
+  removeMiddleware: () => removeMiddleware,
+  resetMiddlewares: () => resetMiddlewares
+});
+module.exports = __toCommonJS(queryMiddleware_exports);
+var import_redux = require("redux");
+const middlewareDispatchFns = /* @__PURE__ */ new Map();
+let store;
+const queryMiddleware = (_store) => {
+  store = _store;
+  const dispatchFns = Array.from(middlewareDispatchFns.values());
+  return (next) => (action) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    (0, import_redux.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();
+};

package/dist/cjs/data/redux-injectors.js

@@ -18,20 +18,36 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var redux_injectors_exports = {};
 __export(redux_injectors_exports, {
-  createManager: () => import_redux_injectors2.createManager,
-  useInjectReducer: () => useInjectReducer,
-  useInjectSaga: () => import_redux_injectors2.useInjectSaga
+  useInjectListener: () => useInjectListener,
+  useInjectQuery: () => useInjectQuery
 });
 module.exports = __toCommonJS(redux_injectors_exports);
+var import_react = require("react");
 var import_redux_injectors = require("redux-injectors");
-var import_middleware = require("./middleware.js");
-var import_redux_injectors2 = require("redux-injectors");
-const useInjectReducer = ({
+var import_queryMiddleware = require("./queryMiddleware.js");
+var import_listenerMiddleware = require("./listenerMiddleware.js");
+const useInjectQuery = ({
   key,
   reducer,
-  middleware
+  queryMiddleware
 }) => {
   (0, import_redux_injectors.useInjectReducer)({ key, reducer });
-  if (middleware)
-    (0, import_middleware.addMiddleware)(middleware);
+  return (0, import_react.useEffect)(() => {
+    if (!queryMiddleware)
+      return () => {
+      };
+    (0, import_queryMiddleware.addMiddleware)({ key, middleware: queryMiddleware });
+    return () => {
+      (0, import_queryMiddleware.removeMiddleware)(key);
+    };
+  }, [key, reducer, queryMiddleware]);
 };
+const useInjectListener = ({
+  key,
+  listener
+}) => (0, import_react.useEffect)(() => {
+  (0, import_listenerMiddleware.addListener)({ key, listener });
+  return () => {
+    (0, import_listenerMiddleware.removeListener)(key);
+  };
+}, [key, listener]);

package/dist/cjs/data/store.js

@@ -39,14 +39,15 @@ var import_redux_injectors = require("redux-injectors");
 var import_redux_saga = __toESM(require("redux-saga"));
 var import_reducers = require("./reducers.js");
 var import_webpack_hmr = require("./webpack-hmr.js");
-var import_middleware = __toESM(require("./middleware.js"));
+var import_queryMiddleware = require("./queryMiddleware.js");
+var import_listenerMiddleware = require("./listenerMiddleware.js");
 const rootReducer = (0, import_reducers.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 = [
     (0, import_redux_injectors.createInjectorsEnhancer)({
@@ -56,10 +57,7 @@ const createStore = (initialState, sagaMiddleware, history, middlewareConfig = {
   ];
   const baseStore = (0, import_toolkit.configureStore)({
     reducer: rootReducer,
-    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).concat([
-      sagaMiddleware,
-      import_middleware.default
-    ]),
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).prepend(import_listenerMiddleware.listenerMiddleware).concat([sagaMiddleware, import_queryMiddleware.queryMiddleware]),
     devTools: true,
     preloadedState: initialState,
     enhancers

package/dist/cjs/index.js

@@ -68,9 +68,10 @@ __export(lib_exports, {
   auth: () => import_actions.auth,
   authorize: () => import_auth.authorize,
   configureStore: () => import_store.createAppStore,
-  createManager: () => import_redux_injectors.createManager,
+  createManager: () => import_data.createManager,
   enableReactAppForHostIntegration: () => import_react.enableReactAppForHostIntegration,
   error: () => import_error.actions,
+  errorMiddleware: () => import_errorMiddleware.errorMiddleware,
   fetchHostAppData: () => import_fetch_host_app_data.fetchHostAppData,
   fetchUserSettings: () => import_users.getUser,
   getApiActionCreator: () => import_helpers2.getApiActionCreator,
@@ -108,6 +109,7 @@ __export(lib_exports, {
   renderWithRouter: () => import_render_with_router.renderWithRouter,
   renderWithRouterRedux: () => import_render_with_router_redux.renderWithRouterRedux,
   resetUserIdleTime: () => import_session.resetUserIdleTime,
+  sdkBaseQuery: () => import_baseQuery.sdkBaseQuery,
   sendBAEvent: () => import_analytics.sendBAEvent,
   sendMessageToHost: () => import_message_to_host_app.sendMessageToHost,
   setAppConfig: () => import_config.setAppConfig,
@@ -121,8 +123,10 @@ __export(lib_exports, {
   updateBAEventParameters: () => import_web_analytics.updateBAEventParameters,
   useAppDispatch: () => import_react_redux.useAppDispatch,
   useAppSelector: () => import_react_redux.useAppSelector,
-  useInjectReducer: () => import_redux_injectors.useInjectReducer,
-  useInjectSaga: () => import_redux_injectors.useInjectSaga,
+  useInjectListener: () => import_redux_injectors.useInjectListener,
+  useInjectQuery: () => import_redux_injectors.useInjectQuery,
+  useInjectReducer: () => import_data.useInjectReducer,
+  useInjectSaga: () => import_data.useInjectSaga,
   useMediaQueryList: () => import_use_media_query_list.useMediaQueryList,
   waitMessageAction: () => import_actions3.waitMessage,
   withAppDecorator: () => import_decorator.withAppDecorator
@@ -130,13 +134,16 @@ __export(lib_exports, {
 module.exports = __toCommonJS(lib_exports);
 var import_auth = require("./utils/auth/index.js");
 var import_http_client = require("./communication/http-client/index.js");
+var import_baseQuery = require("./communication/http-client/baseQuery.js");
 var import_response_interceptor = require("./communication/http-client/response-interceptor.js");
 var import_actions = require("./data/auth/actions.js");
 var import_require_auth = require("./view/require-auth.js");
 var import_page = require("./view/page.js");
 var import_constants = __toESM(require("./utils/constants.js"));
 var import_react_redux = require("./data/react-redux.js");
+var import_data = require("./data/index.js");
 var import_redux_injectors = require("./data/redux-injectors.js");
+var import_errorMiddleware = require("./data/errorMiddleware.js");
 var import_helper = require("./utils/auth/helper.js");
 var import_url = require("./utils/url.js");
 var import_store = require("./data/store.js");

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/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/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,31 @@
+import { compose } from "redux";
+const middlewareDispatchFns = /* @__PURE__ */ new Map();
+let store;
+const queryMiddleware = (_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,
+  queryMiddleware,
+  removeMiddleware,
+  resetMiddlewares
+};

package/dist/esm/data/redux-injectors.js

@@ -1,17 +1,39 @@
-import { useInjectReducer as useOriginalInjectReducer } from "redux-injectors";
-import { addMiddleware } from "./middleware.js";
-const useInjectReducer = ({
+import { useEffect } from "react";
+import { useInjectReducer } from "redux-injectors";
+import {
+  addMiddleware,
+  removeMiddleware
+} from "./queryMiddleware.js";
+import {
+  addListener,
+  removeListener
+} from "./listenerMiddleware.js";
+const useInjectQuery = ({
   key,
   reducer,
-  middleware
+  queryMiddleware
 }) => {
-  useOriginalInjectReducer({ key, reducer });
-  if (middleware)
-    addMiddleware(middleware);
+  useInjectReducer({ key, reducer });
+  return useEffect(() => {
+    if (!queryMiddleware)
+      return () => {
+      };
+    addMiddleware({ key, middleware: queryMiddleware });
+    return () => {
+      removeMiddleware(key);
+    };
+  }, [key, reducer, queryMiddleware]);
 };
-import { useInjectSaga, createManager } from "redux-injectors";
+const useInjectListener = ({
+  key,
+  listener
+}) => useEffect(() => {
+  addListener({ key, listener });
+  return () => {
+    removeListener(key);
+  };
+}, [key, listener]);
 export {
-  createManager,
-  useInjectReducer,
-  useInjectSaga
+  useInjectListener,
+  useInjectQuery
 };

package/dist/esm/data/store.js

@@ -4,14 +4,15 @@ import { createInjectorsEnhancer } from "redux-injectors";
 import createSagaMiddleware from "redux-saga";
 import { createReducer } from "./reducers.js";
 import { enableHotReloading } from "./webpack-hmr.js";
-import dynamicMiddleware from "./middleware.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,10 +22,7 @@ const createStore = (initialState, sagaMiddleware, history, middlewareConfig = {
   ];
   const baseStore = configureStore({
     reducer: rootReducer,
-    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).concat([
-      sagaMiddleware,
-      dynamicMiddleware
-    ]),
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware(middlewareConfig).prepend(listenerMiddleware).concat([sagaMiddleware, queryMiddleware]),
     devTools: true,
     preloadedState: initialState,
     enhancers

package/dist/esm/index.js

@@ -3,6 +3,7 @@ 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";
@@ -13,7 +14,9 @@ import {
   useInjectReducer,
   useInjectSaga,
   createManager
-} from "./data/redux-injectors.js";
+} from "./data/index.js";
+import { useInjectQuery, useInjectListener } from "./data/redux-injectors.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";
@@ -150,6 +153,7 @@ export {
   createManager,
   enableReactAppForHostIntegration,
   actions2 as error,
+  errorMiddleware,
   fetchHostAppData,
   getUser as fetchUserSettings,
   getApiActionCreator,
@@ -187,6 +191,7 @@ export {
   renderWithRouter,
   renderWithRouterRedux,
   resetUserIdleTime,
+  sdkBaseQuery,
   sendBAEvent,
   sendMessageToHost,
   setAppConfig,
@@ -200,6 +205,8 @@ export {
   updateBAEventParameters,
   useAppDispatch,
   useAppSelector,
+  useInjectListener,
+  useInjectQuery,
   useInjectReducer,
   useInjectSaga,
   useMediaQueryList,

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/errorMiddleware.d.ts

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

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,9 @@
+import { createApi } from '@reduxjs/toolkit/query/react';
+export type RTKQueryMiddleware = ReturnType<typeof createApi>['middleware'];
+export declare const queryMiddleware: RTKQueryMiddleware;
+export declare const addMiddleware: ({ key, middleware, }: {
+    key: string;
+    middleware: RTKQueryMiddleware;
+}) => void;
+export declare const removeMiddleware: (key: string) => void;
+export declare const resetMiddlewares: () => void;

package/dist/types/lib/data/redux-injectors.d.ts

@@ -1,7 +1,12 @@
-import { Middleware, Reducer } from 'redux';
-export declare const useInjectReducer: ({ key, reducer, middleware, }: {
+import { Reducer } from 'redux';
+import { RTKQueryMiddleware } from './queryMiddleware.js';
+import { ListenerDispatchFn } from './listenerMiddleware.js';
+export declare const useInjectQuery: ({ key, reducer, queryMiddleware, }: {
     key: string;
     reducer: Reducer;
-    middleware?: Middleware<any, any, import("redux").Dispatch<import("redux").AnyAction>> | undefined;
+    queryMiddleware?: import("redux").Middleware<{}, import("@reduxjs/toolkit/dist/query/core/apiState.js").RootState<import("@reduxjs/toolkit/dist/query/endpointDefinitions.js").EndpointDefinitions, string, string>, import("redux-thunk").ThunkDispatch<any, any, import("redux").AnyAction>> | undefined;
+}) => void;
+export declare const useInjectListener: ({ key, listener, }: {
+    key: string;
+    listener: ListenerDispatchFn;
 }) => void;
-export { useInjectSaga, createManager } from 'redux-injectors';

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>, ...(((_store: any) => (next: any) => (action: any) => any) | 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/index.d.ts

@@ -1,12 +1,15 @@
 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 './data/redux-injectors.js';
+export { useInjectReducer, useInjectSaga, createManager, } from './data/index.js';
+export { useInjectQuery, useInjectListener } from './data/redux-injectors.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>, ...(((_store: any) => (next: any) => (action: any) => any) | 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>, ...(((_store: any) => (next: any) => (action: any) => any) | 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/pui-app-sdk",
-  "version": "4.10.0-beta.1",
+  "version": "4.10.0-beta.3",
   "description": "ICE MT UI Platform Application SDK ",
   "sideEffects": [
     "*.css",
@@ -111,7 +111,7 @@
     "indent": 4
   },
   "peerDependencies": {
-    "@elliemae/app-react-dependencies": "^4.3.0",
+    "@elliemae/app-react-dependencies": "^4.4.0",
     "@elliemae/ds-basic": "^3.13.0",
     "@elliemae/ds-button": "^3.13.0",
     "@elliemae/ds-controlled-form": "^3.13.0",
@@ -133,7 +133,7 @@
     "@elliemae/pui-user-monitoring": "^1.18.1"
   },
   "devDependencies": {
-    "@elliemae/app-react-dependencies": "~4.3.0",
+    "@elliemae/app-react-dependencies": "~4.4.0",
     "@elliemae/browserslist-config-elliemae-latest-browsers": "~1.6.0",
     "@elliemae/ds-basic": "~3.13.0",
     "@elliemae/ds-button": "~3.13.0",
@@ -149,7 +149,7 @@
     "@elliemae/ds-popperjs": "~3.13.0",
     "@elliemae/ds-toast": "~3.13.0",
     "@elliemae/em-ssf-guest": "~1.11.2",
-    "@elliemae/pui-cli": "~7.25.0",
+    "@elliemae/pui-cli": "~7.26.0",
     "@elliemae/pui-diagnostics": "~2.7.5",
     "@elliemae/pui-doc-gen": "~1.4.1",
     "@elliemae/pui-e2e-test-sdk": "~7.7.1",

package/dist/cjs/data/middleware.js

@@ -1,69 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var middleware_exports = {};
-__export(middleware_exports, {
-  addMiddleware: () => addMiddleware,
-  createDynamicMiddlewares: () => createDynamicMiddlewares,
-  default: () => middleware_default,
-  removeMiddleware: () => removeMiddleware,
-  resetMiddlewares: () => resetMiddlewares
-});
-module.exports = __toCommonJS(middleware_exports);
-var import_redux = require("redux");
-const createDynamicMiddlewares = () => {
-  let allDynamicMiddlewares = [];
-  let allApplyedDynamicMiddlewares = [];
-  let store;
-  const enhancer = (_store) => {
-    store = _store;
-    return (next) => (action) => (0, import_redux.compose)(...allApplyedDynamicMiddlewares)(next)(action);
-  };
-  const addMiddleware2 = (...middlewares) => {
-    allApplyedDynamicMiddlewares.push(
-      ...middlewares.map((middleware) => middleware(store))
-    );
-    allDynamicMiddlewares.push(...middlewares);
-  };
-  const removeMiddleware2 = (middleware) => {
-    const index = allDynamicMiddlewares.findIndex((d) => d === middleware);
-    if (index === -1) {
-      console.error("Middleware does not exist!", middleware);
-      return;
-    }
-    allDynamicMiddlewares = allDynamicMiddlewares.filter(
-      (_, mdwIndex) => mdwIndex !== index
-    );
-    allApplyedDynamicMiddlewares = allApplyedDynamicMiddlewares.filter(
-      (_, mdwIndex) => mdwIndex !== index
-    );
-  };
-  const resetMiddlewares2 = () => {
-    allApplyedDynamicMiddlewares = [];
-    allDynamicMiddlewares = [];
-  };
-  return {
-    enhancer,
-    addMiddleware: addMiddleware2,
-    removeMiddleware: removeMiddleware2,
-    resetMiddlewares: resetMiddlewares2
-  };
-};
-const dynamicMiddlewaresInstance = createDynamicMiddlewares();
-var middleware_default = dynamicMiddlewaresInstance.enhancer;
-const { addMiddleware, removeMiddleware, resetMiddlewares } = dynamicMiddlewaresInstance;

package/dist/esm/data/middleware.js

@@ -1,49 +0,0 @@
-import { compose } from "redux";
-const createDynamicMiddlewares = () => {
-  let allDynamicMiddlewares = [];
-  let allApplyedDynamicMiddlewares = [];
-  let store;
-  const enhancer = (_store) => {
-    store = _store;
-    return (next) => (action) => compose(...allApplyedDynamicMiddlewares)(next)(action);
-  };
-  const addMiddleware2 = (...middlewares) => {
-    allApplyedDynamicMiddlewares.push(
-      ...middlewares.map((middleware) => middleware(store))
-    );
-    allDynamicMiddlewares.push(...middlewares);
-  };
-  const removeMiddleware2 = (middleware) => {
-    const index = allDynamicMiddlewares.findIndex((d) => d === middleware);
-    if (index === -1) {
-      console.error("Middleware does not exist!", middleware);
-      return;
-    }
-    allDynamicMiddlewares = allDynamicMiddlewares.filter(
-      (_, mdwIndex) => mdwIndex !== index
-    );
-    allApplyedDynamicMiddlewares = allApplyedDynamicMiddlewares.filter(
-      (_, mdwIndex) => mdwIndex !== index
-    );
-  };
-  const resetMiddlewares2 = () => {
-    allApplyedDynamicMiddlewares = [];
-    allDynamicMiddlewares = [];
-  };
-  return {
-    enhancer,
-    addMiddleware: addMiddleware2,
-    removeMiddleware: removeMiddleware2,
-    resetMiddlewares: resetMiddlewares2
-  };
-};
-const dynamicMiddlewaresInstance = createDynamicMiddlewares();
-var middleware_default = dynamicMiddlewaresInstance.enhancer;
-const { addMiddleware, removeMiddleware, resetMiddlewares } = dynamicMiddlewaresInstance;
-export {
-  addMiddleware,
-  createDynamicMiddlewares,
-  middleware_default as default,
-  removeMiddleware,
-  resetMiddlewares
-};

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

@@ -1,16 +0,0 @@
-export default enhancer;
-export function addMiddleware(...middlewares: any[]): void;
-export function removeMiddleware(middleware: any): void;
-export function resetMiddlewares(): void;
-declare function enhancer(_store: any): (next: any) => (action: any) => any;
-declare namespace dynamicMiddlewaresInstance {
-    export { addMiddleware };
-    export { removeMiddleware };
-    export { resetMiddlewares };
-}
-export function createDynamicMiddlewares(): {
-    enhancer: (_store: any) => (next: any) => (action: any) => any;
-    addMiddleware: (...middlewares: any[]) => void;
-    removeMiddleware: (middleware: any) => void;
-    resetMiddlewares: () => void;
-};