studiokit-scaffolding-js 4.5.1 → 4.5.2

package/lib/components/HOC/ActivityRequiredComponent.d.ts

@@ -4,6 +4,7 @@ import { BaseReduxState, OptionalRecord } from '../../types';
 import { ActivityOptions } from '../../utils/baseActivity';
 export interface ActivityRequiredStateProps {
     hasAccess: boolean;
+    redirectPath: string;
 }
 export declare const configureActivityRequiredComponent: <TOwnProps extends {}>(WrappedComponent: React.ComponentType<TOwnProps>) => {
     new (props: (TOwnProps & ActivityRequiredStateProps) | Readonly<TOwnProps & ActivityRequiredStateProps>): {
@@ -60,15 +61,14 @@ export declare const configureActivityRequiredComponent: <TOwnProps extends {}>(
 };
 /**
  * Return `mapStateToProps` function. Add a `hasAccess` boolean property to the component's props
- * checking whether the user has the passed `requiredActivity`
+ * checking whether the user has the passed `requiredActivity`.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty (Optional) The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty?: string | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
+export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty?: string | undefined, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
 /**
  * This HOC ensures that the wrapped component is only rendered if the predicate provided is satisfied.
  *
@@ -78,15 +78,14 @@ export declare const configureMapStateToProps: <TOwnProps extends {}>(accessPred
  * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
  * parameter. It can be ignored if not needed by the lambda.
  *
- * @param {Component} WrappedComponent The component which requires activity/activities in order to render
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function activityRequiredComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string): ComponentClass<TOwnProps>;
+export default function activityRequiredComponent<TOwnProps extends {}>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined): ComponentClass<TOwnProps>;
 /**
- * This HOC ensures that the wrapped component is rendered iff the predicate provided is satisfied.
+ * This HOC ensures that the wrapped component is rendered if the predicate provided is satisfied.
  *
  * Typically this component is used by passing one of the functions in utils/activities as the
  * `accessPredicate` and a constant from "constants/activities" as the `requiredActivity`.
@@ -94,12 +93,10 @@ export default function activityRequiredComponent<TOwnProps extends {}>(WrappedC
  * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
  * and `modelsProperty` parameters. They can be ignored if not needed by the lambda.
  *
- * @param {Component} WrappedComponent The component which requires activity/activities in order to render
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
- *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function activityRequiredComponent<TOwnProps extends {}, TPropName extends string>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string, modelsProperty: TPropName): ComponentClass<TOwnProps & OptionalRecord<TPropName, Model>>;
+export default function activityRequiredComponent<TOwnProps extends {}, TPropName extends string>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, modelsProperty: TPropName, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined): ComponentClass<TOwnProps & OptionalRecord<TPropName, Model>>;

package/lib/components/HOC/ActivityRequiredComponent.js

@@ -66,9 +66,9 @@ var configureActivityRequiredComponent = function (WrappedComponent) {
             return _super !== null && _super.apply(this, arguments) || this;
         }
         ActivityRequiredComponent.prototype.render = function () {
-            var _a = this.props, hasAccess = _a.hasAccess, rest = __rest(_a, ["hasAccess"]);
-            if (!this.props.hasAccess) {
-                return react_1.default.createElement(react_router_dom_1.Redirect, { to: '/' });
+            var _a = this.props, hasAccess = _a.hasAccess, redirectPath = _a.redirectPath, rest = __rest(_a, ["hasAccess", "redirectPath"]);
+            if (!hasAccess) {
+                return react_1.default.createElement(react_router_dom_1.Redirect, { to: redirectPath });
             }
             return react_1.default.createElement(WrappedComponent, __assign({}, rest));
         };
@@ -78,23 +78,39 @@ var configureActivityRequiredComponent = function (WrappedComponent) {
 exports.configureActivityRequiredComponent = configureActivityRequiredComponent;
 /**
  * Return `mapStateToProps` function. Add a `hasAccess` boolean property to the component's props
- * checking whether the user has the passed `requiredActivity`
+ * checking whether the user has the passed `requiredActivity`.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
- * @param {string} modelsProperty The property used to locate the entity or entities needed for entity-level
- * activity grants
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty (Optional) The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-var configureMapStateToProps = function (accessPredicate, requiredActivity, modelsProperty) { return function (state, ownProps) {
+var configureMapStateToProps = function (accessPredicate, requiredActivity, modelsProperty, redirectPath) { return function (state, ownProps) {
+    var options = baseActivity_1.defaultOptions(state, ownProps, modelsProperty);
     return {
-        hasAccess: accessPredicate(requiredActivity, baseActivity_1.defaultOptions(state, ownProps, modelsProperty))
+        hasAccess: accessPredicate(requiredActivity, options),
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
-function activityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, modelsProperty) {
+/**
+ * This HOC ensures that the wrapped component is rendered if the predicate provided is satisfied.
+ *
+ * Typically this component is used by passing one of the functions in utils/activities as the
+ * `accessPredicate` and a constant from "constants/activities" as the `requiredActivity`.
+ *
+ * If a lambda is passed as the predicate, it is passed (but may or may not opt to utilize) the `requiredActivity`
+ * and `modelsProperty` parameters. They can be ignored if not needed by the lambda.
+ *
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param modelsProperty The property used to locate the entity or entities needed for entity-level activity grants
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
+ */
+function activityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, modelsProperty, redirectPath) {
     var ActivityRequiredComponent = exports.configureActivityRequiredComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, modelsProperty);
+    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, modelsProperty, redirectPath);
     // @ts-ignore: could not match inferred type from the `connect` HOC
     return react_redux_1.connect(mapStateToProps)(ActivityRequiredComponent);
 }

package/lib/components/HOC/CollectionComponent.js

@@ -123,11 +123,11 @@ function configureCollectionComponent(WrappedComponent, LoaderComponent) {
             collection_1.initializeCollection(model, this.load, this.getCollectionMethodConfig());
         };
         CollectionComponent.prototype.componentDidUpdate = function (prevProps) {
-            var prevModel = prevProps.model, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
-            var _a = this.props, model = _a.model, pathParams = _a.pathParams, queryParams = _a.queryParams;
+            var prevModel = prevProps.model, prevModelName = prevProps.modelName, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
+            var _a = this.props, model = _a.model, modelName = _a.modelName, pathParams = _a.pathParams, queryParams = _a.queryParams;
             var fetchingId = this.state.fetchingId;
             model_1.handleModelFetchFinish(model, prevModel, fetchingId, this.changeModelStatus);
-            collection_1.handleCollectionParamsChange(pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
+            collection_1.handleCollectionParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
         };
         CollectionComponent.prototype.componentWillUnmount = function () {
             var model = this.props.model;

package/lib/components/HOC/CollectionItemComponent.js

@@ -125,10 +125,10 @@ function configureCollectionItemComponent(WrappedComponent, LoaderComponent) {
             collection_1.initializeCollectionItem(model, this.load, this.getCollectionMethodConfig());
         };
         CollectionItemComponent.prototype.componentDidUpdate = function (prevProps) {
-            var prevModel = prevProps.model, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
+            var prevModel = prevProps.model, prevModelName = prevProps.modelName, prevPathParams = prevProps.pathParams, prevQueryParams = prevProps.queryParams;
             var _a = this.props, modelName = _a.modelName, model = _a.model, pathParams = _a.pathParams, queryParams = _a.queryParams;
             model_1.handleModelFetchFinish(model, prevModel, undefined, this.setModelStatus);
-            collection_1.handleCollectionItemParamsChange(modelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
+            collection_1.handleCollectionItemParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, this.load);
         };
         CollectionItemComponent.prototype.render = function () {
             var _a = this.props, history = _a.history, match = _a.match, location = _a.location, staticContext = _a.staticContext, otherProps = __rest(_a, ["history", "match", "location", "staticContext"]);

package/lib/components/HOC/GroupActivityRequiredComponent.d.ts

@@ -15,15 +15,18 @@ export interface GroupRelatedEntity extends Model {
  * checking whether the user has the passed `requiredActivity` for the group referenced by
  * `ownProps.model.groupId`, if any.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export declare const configureMapStateToProps: <TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
+export declare const configureMapStateToProps: <TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(accessPredicate: (requiredActivity: string, options: ActivityOptions) => boolean, requiredActivity: string, redirectPath?: string | ((options: ActivityOptions) => string | undefined) | undefined) => (state: BaseReduxState, ownProps?: TOwnProps | undefined) => ActivityRequiredStateProps;
 /**
  * This HOC ensures that the wrapped component is only rendered if the group referenced by
  * `props.model.groupId`, if any, satisfies the `accessPredicate` for the `requiredActivity`.
  *
- * @see ActivityRequiredComponent
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-export default function groupActivityRequiredComponent<TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string): ComponentClass<TOwnProps>;
+export default function groupActivityRequiredComponent<TOwnProps extends CollectionItemComponentWrappedProps<GroupRelatedEntity>>(WrappedComponent: ComponentType<TOwnProps>, accessPredicate: (requiredActivity: string, options: any) => boolean, requiredActivity: string, redirectPath?: string | undefined | ((options: ActivityOptions) => string | undefined)): ComponentClass<TOwnProps>;

package/lib/components/HOC/GroupActivityRequiredComponent.js

@@ -20,17 +20,18 @@ var ActivityRequiredComponent_1 = require("./ActivityRequiredComponent");
  * checking whether the user has the passed `requiredActivity` for the group referenced by
  * `ownProps.model.groupId`, if any.
  *
- * @param {function} accessPredicate A predicate accepting a required activity and an optional entity and/or
- * 		userInfo object
- * @param {string} requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-var configureMapStateToProps = function (accessPredicate, requiredActivity) { return function (state, ownProps) {
+var configureMapStateToProps = function (accessPredicate, requiredActivity, redirectPath) { return function (state, ownProps) {
     var entity = ownProps && ownProps.model && state.models && state.models.groups
         ? state.models.groups[ownProps.model.groupId]
         : undefined;
     var options = __assign(__assign({}, baseActivity_1.defaultOptions(state, ownProps)), { entity: entity });
     return {
-        hasAccess: accessPredicate(requiredActivity, options)
+        hasAccess: accessPredicate(requiredActivity, options),
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
@@ -38,11 +39,14 @@ exports.configureMapStateToProps = configureMapStateToProps;
  * This HOC ensures that the wrapped component is only rendered if the group referenced by
  * `props.model.groupId`, if any, satisfies the `accessPredicate` for the `requiredActivity`.
  *
- * @see ActivityRequiredComponent
+ * @param WrappedComponent The component which requires activity/activities in order to render
+ * @param accessPredicate A predicate accepting a required activity and an optional entity and/or userInfo object
+ * @param requiredActivity The required activity which is passed to the predicate for evaluation
+ * @param redirectPath (Optional) A string or function that provides the redirect path for when `accessPredicate` is false. Defaults to '/'.
  */
-function groupActivityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity) {
+function groupActivityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, redirectPath) {
     var ActivityRequiredComponent = ActivityRequiredComponent_1.configureActivityRequiredComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity);
+    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, redirectPath);
     // @ts-ignore: could not match inferred type from the `connect` HOC
     return react_redux_1.connect(mapStateToProps)(ActivityRequiredComponent);
 }

package/lib/components/UserRoles/index.d.ts

@@ -39,8 +39,12 @@ export interface UserRolesOwnProps extends CollectionComponentWrappedProps<UserR
     externalProviders?: ModelCollection<ExternalProvider>;
     /** (Optional) Allow users to be excluded from being displayed in the table */
     filterUsers?: (users: UserWithRoles[]) => UserWithRoles[];
-    /** (Optional) Callback that is called after any change is made */
-    onChange?: () => void;
+    /** (Optional) Callback that is called after user roles are added */
+    onAdd?: (userRoles: UserRole[]) => void;
+    /** (Optional) Callback that is called after a user role is updated */
+    onUpdate?: (userRole: UserRole, role: string) => void;
+    /** (Optional) Callback that is called after a user role is removed */
+    onRemove?: (userRole: UserRole) => void;
     /** (Optional) Render custom components between the Add and Table components */
     renderTableDescription?: (canModify?: boolean) => JSX.Element;
     /** (Optional) Render custom components at the start of the Add component */
@@ -100,5 +104,5 @@ export declare class UserRoles extends Component<UserRolesProps, UserRolesState>
     render(): JSX.Element;
 }
 export declare const mapStateToProps: (state: BaseReduxState, ownProps: UserRolesOwnProps) => UserRolesReduxProps;
-declare const _default: import("react-redux").ConnectedComponent<typeof UserRoles, Pick<React.ClassAttributes<UserRoles> & UserRolesProps, "externalProviders" | "model" | "ref" | "onChange" | "key" | "guid" | "load" | "modelName" | "pathParams" | "modelStatus" | "queryParams" | "disableAutoLoad" | "modelArray" | "stopPeriodicLoad" | "create" | "update" | "delete" | "previousModelStatus" | "fetchingId" | "textForRole" | "entityName" | "defaultRole" | "roleDescriptions" | "renderAddDescription" | "isUpdateDisabled" | "isDeleteDisabled" | "allowMultipleRoles" | "requiredRole" | "isAddDisabled" | "modifyUserRoleActivityName" | "deleteOwnUserRoleActivityName" | "addRoleExcludeList" | "entity" | "filterUsers" | "renderTableDescription" | "singularArticleForRole"> & UserRolesOwnProps>;
+declare const _default: import("react-redux").ConnectedComponent<typeof UserRoles, Pick<React.ClassAttributes<UserRoles> & UserRolesProps, "externalProviders" | "model" | "ref" | "key" | "guid" | "load" | "modelName" | "pathParams" | "modelStatus" | "queryParams" | "disableAutoLoad" | "modelArray" | "stopPeriodicLoad" | "create" | "update" | "delete" | "previousModelStatus" | "fetchingId" | "textForRole" | "entityName" | "defaultRole" | "roleDescriptions" | "renderAddDescription" | "isUpdateDisabled" | "isDeleteDisabled" | "allowMultipleRoles" | "requiredRole" | "isAddDisabled" | "modifyUserRoleActivityName" | "deleteOwnUserRoleActivityName" | "addRoleExcludeList" | "entity" | "filterUsers" | "onAdd" | "onUpdate" | "onRemove" | "renderTableDescription" | "singularArticleForRole"> & UserRolesOwnProps>;
 export default _default;

package/lib/components/UserRoles/index.js

@@ -136,7 +136,7 @@ var UserRoles = /** @class */ (function (_super) {
             });
         };
         _this.didAdd = function (data) {
-            var _a = _this.props, entityName = _a.entityName, onChange = _a.onChange, model = _a.model, modelName = _a.modelName, pathParams = _a.pathParams;
+            var _a = _this.props, entityName = _a.entityName, onAdd = _a.onAdd, model = _a.model, modelName = _a.modelName, pathParams = _a.pathParams;
             var _b = _this.state, roleForAdd = _b.roleForAdd, identifiersToAdd = _b.identifiersToAdd;
             if (!roleForAdd || !identifiersToAdd || identifiersToAdd.length === 0) {
                 throw new Error('didAdd was called in the incorrect state');
@@ -209,8 +209,8 @@ var UserRoles = /** @class */ (function (_super) {
                     modelName: prepareFetchResult.modelName,
                     data: updatedModel_1
                 });
-                if (onChange) {
-                    onChange();
+                if (onAdd) {
+                    onAdd(addedUserRoles);
                 }
             }
         };
@@ -233,7 +233,7 @@ var UserRoles = /** @class */ (function (_super) {
             });
         };
         _this.didUpdate = function (isSuccess) {
-            var _a = _this.props, entityName = _a.entityName, onChange = _a.onChange;
+            var _a = _this.props, entityName = _a.entityName, onUpdate = _a.onUpdate;
             var _b = _this.state, userRoleToUpdate = _b.userRoleToUpdate, roleForUpdate = _b.roleForUpdate;
             if (userRoleToUpdate === undefined) {
                 throw new Error('`didUpdate` was called without setting `userRoleToUpdate` in state');
@@ -255,15 +255,15 @@ var UserRoles = /** @class */ (function (_super) {
                 return;
             }
             var successMessage = name + " was successfully updated to " + singularArticleString + " " + roleString + (entityName ? " in your " + entityName : '') + ".";
+            if (onUpdate) {
+                onUpdate(userRoleToUpdate, roleForUpdate);
+            }
             _this.setState({
                 isUpdating: false,
                 userRoleToUpdate: undefined,
                 roleForUpdate: undefined,
                 successMessage: successMessage
             });
-            if (onChange) {
-                onChange();
-            }
         };
         //#endregion Update
         //#region Remove User
@@ -333,7 +333,7 @@ var UserRoles = /** @class */ (function (_super) {
             });
         };
         _this.didRemove = function (isSuccess) {
-            var _a = _this.props, entityName = _a.entityName, onChange = _a.onChange;
+            var _a = _this.props, entityName = _a.entityName, onRemove = _a.onRemove;
             var userRoleToRemove = _this.state.userRoleToRemove;
             if (userRoleToRemove === undefined) {
                 throw new Error('`didRemove` was called without setting `userRoleToRemove` in state');
@@ -349,14 +349,14 @@ var UserRoles = /** @class */ (function (_super) {
                 return;
             }
             var successMessage = name + " was successfully removed" + (entityName ? " from your " + entityName : '') + ".";
+            if (onRemove) {
+                onRemove(userRoleToRemove);
+            }
             _this.setState({
                 isRemoving: false,
                 userRoleToRemove: undefined,
                 successMessage: successMessage
             });
-            if (onChange) {
-                onChange();
-            }
         };
         return _this;
     }

package/lib/hooks/useCollection.js

@@ -8,7 +8,7 @@ function useCollection(props) {
     var modelName = props.modelName;
     // state, route, and redux
     var config = useCollectionConfiguration_1.useCollectionConfiguration(props, collection_1.selectCollectionFromState);
-    var guid = config.guid, model = config.model, pathParams = config.pathParams, previousPathParams = config.previousPathParams, queryParams = config.queryParams, previousQueryParams = config.previousQueryParams, fetchingId = config.fetchingId, modelStatus = config.modelStatus, previousModelStatus = config.previousModelStatus, isInitialized = config.isInitialized, setIsInitialized = config.setIsInitialized, methodConfig = config.methodConfig, modelArray = config.modelArray;
+    var previousModelName = config.previousModelName, guid = config.guid, model = config.model, pathParams = config.pathParams, previousPathParams = config.previousPathParams, queryParams = config.queryParams, previousQueryParams = config.previousQueryParams, fetchingId = config.fetchingId, modelStatus = config.modelStatus, previousModelStatus = config.previousModelStatus, isInitialized = config.isInitialized, setIsInitialized = config.setIsInitialized, methodConfig = config.methodConfig, modelArray = config.modelArray;
     // decorated methods
     var load = react_1.useCallback(function (params) {
         if (params === void 0) { params = {}; }
@@ -35,8 +35,8 @@ function useCollection(props) {
     }, [isInitialized, load, methodConfig, model, setIsInitialized]);
     // re-load if `pathParams` or `queryParams` change
     react_1.useEffect(function () {
-        collection_1.handleCollectionParamsChange(pathParams, previousPathParams, queryParams, previousQueryParams, load);
-    }, [load, modelName, pathParams, previousPathParams, previousQueryParams, queryParams]);
+        collection_1.handleCollectionParamsChange(modelName, previousModelName, pathParams, previousPathParams, queryParams, previousQueryParams, load);
+    }, [load, modelName, pathParams, previousModelName, previousPathParams, previousQueryParams, queryParams]);
     // cleanup on unmount
     react_1.useEffect(function () {
         return function cleanup() {

package/lib/hooks/useCollectionConfiguration.d.ts

@@ -4,6 +4,7 @@ import { Model, ModelCollection } from 'studiokit-net-js';
 import { CollectionCommonProps, CollectionCommonState, CollectionMethodConfiguration, CollectionSelectorMethod } from '../types/Collection';
 /** Configuration returned by `useCollectionConfiguration` for use in `useCollection` and `useCollectionItem` */
 export interface CollectionConfiguration<TModel extends Model> extends CollectionCommonState {
+    previousModelName: string;
     guid: string;
     model: TModel | ModelCollection<TModel>;
     modelArray?: TModel[];

package/lib/hooks/useCollectionConfiguration.js

@@ -26,6 +26,7 @@ function useCollectionConfiguration(props, selectorFunction) {
     var _d = react_redux_1.useSelector(function (state) {
         return selectorFunction({ guid: guid, modelName: modelName, pathParams: propPathParams, routeMatchParams: routeMatchParams, state: state });
     }), pathParams = _d.pathParams, model = _d.model, modelArray = _d.modelArray, modelMinusRelations = _d.modelMinusRelations;
+    var previousModelName = usePrevious_1.usePrevious(modelName);
     var previousModel = usePrevious_1.usePrevious(model);
     var previousPathParams = usePrevious_1.usePrevious(pathParams);
     var previousQueryParams = usePrevious_1.usePrevious(queryParams);
@@ -47,6 +48,7 @@ function useCollectionConfiguration(props, selectorFunction) {
         model_1.handleModelFetchFinish(model, previousModel, fetchingId, changeModelStatus);
     }, [fetchingId, model, previousModel]);
     return {
+        previousModelName: previousModelName,
         guid: guid,
         model: model,
         modelArray: modelArray,

package/lib/hooks/useCollectionItem.js

@@ -8,7 +8,7 @@ function useCollectionItem(props) {
     var modelName = props.modelName;
     // state, route, and redux
     var config = useCollectionConfiguration_1.useCollectionConfiguration(props, collection_1.selectCollectionItemFromState);
-    var guid = config.guid, model = config.model, pathParams = config.pathParams, previousPathParams = config.previousPathParams, queryParams = config.queryParams, previousQueryParams = config.previousQueryParams, modelStatus = config.modelStatus, previousModelStatus = config.previousModelStatus, isInitialized = config.isInitialized, setIsInitialized = config.setIsInitialized, methodConfig = config.methodConfig, modelMinusRelations = config.modelMinusRelations;
+    var previousModelName = config.previousModelName, guid = config.guid, model = config.model, pathParams = config.pathParams, previousPathParams = config.previousPathParams, queryParams = config.queryParams, previousQueryParams = config.previousQueryParams, modelStatus = config.modelStatus, previousModelStatus = config.previousModelStatus, isInitialized = config.isInitialized, setIsInitialized = config.setIsInitialized, methodConfig = config.methodConfig, modelMinusRelations = config.modelMinusRelations;
     // decorated methods
     var load = react_1.useCallback(function (params) {
         if (params === void 0) { params = {}; }
@@ -36,8 +36,8 @@ function useCollectionItem(props) {
     }, [isInitialized, load, methodConfig, model, setIsInitialized]);
     // re-load if `pathParams` or `queryParams` change
     react_1.useEffect(function () {
-        collection_1.handleCollectionItemParamsChange(modelName, pathParams, previousPathParams, queryParams, previousQueryParams, load);
-    }, [load, modelName, pathParams, previousPathParams, previousQueryParams, queryParams]);
+        collection_1.handleCollectionItemParamsChange(modelName, previousModelName, pathParams, previousPathParams, queryParams, previousQueryParams, load);
+    }, [load, modelName, pathParams, previousModelName, previousPathParams, previousQueryParams, queryParams]);
     return {
         guid: guid,
         model: model,

package/lib/utils/collection.d.ts

@@ -32,11 +32,11 @@ export declare function initializeCollection(model: Model, load: (params?: Colle
 /**
  * When `pathParams` or `queryParams` change, call `load`
  */
-export declare function handleCollectionItemParamsChange(modelName: string, pathParams: string[], prevPathParams: string[] | undefined, queryParams: Dictionary<string> | undefined, prevQueryParams: Dictionary<string> | undefined, load: (params?: CollectionItemLoadParams) => void): void;
+export declare function handleCollectionItemParamsChange(modelName: string, prevModelName: string, pathParams: string[], prevPathParams: string[] | undefined, queryParams: Dictionary<string> | undefined, prevQueryParams: Dictionary<string> | undefined, load: (params?: CollectionItemLoadParams) => void): void;
 /**
  * When `pathParams` or `queryParams` change, call `load`
  */
-export declare function handleCollectionParamsChange(pathParams: string[], prevPathParams: string[] | undefined, queryParams: Dictionary<string> | undefined, prevQueryParams: Dictionary<string> | undefined, load: (params?: CollectionLoadParams) => void): void;
+export declare function handleCollectionParamsChange(modelName: string, prevModelName: string, pathParams: string[], prevPathParams: string[] | undefined, queryParams: Dictionary<string> | undefined, prevQueryParams: Dictionary<string> | undefined, load: (params?: CollectionLoadParams) => void): void;
 /**
  * Delete the guid in the model
  */

package/lib/utils/collection.js

@@ -291,8 +291,9 @@ exports.initializeCollection = initializeCollection;
 /**
  * When `pathParams` or `queryParams` change, call `load`
  */
-function handleCollectionItemParamsChange(modelName, pathParams, prevPathParams, queryParams, prevQueryParams, load) {
-    if ((pathParams.length === route_1.getMinRequiredPathParamsCount(modelName) + 1 && !lodash_1.isEqual(prevPathParams, pathParams)) ||
+function handleCollectionItemParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, load) {
+    if (modelName !== prevModelName ||
+        (pathParams.length === route_1.getMinRequiredPathParamsCount(modelName) + 1 && !lodash_1.isEqual(prevPathParams, pathParams)) ||
         !lodash_1.isEqual(prevQueryParams, queryParams)) {
         load({ pathParams: pathParams, queryParams: queryParams });
     }
@@ -301,8 +302,10 @@ exports.handleCollectionItemParamsChange = handleCollectionItemParamsChange;
 /**
  * When `pathParams` or `queryParams` change, call `load`
  */
-function handleCollectionParamsChange(pathParams, prevPathParams, queryParams, prevQueryParams, load) {
-    if ((pathParams.length > 0 && !lodash_1.isEqual(prevPathParams, pathParams)) || !lodash_1.isEqual(prevQueryParams, queryParams)) {
+function handleCollectionParamsChange(modelName, prevModelName, pathParams, prevPathParams, queryParams, prevQueryParams, load) {
+    if (modelName !== prevModelName ||
+        (pathParams.length > 0 && !lodash_1.isEqual(prevPathParams, pathParams)) ||
+        !lodash_1.isEqual(prevQueryParams, queryParams)) {
         load({ pathParams: pathParams, queryParams: queryParams });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "studiokit-scaffolding-js",
-	"version": "4.5.1",
+	"version": "4.5.2",
 	"description": "Common scaffolding for Studio apps at Purdue",
 	"repository": "https://gitlab.com/purdue-informatics/studiokit/studiokit-scaffolding-js",
 	"license": "MIT",