studiokit-scaffolding-js 5.2.0 → 6.0.0

package/lib/redux/actionCreator.js

@@ -1,17 +1,55 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAction = exports.dispatchAction = exports.setStore = void 0;
-var lodash_1 = require("lodash");
+exports.addNotification = exports.dispatchModelRemoveKeyAction = exports.dispatchPeriodicModelFetchTerminateAction = exports.dispatchPeriodicModelFetchRequest = exports.dispatchModelFetchRequest = exports.dispatchAction = exports.setStore = void 0;
+var uuid_1 = require("uuid");
+var actions_1 = require("./actions");
+var NotificationAction_1 = require("./actions/NotificationAction");
 var store;
 var setStore = function (storeParam) {
     store = storeParam;
 };
 exports.setStore = setStore;
-var dispatchAction = function (type, payload) {
-    store.dispatch(exports.createAction(type, payload));
+var dispatchAction = function (action) {
+    store.dispatch(action);
 };
 exports.dispatchAction = dispatchAction;
-var createAction = function (type, payload) {
-    return lodash_1.merge({}, { type: type }, payload);
+var dispatchModelFetchRequest = function (action) {
+    exports.dispatchAction(__assign({ type: actions_1.MODEL_FETCH_REQUEST_ACTION_TYPE.FETCH_REQUEST }, action));
+};
+exports.dispatchModelFetchRequest = dispatchModelFetchRequest;
+var dispatchPeriodicModelFetchRequest = function (action) {
+    exports.dispatchAction(__assign({ type: actions_1.MODEL_FETCH_REQUEST_ACTION_TYPE.PERIODIC_FETCH_REQUEST }, action));
+};
+exports.dispatchPeriodicModelFetchRequest = dispatchPeriodicModelFetchRequest;
+var dispatchPeriodicModelFetchTerminateAction = function (action) {
+    exports.dispatchAction(__assign({ type: actions_1.PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE.TERMINATE }, action));
+};
+exports.dispatchPeriodicModelFetchTerminateAction = dispatchPeriodicModelFetchTerminateAction;
+var dispatchModelRemoveKeyAction = function (action) {
+    exports.dispatchAction(__assign({ type: actions_1.MODEL_REMOVE_KEY_ACTION_TYPE }, action));
+};
+exports.dispatchModelRemoveKeyAction = dispatchModelRemoveKeyAction;
+var addNotification = function (_a) {
+    var text = _a.text, type = _a.type, modalId = _a.modalId;
+    exports.dispatchAction({
+        type: NotificationAction_1.NOTIFICATION_ACTION_TYPE.ADD_NOTIFICATION,
+        notification: {
+            id: uuid_1.v4(),
+            text: text,
+            type: type,
+            modalId: modalId
+        }
+    });
 };
-exports.createAction = createAction;
+exports.addNotification = addNotification;

package/lib/redux/actions/AuthAction.d.ts

@@ -0,0 +1,53 @@
+import { Action } from 'redux';
+import { CasV1LoginRequestBody, IdentityProvider } from '../../types';
+import { LocalLoginRequestBody } from '../../types/auth/LocalLoginRequestBody';
+import { OAuthToken, OAuthTokenOrNull } from '../../types/net';
+export declare enum AUTH_ACTION_TYPE {
+    CAS_LOGIN_REQUESTED = "auth/CAS_LOGIN_REQUESTED",
+    LOGIN_REQUESTED = "auth/LOGIN_REQUESTED",
+    LOG_OUT_REQUESTED = "auth/LOG_OUT_REQUESTED",
+    TOKEN_REFRESH_FAILED = "auth/TOKEN_REFRESH_FAILED",
+    LOGIN_FAILED = "auth/LOGIN_FAILED"
+}
+/**
+ * Action with no additional properties.
+ */
+export interface AuthAction extends Action<AUTH_ACTION_TYPE> {
+}
+export declare enum AUTH_TOKEN_ACTION_TYPE {
+    AUTH_INITIALIZED = "auth/INITIALIZED"
+}
+/**
+ * Action with a nullable `oauthToken`.
+ */
+export interface AuthTokenAction extends Action<AUTH_TOKEN_ACTION_TYPE> {
+    oauthToken: OAuthTokenOrNull;
+}
+export declare enum AUTH_TOKEN_SUCCESS_ACTION_TYPE {
+    GET_TOKEN_SUCCEEDED = "auth/GET_TOKEN_SUCCEEDED",
+    TOKEN_REFRESH_SUCCEEDED = "auth/TOKEN_REFRESH_SUCCEEDED"
+}
+/**
+ * Action with an `oauthToken`.
+ */
+export interface AuthTokenSuccessAction extends Action<AUTH_TOKEN_SUCCESS_ACTION_TYPE> {
+    oauthToken: OAuthToken;
+}
+export declare enum AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE {
+    IDENTITY_PROVIDER_LOGIN_REQUEST = "auth/IDENTITY_PROVIDER_LOGIN_REQUEST"
+}
+export interface AuthIdentityProviderRequestAction extends Action<AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE> {
+    identityProvider: IdentityProvider;
+}
+export declare enum AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE {
+    CAS_V1_LOGIN_REQUEST = "auth/CAS_V1_LOGIN_REQUEST"
+}
+export interface AuthCasV1LoginRequestAction extends Action<AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE> {
+    body: CasV1LoginRequestBody;
+}
+export declare enum AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE {
+    LOCAL_LOGIN_REQUEST = "auth/LOCAL_LOGIN_REQUEST"
+}
+export interface AuthLocalLoginRequestAction extends Action<AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE> {
+    body: LocalLoginRequestBody;
+}

package/lib/redux/actions/AuthAction.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE = exports.AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE = exports.AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE = exports.AUTH_TOKEN_SUCCESS_ACTION_TYPE = exports.AUTH_TOKEN_ACTION_TYPE = exports.AUTH_ACTION_TYPE = void 0;
+var AUTH_ACTION_TYPE;
+(function (AUTH_ACTION_TYPE) {
+    AUTH_ACTION_TYPE["CAS_LOGIN_REQUESTED"] = "auth/CAS_LOGIN_REQUESTED";
+    AUTH_ACTION_TYPE["LOGIN_REQUESTED"] = "auth/LOGIN_REQUESTED";
+    AUTH_ACTION_TYPE["LOG_OUT_REQUESTED"] = "auth/LOG_OUT_REQUESTED";
+    AUTH_ACTION_TYPE["TOKEN_REFRESH_FAILED"] = "auth/TOKEN_REFRESH_FAILED";
+    AUTH_ACTION_TYPE["LOGIN_FAILED"] = "auth/LOGIN_FAILED";
+})(AUTH_ACTION_TYPE = exports.AUTH_ACTION_TYPE || (exports.AUTH_ACTION_TYPE = {}));
+var AUTH_TOKEN_ACTION_TYPE;
+(function (AUTH_TOKEN_ACTION_TYPE) {
+    AUTH_TOKEN_ACTION_TYPE["AUTH_INITIALIZED"] = "auth/INITIALIZED";
+})(AUTH_TOKEN_ACTION_TYPE = exports.AUTH_TOKEN_ACTION_TYPE || (exports.AUTH_TOKEN_ACTION_TYPE = {}));
+var AUTH_TOKEN_SUCCESS_ACTION_TYPE;
+(function (AUTH_TOKEN_SUCCESS_ACTION_TYPE) {
+    AUTH_TOKEN_SUCCESS_ACTION_TYPE["GET_TOKEN_SUCCEEDED"] = "auth/GET_TOKEN_SUCCEEDED";
+    AUTH_TOKEN_SUCCESS_ACTION_TYPE["TOKEN_REFRESH_SUCCEEDED"] = "auth/TOKEN_REFRESH_SUCCEEDED";
+})(AUTH_TOKEN_SUCCESS_ACTION_TYPE = exports.AUTH_TOKEN_SUCCESS_ACTION_TYPE || (exports.AUTH_TOKEN_SUCCESS_ACTION_TYPE = {}));
+var AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE;
+(function (AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE) {
+    AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE["IDENTITY_PROVIDER_LOGIN_REQUEST"] = "auth/IDENTITY_PROVIDER_LOGIN_REQUEST";
+})(AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE = exports.AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE || (exports.AUTH_IDENTITY_PROVIDER_REQUEST_ACTION_TYPE = {}));
+var AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE;
+(function (AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE) {
+    AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE["CAS_V1_LOGIN_REQUEST"] = "auth/CAS_V1_LOGIN_REQUEST";
+})(AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE = exports.AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE || (exports.AUTH_CAS_V1_LOGIN_REQUEST_ACTION_TYPE = {}));
+var AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE;
+(function (AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE) {
+    AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE["LOCAL_LOGIN_REQUEST"] = "auth/LOCAL_LOGIN_REQUEST";
+})(AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE = exports.AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE || (exports.AUTH_LOCAL_LOGIN_REQUEST_ACTION_TYPE = {}));

package/lib/redux/actions/ModalAction.d.ts

@@ -0,0 +1,16 @@
+import { Action } from 'redux';
+export declare enum MODAL_ACTION_TYPE {
+    MODAL_ENTERING = "modals/ENTERING",
+    MODAL_EXITED = "modals/EXITED"
+}
+export interface ModalActionValue {
+    index: number;
+    isFullscreen: boolean;
+}
+export interface ModalEnterAction extends Action<MODAL_ACTION_TYPE.MODAL_ENTERING>, ModalActionValue {
+    guid: string;
+}
+export interface ModalExitAction extends Action<MODAL_ACTION_TYPE.MODAL_EXITED> {
+    guid: string;
+}
+export declare type ModalAction = ModalEnterAction | ModalExitAction;

package/lib/redux/actions/ModalAction.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODAL_ACTION_TYPE = void 0;
+var MODAL_ACTION_TYPE;
+(function (MODAL_ACTION_TYPE) {
+    MODAL_ACTION_TYPE["MODAL_ENTERING"] = "modals/ENTERING";
+    MODAL_ACTION_TYPE["MODAL_EXITED"] = "modals/EXITED";
+})(MODAL_ACTION_TYPE = exports.MODAL_ACTION_TYPE || (exports.MODAL_ACTION_TYPE = {}));

package/lib/redux/actions/ModelAction.d.ts

@@ -0,0 +1,117 @@
+import { Action, AnyAction } from 'redux';
+import { FetchErrorData } from '../../types/net/FetchErrorData';
+import { HTTPMethod } from '../../types/net/HTTPMethod';
+export declare enum MODEL_FETCH_REQUEST_ACTION_TYPE {
+    FETCH_REQUEST = "models/FETCH_REQUEST",
+    PERIODIC_FETCH_REQUEST = "models/PERIODIC_FETCH_REQUEST"
+}
+export interface BaseModelFetchRequestAction<T> extends Action<T> {
+    /**
+     * The generic path (no Ids) to an `EndpointMapping` and to where the model will be stored in redux under `state.models` (levels separated by a '.').
+     */
+    modelName: string;
+    /**
+     * An array of values to be replaced in the fetch path and redux model path using pattern matching, in order, e.g.
+     * `"/collection/{}/subcollection/{}" => "/collection/1/subcollection/2"`
+     */
+    pathParams?: Array<string | number | undefined | null>;
+    /** A unique identifier used for action dispatchers to correlate responses to requests. Will be attached to the corresponding `ModelFetchResultAction.data`. */
+    guid?: string;
+    /** The HTTP Method to use for the fetch. Defaults to use value from EndpointMapping, or 'GET'. */
+    method?: HTTPMethod;
+    /** Key/value pairs of headers to be sent with the request. */
+    headers?: Record<string, string>;
+    /** Key/value pairs to be added to query as query params. */
+    queryParams?: Record<string, string | number | boolean>;
+    /** A value to send as the HTTP Body. */
+    body?: any;
+    /** If true, make the request but do not store the response in redux. */
+    noStore?: boolean;
+    /** Prevent the use of the default logarithmic backoff retry strategy. */
+    noRetry?: boolean;
+    /** The contentType to be set in the headers. Defaults to `application/json` */
+    contentType?: string;
+    /** If true, the `modelsReducer` will replace the existing value in redux, instead of merging the incoming with existing. Passed to `ModelFetchResultAction` */
+    replaceValue?: boolean;
+}
+/**
+ * Action used to trigger a fetch request for a model. Uses `modelName` to find an `EndpointMapping`, and stores results in the corresponding location in redux under `state.models`.
+ */
+export interface ModelFetchRequestAction extends BaseModelFetchRequestAction<MODEL_FETCH_REQUEST_ACTION_TYPE.FETCH_REQUEST> {
+}
+/**
+ * Action used to trigger a recurring fetch request for a model. Uses `modelName` to find an `EndpointMapping`, and stores results in the corresponding location in redux under `state.models`.
+ */
+export interface PeriodicModelFetchRequestAction extends BaseModelFetchRequestAction<MODEL_FETCH_REQUEST_ACTION_TYPE.PERIODIC_FETCH_REQUEST> {
+    /** How often in `ms` milliseconds to re-fetch when used in a recurring fetch scenario. */
+    period: number;
+    /** An id, from your application, used to cancel the recurring fetch task at a later time. */
+    taskId: string;
+}
+export declare enum PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE {
+    TERMINATE = "models/PERIODIC_MODEL_FETCH_REQUEST_TERMINATE",
+    SUCCEEDED = "models/PERIODIC_MODEL_FETCH_REQUEST_TERMINATE_SUCCEEDED"
+}
+/**
+ * Action used to terminate a periodic model fetch request task, or notify of termination success.
+ */
+export interface PeriodicModelFetchTerminationAction extends Action<PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE> {
+    /** The id, from your application, used to cancel a recurring task. */
+    taskId: string;
+}
+interface BaseModelStoreAction {
+    /** The full object path used to store the result in the redux store under 'state.models'. Includes keys and ids. */
+    modelPath: string;
+    /** The pre-generated GUID, from your application, that was provided to the `ModelFetchRequestAction`. */
+    guid?: string;
+}
+export declare const MODEL_REMOVE_KEY_ACTION_TYPE = "models/REMOVE_KEY";
+/**
+ * Action used to remove the model at the target redux `modelPath` key.
+ */
+export interface ModelRemoveKeyAction extends Action<typeof MODEL_REMOVE_KEY_ACTION_TYPE>, Omit<BaseModelStoreAction, 'guid'> {
+}
+export declare enum MODEL_FETCH_START_ACTION_TYPE {
+    FETCH_START = "models/FETCH_START",
+    TRANSIENT_FETCH_START = "models/TRANSIENT_FETCH_START"
+}
+/**
+ * Action used to update the target redux `modelPath` `_metadata` when a fetch is about to start.
+ */
+export interface ModelFetchStartAction extends Action<MODEL_FETCH_START_ACTION_TYPE>, BaseModelStoreAction {
+}
+export declare enum MODEL_FETCH_RESULT_ACTION_TYPE {
+    FETCH_RESULT_RECEIVED = "models/FETCH_RESULT_RECEIVED",
+    TRANSIENT_FETCH_RESULT_RECEIVED = "models/TRANSIENT_FETCH_RESULT_RECEIVED"
+}
+/**
+ * Action used to update the target redux `modelPath` when a successful fetch result is received.
+ */
+export interface ModelFetchResultAction extends Action<MODEL_FETCH_RESULT_ACTION_TYPE>, BaseModelStoreAction {
+    /** If true, the `modelsReducer` will replace the existing value in redux, instead of merging the incoming with existing. */
+    replaceValue?: boolean;
+    /** The data returned from a request. */
+    data?: any;
+}
+export declare const isModelFetchResultAction: (action: AnyAction) => action is ModelFetchResultAction;
+export declare const isTransientModelFetchResultAction: (action: AnyAction) => action is ModelFetchResultAction;
+export declare enum MODEL_FETCH_ERROR_ACTION_TYPE {
+    FETCH_FAILED = "models/FETCH_FAILED",
+    TRANSIENT_FETCH_FAILED = "models/TRANSIENT_FETCH_FAILED",
+    TRY_FETCH_FAILED = "models/TRY_FETCH_FAILED"
+}
+/**
+ * Action used to update the target redux `modelPath` `_metadata` for a failed fetch.
+ */
+export interface ModelFetchErrorAction extends Action<MODEL_FETCH_ERROR_ACTION_TYPE>, BaseModelStoreAction {
+    /** The error data returned from a failed request. */
+    errorData?: FetchErrorData;
+}
+export declare const isModelFetchErrorAction: (action: AnyAction) => action is ModelFetchErrorAction;
+export declare const isTransientModelFetchErrorAction: (action: AnyAction) => action is ModelFetchErrorAction;
+export declare const isModelTryFetchErrorAction: (action: AnyAction) => action is ModelFetchErrorAction;
+/**
+ * A redux action related to a model fetch request, result, error, or remove key action. To be used by `modelsReducer`.
+ */
+export declare type ModelStoreAction = ModelFetchStartAction | ModelFetchResultAction | ModelFetchErrorAction | ModelRemoveKeyAction;
+export {};

package/lib/redux/actions/ModelAction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModelTryFetchErrorAction = exports.isTransientModelFetchErrorAction = exports.isModelFetchErrorAction = exports.MODEL_FETCH_ERROR_ACTION_TYPE = exports.isTransientModelFetchResultAction = exports.isModelFetchResultAction = exports.MODEL_FETCH_RESULT_ACTION_TYPE = exports.MODEL_FETCH_START_ACTION_TYPE = exports.MODEL_REMOVE_KEY_ACTION_TYPE = exports.PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE = exports.MODEL_FETCH_REQUEST_ACTION_TYPE = void 0;
+//#region Model Fetch Requests
+var MODEL_FETCH_REQUEST_ACTION_TYPE;
+(function (MODEL_FETCH_REQUEST_ACTION_TYPE) {
+    MODEL_FETCH_REQUEST_ACTION_TYPE["FETCH_REQUEST"] = "models/FETCH_REQUEST";
+    MODEL_FETCH_REQUEST_ACTION_TYPE["PERIODIC_FETCH_REQUEST"] = "models/PERIODIC_FETCH_REQUEST";
+})(MODEL_FETCH_REQUEST_ACTION_TYPE = exports.MODEL_FETCH_REQUEST_ACTION_TYPE || (exports.MODEL_FETCH_REQUEST_ACTION_TYPE = {}));
+var PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE;
+(function (PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE) {
+    PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE["TERMINATE"] = "models/PERIODIC_MODEL_FETCH_REQUEST_TERMINATE";
+    PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE["SUCCEEDED"] = "models/PERIODIC_MODEL_FETCH_REQUEST_TERMINATE_SUCCEEDED";
+})(PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE = exports.PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE || (exports.PERIODIC_MODEL_FETCH_TERMINATION_ACTION_TYPE = {}));
+//#region Model Remove Key
+exports.MODEL_REMOVE_KEY_ACTION_TYPE = 'models/REMOVE_KEY';
+//#endregion Model Remove Key
+//#region Model Fetch Start
+var MODEL_FETCH_START_ACTION_TYPE;
+(function (MODEL_FETCH_START_ACTION_TYPE) {
+    MODEL_FETCH_START_ACTION_TYPE["FETCH_START"] = "models/FETCH_START";
+    MODEL_FETCH_START_ACTION_TYPE["TRANSIENT_FETCH_START"] = "models/TRANSIENT_FETCH_START";
+})(MODEL_FETCH_START_ACTION_TYPE = exports.MODEL_FETCH_START_ACTION_TYPE || (exports.MODEL_FETCH_START_ACTION_TYPE = {}));
+//#endregion Model Fetch Start
+//#region Model Fetch Result
+var MODEL_FETCH_RESULT_ACTION_TYPE;
+(function (MODEL_FETCH_RESULT_ACTION_TYPE) {
+    MODEL_FETCH_RESULT_ACTION_TYPE["FETCH_RESULT_RECEIVED"] = "models/FETCH_RESULT_RECEIVED";
+    MODEL_FETCH_RESULT_ACTION_TYPE["TRANSIENT_FETCH_RESULT_RECEIVED"] = "models/TRANSIENT_FETCH_RESULT_RECEIVED";
+})(MODEL_FETCH_RESULT_ACTION_TYPE = exports.MODEL_FETCH_RESULT_ACTION_TYPE || (exports.MODEL_FETCH_RESULT_ACTION_TYPE = {}));
+var isModelFetchResultAction = function (action) {
+    return action.type === MODEL_FETCH_RESULT_ACTION_TYPE.FETCH_RESULT_RECEIVED ||
+        action.type === MODEL_FETCH_RESULT_ACTION_TYPE.TRANSIENT_FETCH_RESULT_RECEIVED;
+};
+exports.isModelFetchResultAction = isModelFetchResultAction;
+var isTransientModelFetchResultAction = function (action) {
+    return action.type === MODEL_FETCH_RESULT_ACTION_TYPE.TRANSIENT_FETCH_RESULT_RECEIVED;
+};
+exports.isTransientModelFetchResultAction = isTransientModelFetchResultAction;
+//#endregion Model Fetch Result
+//#region Model Fetch Error
+var MODEL_FETCH_ERROR_ACTION_TYPE;
+(function (MODEL_FETCH_ERROR_ACTION_TYPE) {
+    MODEL_FETCH_ERROR_ACTION_TYPE["FETCH_FAILED"] = "models/FETCH_FAILED";
+    MODEL_FETCH_ERROR_ACTION_TYPE["TRANSIENT_FETCH_FAILED"] = "models/TRANSIENT_FETCH_FAILED";
+    MODEL_FETCH_ERROR_ACTION_TYPE["TRY_FETCH_FAILED"] = "models/TRY_FETCH_FAILED";
+})(MODEL_FETCH_ERROR_ACTION_TYPE = exports.MODEL_FETCH_ERROR_ACTION_TYPE || (exports.MODEL_FETCH_ERROR_ACTION_TYPE = {}));
+var isModelFetchErrorAction = function (action) {
+    return action.type === MODEL_FETCH_ERROR_ACTION_TYPE.TRY_FETCH_FAILED ||
+        action.type === MODEL_FETCH_ERROR_ACTION_TYPE.FETCH_FAILED ||
+        action.type === MODEL_FETCH_ERROR_ACTION_TYPE.TRANSIENT_FETCH_FAILED;
+};
+exports.isModelFetchErrorAction = isModelFetchErrorAction;
+var isTransientModelFetchErrorAction = function (action) {
+    return action.type === MODEL_FETCH_ERROR_ACTION_TYPE.TRANSIENT_FETCH_FAILED;
+};
+exports.isTransientModelFetchErrorAction = isTransientModelFetchErrorAction;
+var isModelTryFetchErrorAction = function (action) {
+    return action.type === MODEL_FETCH_ERROR_ACTION_TYPE.TRY_FETCH_FAILED;
+};
+exports.isModelTryFetchErrorAction = isModelTryFetchErrorAction;
+//#endregion Model Store Actions

package/lib/redux/actions/NotificationAction.d.ts

@@ -0,0 +1,9 @@
+import { Action } from 'redux';
+import { Notification } from '../../types/Notification';
+export declare enum NOTIFICATION_ACTION_TYPE {
+    ADD_NOTIFICATION = "notifications/ADD_NOTIFICATION",
+    REMOVE_NOTIFICATION = "notifications/REMOVE_NOTIFICATION"
+}
+export interface NotificationAction extends Action<NOTIFICATION_ACTION_TYPE> {
+    notification: Notification;
+}

package/lib/redux/actions/NotificationAction.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTIFICATION_ACTION_TYPE = void 0;
+var NOTIFICATION_ACTION_TYPE;
+(function (NOTIFICATION_ACTION_TYPE) {
+    NOTIFICATION_ACTION_TYPE["ADD_NOTIFICATION"] = "notifications/ADD_NOTIFICATION";
+    NOTIFICATION_ACTION_TYPE["REMOVE_NOTIFICATION"] = "notifications/REMOVE_NOTIFICATION";
+})(NOTIFICATION_ACTION_TYPE = exports.NOTIFICATION_ACTION_TYPE || (exports.NOTIFICATION_ACTION_TYPE = {}));

package/lib/redux/actions/SearchAction.d.ts

@@ -0,0 +1,8 @@
+import { Dictionary } from 'lodash';
+import { Action } from 'redux';
+export declare enum SEARCH_ACTION_TYPE {
+    PERSIST_SEARCH = "manage/PERSIST_SEARCH"
+}
+export interface SearchAction extends Action<SEARCH_ACTION_TYPE> {
+    data: Dictionary<any>;
+}

package/lib/redux/actions/SearchAction.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_ACTION_TYPE = void 0;
+var SEARCH_ACTION_TYPE;
+(function (SEARCH_ACTION_TYPE) {
+    SEARCH_ACTION_TYPE["PERSIST_SEARCH"] = "manage/PERSIST_SEARCH";
+})(SEARCH_ACTION_TYPE = exports.SEARCH_ACTION_TYPE || (exports.SEARCH_ACTION_TYPE = {}));

package/lib/redux/actions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './AuthAction';
+export * from './ModelAction';
+export * from './ModalAction';
+export * from './NotificationAction';
+export * from './SearchAction';

package/lib/redux/actions/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AuthAction"), exports);
+__exportStar(require("./ModelAction"), exports);
+__exportStar(require("./ModalAction"), exports);
+__exportStar(require("./NotificationAction"), exports);
+__exportStar(require("./SearchAction"), exports);

package/lib/redux/configureReducers.d.ts

@@ -3,10 +3,11 @@ import { History } from 'history';
 import { Dictionary } from 'lodash';
 import { Reducer } from 'redux';
 import { PersistedState } from 'redux-persist';
-import { BaseModelsState, BaseReduxState, FetchAction } from '../types';
+import { BaseModelsState, BaseReduxState } from '../types';
+import { ModelStoreAction } from './actions/ModelAction';
 export declare const updatePersistBlacklist: (blacklist: string[]) => void;
 export declare const setOtherReducers: (value: Dictionary<Reducer>) => void;
-declare type ConfigureModelsReducerFunction = <TModelsState extends BaseModelsState>(reducer: Reducer<TModelsState, FetchAction>) => Reducer<TModelsState, FetchAction>;
+declare type ConfigureModelsReducerFunction = <TModelsState extends BaseModelsState>(reducer: Reducer<TModelsState, ModelStoreAction>) => Reducer<TModelsState, ModelStoreAction>;
 /**
  * Sets or clears a "middleware" function that is called when constructing the "models"
  * redux reducer, allowing for modification by the app.

package/lib/redux/configureReducers.js

@@ -80,11 +80,11 @@ var setConfigureModelsReducer = function (value) {
 exports.setConfigureModelsReducer = setConfigureModelsReducer;
 //#endregion Setup
 var getModelsReducer = function () {
-    var modelsReducer = reducers_1.fetchReducer;
+    var localModelsReducer = reducers_1.modelsReducer;
     if (configureModelsReducer) {
-        return configureModelsReducer(modelsReducer);
+        return configureModelsReducer(localModelsReducer);
     }
-    return modelsReducer;
+    return localModelsReducer;
 };
 var configureReducers = function (history) {
     return redux_persist_1.persistReducer(rootPersistConfig, redux_1.combineReducers(__assign({ auth: redux_persist_1.persistReducer(authPersistConfig, reducers_1.authReducer), notifications: redux_persist_1.persistReducer(notificationsPersistConfig, reducers_1.notificationsReducer), modals: reducers_1.modalsReducer, models: getModelsReducer(), router: connected_react_router_1.connectRouter(history), search: reducers_1.searchReducer }, otherReducers)));

package/lib/redux/configureStore.js

@@ -43,7 +43,16 @@ var actionCreator_1 = require("./actionCreator");
 var actions_1 = require("./actions");
 var configureReducers_1 = __importDefault(require("./configureReducers"));
 var rootSaga_1 = __importDefault(require("./sagas/rootSaga"));
-var keysToFilter = ['puid', 'employeeNumber', 'access_token', 'refresh_token', 'password', 'Password', 'content'];
+var keysToFilter = [
+    'puid',
+    'employeeNumber',
+    'access_token',
+    'refresh_token',
+    'password',
+    'Password',
+    'content',
+    'data'
+];
 var filterData = function (obj) {
     return lodash_1.transform(obj, function (result, value, key) {
         if (keysToFilter.includes(key)) {
@@ -65,17 +74,11 @@ var stripState = function (obj, parentKey) {
 };
 exports.stripState = stripState;
 var actionTransformer = function (action) {
-    var _a;
     // action breadcrumb filtering
     if (
-    // do not track API responses
-    action.type === actions_1.NET_ACTION.FETCH_RESULT_RECEIVED ||
-        action.type === actions_1.NET_ACTION.TRANSIENT_FETCH_RESULT_RECEIVED ||
-        // do not track modal actions
-        action.type === actions_1.ACTION.MODAL_ENTERING ||
-        action.type === actions_1.ACTION.MODAL_EXITED ||
-        // do not track API requests for tokens
-        (action.type === actions_1.NET_ACTION.DATA_REQUESTED && ((_a = action.data) === null || _a === void 0 ? void 0 : _a.modelName) === 'getToken')) {
+    // do not track modal actions
+    action.type === actions_1.MODAL_ACTION_TYPE.MODAL_ENTERING ||
+        action.type === actions_1.MODAL_ACTION_TYPE.MODAL_EXITED) {
         return null;
     }
     return filterData(action);

package/lib/redux/helpers.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasUserData = void 0;
-var hasUserData = function (state) {
-    return !!state.models && !!state.models.user && !!state.models.user.userInfo && !!state.models.user.userInfo.id;
-};
+var hasUserData = function (state) { var _a, _b, _c; return !!((_c = (_b = (_a = state.models) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.userInfo) === null || _c === void 0 ? void 0 : _c.id); };
 exports.hasUserData = hasUserData;

package/lib/redux/reducers/authReducer.d.ts

@@ -1,2 +1,6 @@
-import { AuthAction, AuthState } from '../../types';
-export default function authReducer(state: AuthState | undefined, action: AuthAction): AuthState;
+import { AuthState } from '../../types/auth/AuthState';
+import { AuthAction, AuthTokenAction, AuthTokenSuccessAction } from '../actions/AuthAction';
+/**
+ * Reducer for updating `auth` in redux.
+ */
+export default function authReducer(state: AuthState | undefined, action: AuthAction | AuthTokenAction | AuthTokenSuccessAction): AuthState;

package/lib/redux/reducers/authReducer.js

@@ -1,40 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var actions_1 = require("../actions");
+var AuthAction_1 = require("../actions/AuthAction");
 var initialState = {
     isInitialized: false,
     isAuthenticating: false,
     isAuthenticated: false,
     didFail: false
 };
+/**
+ * Reducer for updating `auth` in redux.
+ */
 function authReducer(state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
-        case actions_1.AUTH_ACTION.AUTH_INITIALIZED:
+        case AuthAction_1.AUTH_TOKEN_ACTION_TYPE.AUTH_INITIALIZED:
             return Object.assign({}, state, {
                 isInitialized: true,
                 isAuthenticated: !!action.oauthToken
             });
-        case actions_1.AUTH_ACTION.GET_TOKEN_SUCCEEDED:
-        case actions_1.AUTH_ACTION.TOKEN_REFRESH_SUCCEEDED:
+        case AuthAction_1.AUTH_TOKEN_SUCCESS_ACTION_TYPE.GET_TOKEN_SUCCEEDED:
+        case AuthAction_1.AUTH_TOKEN_SUCCESS_ACTION_TYPE.TOKEN_REFRESH_SUCCEEDED:
             return Object.assign({}, state, {
                 isAuthenticating: false,
                 isAuthenticated: true,
                 didFail: false
             });
-        case actions_1.AUTH_ACTION.LOGIN_REQUESTED:
+        case AuthAction_1.AUTH_ACTION_TYPE.LOGIN_REQUESTED:
             return Object.assign({}, state, {
                 isAuthenticating: true,
                 isAuthenticated: false,
                 didFail: false
             });
-        case actions_1.AUTH_ACTION.LOG_OUT_REQUESTED:
+        case AuthAction_1.AUTH_ACTION_TYPE.LOG_OUT_REQUESTED:
             return Object.assign({}, state, {
                 isAuthenticating: false,
                 isAuthenticated: false,
                 didFail: false
             });
-        case actions_1.AUTH_ACTION.LOGIN_FAILED:
+        case AuthAction_1.AUTH_ACTION_TYPE.LOGIN_FAILED:
             return Object.assign({}, state, {
                 isAuthenticating: false,
                 isAuthenticated: false,

package/lib/redux/reducers/index.d.ts

@@ -1,6 +1,6 @@
 import authReducer from './authReducer';
-import fetchReducer from './fetchReducer';
 import modalsReducer from './modalsReducer';
+import modelsReducer from './modelsReducer';
 import notificationsReducer from './notificationsReducer';
 import searchReducer from './searchReducer';
-export { authReducer, fetchReducer, modalsReducer, notificationsReducer, searchReducer };
+export { authReducer, modelsReducer, modalsReducer, notificationsReducer, searchReducer };

package/lib/redux/reducers/index.js

@@ -3,13 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.searchReducer = exports.notificationsReducer = exports.modalsReducer = exports.fetchReducer = exports.authReducer = void 0;
+exports.searchReducer = exports.notificationsReducer = exports.modalsReducer = exports.modelsReducer = exports.authReducer = void 0;
 var authReducer_1 = __importDefault(require("./authReducer"));
 exports.authReducer = authReducer_1.default;
-var fetchReducer_1 = __importDefault(require("./fetchReducer"));
-exports.fetchReducer = fetchReducer_1.default;
 var modalsReducer_1 = __importDefault(require("./modalsReducer"));
 exports.modalsReducer = modalsReducer_1.default;
+var modelsReducer_1 = __importDefault(require("./modelsReducer"));
+exports.modelsReducer = modelsReducer_1.default;
 var notificationsReducer_1 = __importDefault(require("./notificationsReducer"));
 exports.notificationsReducer = notificationsReducer_1.default;
 var searchReducer_1 = __importDefault(require("./searchReducer"));

package/lib/redux/reducers/modalsReducer.d.ts

@@ -1,12 +1,9 @@
 import { Dictionary } from 'lodash';
-import { Action } from 'redux';
+import { ModalAction } from '../actions/ModalAction';
 export interface ModalActionValue {
     index: number;
     isFullscreen: boolean;
 }
-export interface ModalAction extends Action, ModalActionValue {
-    guid: string;
-}
 export interface ModalsState extends Dictionary<ModalActionValue> {
 }
 export default function modalsReducer(state: ModalsState | undefined, action: ModalAction): ModalsState;

package/lib/redux/reducers/modalsReducer.js

@@ -22,7 +22,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var actions_1 = require("../actions");
+var ModalAction_1 = require("../actions/ModalAction");
 /// state is a dictionary where keys are modal guids, for easy lookup
 var initialState = {};
 function modalsReducer(state, action) {
@@ -32,7 +32,7 @@ function modalsReducer(state, action) {
     var index;
     var isFullscreen;
     switch (action.type) {
-        case actions_1.ACTION.MODAL_ENTERING: {
+        case ModalAction_1.MODAL_ACTION_TYPE.MODAL_ENTERING: {
             guid = action.guid;
             index = action.index;
             isFullscreen = action.isFullscreen;
@@ -42,7 +42,7 @@ function modalsReducer(state, action) {
             var newState = __assign(__assign({}, state), (_a = {}, _a["" + guid] = { index: index, isFullscreen: isFullscreen }, _a));
             return newState;
         }
-        case actions_1.ACTION.MODAL_EXITED: {
+        case ModalAction_1.MODAL_ACTION_TYPE.MODAL_EXITED: {
             guid = action.guid;
             if (!state[guid]) {
                 return state;