@elliemae/pui-app-sdk 2.17.0 → 3.0.0-beta.3

package/dist/es/communication/http-client/retry-axios.js

@@ -1,148 +1,88 @@
-/* eslint-disable no-param-reassign,jsdoc/require-returns,jsdoc/require-param-type,jsdoc/require-returns-type,max-lines,@typescript-eslint/no-non-null-assertion */
-import axios from 'axios';
-
-const onFulfilled = res => res;
-/**
- * Eject the Axios interceptor that is providing retry capabilities.
- *
- * @param interceptorId The interceptorId provided in the config.
- * @param instance The axios instance using this interceptor.
- */
-
-
-export const detach = (interceptorId, instance) => {
-  var _instance, _instance$interceptor;
-
+import axios from "axios";
+const onFulfilled = (res) => res;
+const detach = (interceptorId, instance) => {
   instance = instance || axios;
-  if ((_instance = instance) !== null && _instance !== void 0 && (_instance$interceptor = _instance.interceptors) !== null && _instance$interceptor !== void 0 && _instance$interceptor.response) instance.interceptors.response.eject(interceptorId);
+  if (instance?.interceptors?.response)
+    instance.interceptors.response.eject(interceptorId);
 };
-/**
- * Determine based on config if we should retry the request.
- *
- * @param err The AxiosError passed to the interceptor.
- */
-// eslint-disable-next-line complexity
-
-const shouldRetryRequest = err => {
-  const config = err.config.retryConfig; // If there's no config, or retries are disabled, return.
-
+const shouldRetryRequest = (err) => {
+  const config = err.config.retryConfig;
   if (!config || config.retry === 0) {
     return false;
-  } // Check if this error has no response (ETIMEDOUT, ENOTFOUND, etc)
-
-
+  }
   if (!err.response && (config.currentRetryAttempt || 0) >= config.noResponseRetries) {
     return false;
-  } // Only retry with configured HttpMethods.
-
-
+  }
   if (!err.config.method || config.httpMethodsToRetry.indexOf(err.config.method.toUpperCase()) < 0) {
     return false;
-  } // If this wasn't in the list of status codes where we want
-  // to automatically retry, return.
-
-
+  }
   if (err.response && err.response.status) {
-    let isInRange = false; // eslint-disable-next-line no-restricted-syntax
-
+    let isInRange = false;
     for (const [min, max] of config.statusCodesToRetry) {
-      const {
-        status
-      } = err.response;
-
+      const { status } = err.response;
       if (status >= min && status <= max) {
         isInRange = true;
         break;
       }
     }
-
     if (!isInRange) {
       return false;
     }
-  } // If we are out of retry attempts, return
-
-
+  }
   config.currentRetryAttempt = config.currentRetryAttempt || 0;
-
   if (config.currentRetryAttempt >= config.retry) {
     return false;
   }
-
   return true;
-}; // eslint-disable-next-line complexity
-
-
-const onError = err => {
+};
+const onError = (err) => {
   if (!err.config) {
     return Promise.reject(err);
   }
-
   const config = err.config.retryConfig || {};
   config.currentRetryAttempt = config.currentRetryAttempt || 0;
-  config.retry = config.retry === undefined || config.retry === null ? 3 : config.retry;
+  config.retry = config.retry === void 0 || config.retry === null ? 3 : config.retry;
   config.retryDelay = config.retryDelay || 100;
   config.instance = config.instance || axios;
-  config.httpMethodsToRetry = config.httpMethodsToRetry || ['GET', 'HEAD', 'PUT', 'OPTIONS', 'DELETE'];
-  config.noResponseRetries = config.noResponseRetries === undefined || config.noResponseRetries === null ? 2 : config.noResponseRetries; // If this wasn't in the list of status codes where we want
-  // to automatically retry, return.
-
-  const retryRanges = [// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
-  // 1xx - Retry (Informational, request still processing)
-  // 2xx - Do not retry (Success)
-  // 3xx - Do not retry (Redirect)
-  // 4xx - Do not retry (Client errors)
-  // 429 - Retry ("Too Many Requests")
-  // 5xx - Retry (Server errors)
-  [100, 199], [429, 429], [500, 599]];
-  config.statusCodesToRetry = config.statusCodesToRetry || retryRanges; // Put the config back into the err
-
-  err.config.retryConfig = config; // Determine if we should retry the request
-
+  config.httpMethodsToRetry = config.httpMethodsToRetry || [
+    "GET",
+    "HEAD",
+    "PUT",
+    "OPTIONS",
+    "DELETE"
+  ];
+  config.noResponseRetries = config.noResponseRetries === void 0 || config.noResponseRetries === null ? 2 : config.noResponseRetries;
+  const retryRanges = [
+    [100, 199],
+    [429, 429],
+    [500, 599]
+  ];
+  config.statusCodesToRetry = config.statusCodesToRetry || retryRanges;
+  err.config.retryConfig = config;
   const shouldRetryFn = config.shouldRetry || shouldRetryRequest;
-
   if (!shouldRetryFn(err)) {
     return Promise.reject(err);
-  } // Create a promise that invokes the retry after the backOffDelay
-
-
-  const onBackoffPromise = new Promise(resolve => {
-    // Calculate time to wait with exponential backoff.
-    // Formula: (2^c - 1 / 2) * 1000
-    // eslint-disable-next-line no-restricted-properties
-    const delay = (Math.pow(2, config.currentRetryAttempt) - 1) / 2 * 1000;
+  }
+  const onBackoffPromise = new Promise((resolve) => {
+    const delay = (Math.pow(2, config.currentRetryAttempt) - 1) / 2 * 1e3;
     err.config.retryConfig.currentRetryAttempt += 1;
     setTimeout(resolve, delay);
-  }); // Notify the user if they added an `onRetryAttempt` handler
-
-  const onRetryAttemptPromise = config.onRetryAttempt ? Promise.resolve(config.onRetryAttempt(err)) : Promise.resolve(); // Return the promise in which recalls axios to retry the request
-
+  });
+  const onRetryAttemptPromise = config.onRetryAttempt ? Promise.resolve(config.onRetryAttempt(err)) : Promise.resolve();
   return Promise.resolve().then(() => onBackoffPromise).then(() => onRetryAttemptPromise).then(() => config.instance.request(err.config));
 };
-/**
- * Attach the interceptor to the Axios instance.
- *
- * @param instance The optional Axios instance on which to attach the
- * interceptor.
- * @returns The id of the interceptor attached to the axios instance.
- */
-
-
-export const attach = instance => {
-  var _instance2, _instance2$intercepto;
-
+const attach = (instance) => {
   instance = instance || axios;
-  return (_instance2 = instance) !== null && _instance2 !== void 0 && (_instance2$intercepto = _instance2.interceptors) !== null && _instance2$intercepto !== void 0 && _instance2$intercepto.response ? instance.interceptors.response.use(onFulfilled, onError) : null;
+  return instance?.interceptors?.response ? instance.interceptors.response.use(onFulfilled, onError) : null;
 };
-/**
- * Acquire the retryConfig object from an AxiosError if available.
- *
- * @param err The Axios error with a config object.
- */
-
-export const getConfig = err => {
+const getConfig = (err) => {
   if (err && err.config) {
     return err.config.retryConfig;
   }
-
   return null;
-};
+};
+export {
+  attach,
+  detach,
+  getConfig
+};

package/dist/es/communication/http-client/retry.js

@@ -1,34 +1,31 @@
-import { attach, getConfig } from "./retry-axios.js";
-export const getRaxConfig = httpClient => ({
-  // Retry 3 times on requests that return a response (500, etc) before giving up.  Defaults to 3.
+import {
+  attach,
+  getConfig
+} from "./retry-axios";
+const getRaxConfig = (httpClient) => ({
   retry: 3,
-  // Retry twice on errors that don't return a response (ENOTFOUND, ETIMEDOUT, etc).
   noResponseRetries: 2,
-  // Milliseconds to delay at first.  Defaults to 100.
   retryDelay: 100,
-  // HTTP methods to automatically retry.  Defaults to:
-  // ['GET', 'HEAD', 'OPTIONS', 'DELETE', 'PUT']
-  httpMethodsToRetry: ['GET', 'HEAD', 'OPTIONS', 'DELETE', 'PUT'],
-  // The response status codes to retry.  Supports a double
-  // array with a list of ranges.  Defaults to:
-  // [[100, 199], [429, 429], [500, 599]]
-  statusCodesToRetry: [[100, 199], [429, 429], [500, 599]],
-  // If you are using a non static instance of Axios you need
-  // to pass that instance here (const ax = axios.create())
+  httpMethodsToRetry: ["GET", "HEAD", "OPTIONS", "DELETE", "PUT"],
+  statusCodesToRetry: [
+    [100, 199],
+    [429, 429],
+    [500, 599]
+  ],
   instance: httpClient,
-  // You can detect when a retry is happening, and figure out how many
-  // retry attempts have been made
-  onRetryAttempt: err => {
-    const cfg = getConfig(err); // eslint-disable-next-line no-console
-
-    if (cfg && cfg.currentRetryAttempt) {}
+  onRetryAttempt: (err) => {
+    const cfg = getConfig(err);
+    if (cfg && cfg.currentRetryAttempt)
+      console.log(`Retry attempt #${cfg.currentRetryAttempt}`);
   }
 });
-
-const setupRetry = httpClient => {
-  if (httpClient !== null && httpClient !== void 0 && httpClient.defaults) // eslint-disable-next-line no-param-reassign
+const setupRetry = (httpClient) => {
+  if (httpClient?.defaults)
     httpClient.defaults.retryConfig = getRaxConfig(httpClient);
   attach(httpClient);
 };
-
-export default setupRetry;
+var retry_default = setupRetry;
+export {
+  retry_default as default,
+  getRaxConfig
+};

package/dist/es/communication/http-client/tests/index.test-disable.js

@@ -1,65 +1,46 @@
-/* Important. these test cases work only with server backend. so do not enable these test cases. */
-import enums from "../../../utils/constants.js";
-import { getAuthHTTPClient } from "../index.js";
-import { onAuthorizationFailure } from "../response-interceptor.js";
-describe('http client test cases', () => {
+import enums from "../../../utils/constants";
+import { getAuthHTTPClient } from "../index";
+import { onAuthorizationFailure } from "../response-interceptor";
+describe("http client test cases", () => {
   const callApi = ({
     apiUrl,
     options = {},
-    baseURL = 'http://localhost:3001'
+    baseURL = "http://localhost:3001"
   }) => {
-    const httpClient = getAuthHTTPClient({
-      baseURL
-    });
+    const httpClient = getAuthHTTPClient({ baseURL });
     return httpClient.get(apiUrl, options);
   };
-
-  const refreshToken = () => new Promise(resolve => {
-    const authorizationHeader = 'pui';
+  const refreshToken = () => new Promise((resolve) => {
+    const authorizationHeader = "pui";
     sessionStorage.setItem(enums.AUTHORIZATION, authorizationHeader);
     resolve(authorizationHeader);
   });
-
-  it('should download large file without timing out', async () => {
-    jest.setTimeout(300000);
-    const {
-      data
-    } = await callApi({
-      apiUrl: 'annual_report_2009.pdf',
-      options: {
-        timeout: 200000
-      },
-      baseURL: 'https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en'
+  it("should download large file without timing out", async () => {
+    jest.setTimeout(3e5);
+    const { data } = await callApi({
+      apiUrl: "annual_report_2009.pdf",
+      options: { timeout: 2e5 },
+      baseURL: "https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en"
     });
     expect(data).toBeDefined();
   });
-  it('should throw connection aborted error for large file download', async () => {
-    jest.setTimeout(300000);
+  it("should throw connection aborted error for large file download", async () => {
+    jest.setTimeout(3e5);
     await expect(callApi({
-      apiUrl: 'annual_report_2009.pdf',
-      baseURL: 'https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en'
-    })).rejects.toEqual(new Error('timeout of 10000ms exceeded'));
+      apiUrl: "annual_report_2009.pdf",
+      baseURL: "https://www.iso.org/files/live/sites/isoorg/files/archive/pdf/en"
+    })).rejects.toEqual(new Error("timeout of 10000ms exceeded"));
   });
-  it('should return success response', async () => {
-    const {
-      data
-    } = await callApi({
-      apiUrl: '/hello'
-    });
-    expect(data.name).toEqual('pui-app-sdk');
+  it("should return success response", async () => {
+    const { data } = await callApi({ apiUrl: "/hello" });
+    expect(data.name).toEqual("pui-app-sdk");
   });
-  it('should return unauthorized 401 response', async () => {
-    await expect(callApi({
-      apiUrl: '/private'
-    })).rejects.toThrow('Request failed with status code 401');
+  it("should return unauthorized 401 response", async () => {
+    await expect(callApi({ apiUrl: "/private" })).rejects.toThrow("Request failed with status code 401");
   });
-  it('should return success after refreshing authorization token', async () => {
+  it("should return success after refreshing authorization token", async () => {
     onAuthorizationFailure(refreshToken);
-    const {
-      data
-    } = await callApi({
-      apiUrl: '/private'
-    });
-    expect(data.message).toEqual('you are viewing a private message');
+    const { data } = await callApi({ apiUrl: "/private" });
+    expect(data.message).toEqual("you are viewing a private message");
   });
-});
+});

package/dist/es/data/auth/actions.js

@@ -1,7 +1,7 @@
-export const LOGIN = 'auth/LOGIN';
-export const LOGIN_SUCCESS = 'auth/LOGIN_SUCCESS';
-export const LOGOUT = 'auth/LOGOUT';
-export const auth = {
+const LOGIN = "auth/LOGIN";
+const LOGIN_SUCCESS = "auth/LOGIN_SUCCESS";
+const LOGOUT = "auth/LOGOUT";
+const auth = {
   login: ({
     idpCode,
     redirectUri,
@@ -10,13 +10,7 @@ export const auth = {
     scope
   }) => ({
     type: LOGIN,
-    payload: {
-      idpCode,
-      redirectUri,
-      clientId,
-      responseType,
-      scope
-    }
+    payload: { idpCode, redirectUri, clientId, responseType, scope }
   }),
   logout: ({
     clientId,
@@ -26,12 +20,12 @@ export const auth = {
     code
   }) => ({
     type: LOGOUT,
-    payload: {
-      clientId,
-      redirectUri,
-      responseType,
-      scope,
-      code
-    }
+    payload: { clientId, redirectUri, responseType, scope, code }
   })
-};
+};
+export {
+  LOGIN,
+  LOGIN_SUCCESS,
+  LOGOUT,
+  auth
+};

package/dist/es/data/auth/reducer.js

@@ -1,14 +1,16 @@
-import produce from 'immer';
-import { LOGIN_SUCCESS } from "./actions.js";
-export const initialState = {
+import produce from "immer";
+import { LOGIN_SUCCESS } from "./actions";
+const initialState = {
   authenticated: false
 };
-/* eslint-disable default-case, no-param-reassign */
-
-export const authReducer = produce((draft, action) => {
+const authReducer = produce((draft, action) => {
   switch (action.type) {
     case LOGIN_SUCCESS:
       draft.authenticated = true;
       break;
   }
-}, initialState);
+}, initialState);
+export {
+  authReducer,
+  initialState
+};

package/dist/es/data/breakpoint/index.js

@@ -1,30 +1,28 @@
-/* eslint-disable no-param-reassign */
-import produce from 'immer';
-export const breakpoint = {
-  change: 'change'
+import produce from "immer";
+const breakpoint = {
+  change: "change"
 };
-export let Breakpoints;
-
-(function (Breakpoints) {
-  Breakpoints["LARGE"] = "large";
-  Breakpoints["MEDIUM"] = "medium";
-  Breakpoints["SMALL"] = "small";
-})(Breakpoints || (Breakpoints = {}));
-
+var Breakpoints = /* @__PURE__ */ ((Breakpoints2) => {
+  Breakpoints2["LARGE"] = "large";
+  Breakpoints2["MEDIUM"] = "medium";
+  Breakpoints2["SMALL"] = "small";
+  return Breakpoints2;
+})(Breakpoints || {});
 const initialState = {
-  value: Breakpoints.LARGE
+  value: "large" /* LARGE */
 };
-export const breakpointReducer = (state = initialState, action) => {
-  const {
-    type,
-    payload
-  } = action;
-  return produce(state, draft => {
-    // eslint-disable-next-line default-case
+const breakpointReducer = (state = initialState, action) => {
+  const { type, payload } = action;
+  return produce(state, (draft) => {
     switch (type) {
       case breakpoint.change:
         draft.value = payload;
         break;
     }
   });
-};
+};
+export {
+  Breakpoints,
+  breakpoint,
+  breakpointReducer
+};

package/dist/es/data/error/index.js

@@ -1,17 +1,19 @@
-import { createSlice } from '@reduxjs/toolkit';
+import { createSlice } from "@reduxjs/toolkit";
 const initialState = {
-  description: '',
-  messageText: ''
+  description: "",
+  messageText: ""
 };
 const errorSlice = createSlice({
-  name: 'error',
+  name: "error",
   initialState,
   reducers: {
-    set: (_, actions) => actions.payload,
+    set: (_, actions2) => actions2.payload,
     clear: () => initialState
   }
 });
-export const {
-  actions
-} = errorSlice;
-export const errorReducer = errorSlice.reducer;
+const { actions } = errorSlice;
+const errorReducer = errorSlice.reducer;
+export {
+  actions,
+  errorReducer
+};

package/dist/es/data/live-message/index.js

@@ -1,27 +1,23 @@
-import { createSlice } from '@reduxjs/toolkit';
+import { createSlice } from "@reduxjs/toolkit";
 const initialState = {
-  message: '',
-  ariaLive: 'polite',
-  id: ''
+  message: "",
+  ariaLive: "polite",
+  id: ""
 };
 const liveMessage = createSlice({
-  name: 'liveMessage',
+  name: "liveMessage",
   initialState,
   reducers: {
-    announce: (state, {
-      payload: {
-        message,
-        ariaLive,
-        id
-      }
-    }) => ({
+    announce: (state, { payload: { message, ariaLive, id } }) => ({
       message,
       ariaLive,
       id
     })
   }
 });
-export const {
-  actions
-} = liveMessage;
-export const liveMessageReducer = liveMessage.reducer;
+const { actions } = liveMessage;
+const liveMessageReducer = liveMessage.reducer;
+export {
+  actions,
+  liveMessageReducer
+};

package/dist/es/data/logout/actions.js

@@ -1,8 +1,8 @@
-export const actions = {
-  CONFIRM: 'log-out/CONFIRM',
-  CANCEL: 'log-out/CANCEL'
+const actions = {
+  CONFIRM: "log-out/CONFIRM",
+  CANCEL: "log-out/CANCEL"
 };
-export const logout = {
+const logout = {
   confirm: () => ({
     type: actions.CONFIRM,
     payload: null
@@ -11,4 +11,8 @@ export const logout = {
     type: actions.CANCEL,
     payload: null
   })
-};
+};
+export {
+  actions,
+  logout
+};

package/dist/es/data/navigation-prompt/actions.js

@@ -1,8 +1,8 @@
-export const ACTIONS = {
-  CONFIRM: 'navigation-prompt/CONFIRM',
-  CANCEL: 'navigation-prompt/CANCEL'
+const ACTIONS = {
+  CONFIRM: "navigation-prompt/CONFIRM",
+  CANCEL: "navigation-prompt/CANCEL"
 };
-export const navigationPrompt = {
+const navigationPrompt = {
   confirm: () => ({
     type: ACTIONS.CONFIRM,
     payload: null
@@ -11,4 +11,8 @@ export const navigationPrompt = {
     type: ACTIONS.CANCEL,
     payload: null
   })
-};
+};
+export {
+  ACTIONS,
+  navigationPrompt
+};

package/dist/es/data/react-redux.js

@@ -1,3 +1,7 @@
-import { useDispatch, useSelector } from 'react-redux';
-export const useAppDispatch = () => useDispatch();
-export const useAppSelector = useSelector;
+import { useDispatch, useSelector } from "react-redux";
+const useAppDispatch = () => useDispatch();
+const useAppSelector = useSelector;
+export {
+  useAppDispatch,
+  useAppSelector
+};

package/dist/es/data/reducers.js

@@ -1,9 +1,9 @@
-import { combineReducers } from '@reduxjs/toolkit';
-import { waitMessageReducer } from "./wait-message/reducer.js";
-import { errorReducer } from "./error/index.js";
-import { breakpointReducer } from "./breakpoint/index.js";
-import { liveMessageReducer } from "./live-message/index.js";
-export const createReducer = (injectedReducers = {}) => {
+import { combineReducers } from "@reduxjs/toolkit";
+import { waitMessageReducer } from "./wait-message/reducer";
+import { errorReducer } from "./error";
+import { breakpointReducer } from "./breakpoint";
+import { liveMessageReducer } from "./live-message";
+const createReducer = (injectedReducers = {}) => {
   const rootReducer = combineReducers({
     waitMessage: waitMessageReducer,
     error: errorReducer,
@@ -12,4 +12,7 @@ export const createReducer = (injectedReducers = {}) => {
     ...injectedReducers
   });
   return rootReducer;
-};
+};
+export {
+  createReducer
+};

package/dist/es/data/saga.js

@@ -1,5 +1,8 @@
-export const AllowedModes = {
-  RestartOnRemount: 'RESTART_ON_REMOUNT',
-  Daemon: 'DAEMON',
-  OnceTillUnmount: 'ONCE_TILL_UNMOUNT'
-};
+const AllowedModes = {
+  RestartOnRemount: "RESTART_ON_REMOUNT",
+  Daemon: "DAEMON",
+  OnceTillUnmount: "ONCE_TILL_UNMOUNT"
+};
+export {
+  AllowedModes
+};