studiokit-scaffolding-js 4.5.1-next.1.3 → 4.5.2

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

@@ -61,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, redirectPredicate?: ((options: ActivityOptions) => string | undefined) | 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.
  *
@@ -79,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: ActivityOptions) => boolean, requiredActivity: string, redirectPredicate?: (options: ActivityOptions) => string | undefined): 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`.
@@ -95,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: ActivityOptions) => boolean, requiredActivity: string, modelsProperty: TPropName, redirectPredicate?: (options: ActivityOptions) => string): 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

@@ -78,26 +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, redirectPredicate) { return function (state, ownProps) {
-    var _a;
+var configureMapStateToProps = function (accessPredicate, requiredActivity, modelsProperty, redirectPath) { return function (state, ownProps) {
     var options = baseActivity_1.defaultOptions(state, ownProps, modelsProperty);
     return {
         hasAccess: accessPredicate(requiredActivity, options),
-        redirectPath: redirectPredicate ? (_a = redirectPredicate(options)) !== null && _a !== void 0 ? _a : '/' : '/'
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
-function activityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, modelsProperty, redirectPredicate) {
+/**
+ * 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, redirectPredicate);
+    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, redirectPredicate?: ((options: ActivityOptions) => string | undefined) | undefined) => (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, redirectPredicate?: (options: ActivityOptions) => string | undefined): 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,19 +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, redirectPredicate) { return function (state, ownProps) {
-    var _a;
+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),
-        redirectPath: redirectPredicate ? (_a = redirectPredicate(options)) !== null && _a !== void 0 ? _a : '/' : '/'
+        redirectPath: (typeof redirectPath === 'function' ? redirectPath(options) : redirectPath) || '/'
     };
 }; };
 exports.configureMapStateToProps = configureMapStateToProps;
@@ -40,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, redirectPredicate) {
+function groupActivityRequiredComponent(WrappedComponent, accessPredicate, requiredActivity, redirectPath) {
     var ActivityRequiredComponent = ActivityRequiredComponent_1.configureActivityRequiredComponent(WrappedComponent);
-    var mapStateToProps = exports.configureMapStateToProps(accessPredicate, requiredActivity, redirectPredicate);
+    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/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-next.1.3",
+	"version": "4.5.2",
 	"description": "Common scaffolding for Studio apps at Purdue",
 	"repository": "https://gitlab.com/purdue-informatics/studiokit/studiokit-scaffolding-js",
 	"license": "MIT",