studiokit-scaffolding-js 4.3.21 → 4.3.22

package/lib/utils/baseActivity.js

@@ -1,155 +1,155 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultOptions = exports.canPerformActivityGloballyOrOnSomeEntities = exports.canPerformActivityGloballyOrOnEntity = exports.canPerformActivityGlobally = exports.canPerformActivityOnSomeEntities = exports.canPerformActivityOnEntity = void 0;
-var lodash_1 = __importDefault(require("lodash"));
-var model_1 = require("./model");
-/*
-    The functions in this module all are designed as predicates to determine whether a
-    user has been granted a set of activities to perform, either at an entity-specific
-    level or at a global level.
-
-    Because Javascript doesn’t have named parameters, we use an 'options object' to
-    pass the needed items. By ensuring all these functions have the same signature,
-    we can use them interchangeably in constructing the ActivityRequiredComponent.
-
-    The options object has the following structure:
-    {
-        entities: {
-            {
-                1: {
-                        activities: [
-                            "activityName1",
-                            "activityName2"
-                            ...
-                        ]
-                    },
-                    ...
-            }
-        },
-        entity: {
-                activities: [
-                    "activityName1",
-                    "activityName2"
-                    ...
-                ]
-        }
-        userInfo: {
-            activities: [
-                "activityName1",
-                "activityName2",
-                ...
-            ]
-        }
-    }
-
-    `entity` is a single entity and `entities` is a set of entities to which a user has been granted a set of activities.
-    While we could use the array of entities and eliminate the need for the entity property, the singular property will be
-    used in most cases and it prevents to the need to stuff the entity in an array unnecessarily.
-
-    `userInfo` contains a property with an array of activities the user has been granted at a global level
-*/
-/**
- * Return true if user has activity for the single entity
- *
- * @param {string} requiredActivity The activity required to return true
- * @param {object} options See above
- */
-var canPerformActivityOnEntity = function (requiredActivity, options) {
-    if (!requiredActivity) {
-        throw new Error('`requiredActivity` must be provided');
-    }
-    if (!options || !options.entity) {
-        throw new Error('`options.entity` must be provided');
-    }
-    return lodash_1.default.includes(options.entity.activities, requiredActivity);
-};
-exports.canPerformActivityOnEntity = canPerformActivityOnEntity;
-/**
- * Return true if user has activity on any of the entities
- *
- * @param {string} requiredActivity The activity required to return true
- * @param {object} options See above
- */
-var canPerformActivityOnSomeEntities = function (requiredActivity, options) {
-    if (!requiredActivity) {
-        throw new Error('`requiredActivity` must be provided');
-    }
-    if (!options || !options.entities) {
-        throw new Error('`options.entities` must be provided');
-    }
-    return lodash_1.default.some(model_1.getModelArray(options.entities), function (entity) { return exports.canPerformActivityOnEntity(requiredActivity, { entity: entity }); });
-};
-exports.canPerformActivityOnSomeEntities = canPerformActivityOnSomeEntities;
-/**
- * Return true if user has activity globally
- *
- * This function can accept an null/undefined userInfo property for the
- * options argument. In which case it returns false. This is because userInfo
- * may not be loaded yet. If it is provided however, it must contain an
- * activities array
- *
- * @param {string} requiredActivity The activity required to return true
- * @param {object} options See above
- */
-var canPerformActivityGlobally = function (requiredActivity, options) {
-    if (!requiredActivity) {
-        throw new Error('`requiredActivity` must be provided');
-    }
-    if (!!options &&
-        !!options.userInfo &&
-        !!options.userInfo.activities &&
-        !Array.isArray(options.userInfo.activities)) {
-        throw new Error('`options.userInfo.activities` must be an array');
-    }
-    return (!!options &&
-        !!options.userInfo &&
-        !!options.userInfo.activities &&
-        lodash_1.default.includes(options.userInfo.activities, requiredActivity));
-};
-exports.canPerformActivityGlobally = canPerformActivityGlobally;
-/**
- * Return true if user has activity either globally or on a single entity
- *
- * @param {string} requiredActivity The activity required to return true
- * @param {object} options See above
- */
-var canPerformActivityGloballyOrOnEntity = function (requiredActivity, options) {
-    return exports.canPerformActivityGlobally(requiredActivity, options) || exports.canPerformActivityOnEntity(requiredActivity, options);
-};
-exports.canPerformActivityGloballyOrOnEntity = canPerformActivityGloballyOrOnEntity;
-/**
- * Return true if user has activity globally or on any of the entities provided
- *
- * @param {string} requiredActivity The activity required to return true
- * @param {object} options See above
- */
-var canPerformActivityGloballyOrOnSomeEntities = function (requiredActivity, options) {
-    return (exports.canPerformActivityGlobally(requiredActivity, options) ||
-        exports.canPerformActivityOnSomeEntities(requiredActivity, options));
-};
-exports.canPerformActivityGloballyOrOnSomeEntities = canPerformActivityGloballyOrOnSomeEntities;
-/**
- * Return an options object that can be used in the functions in this module. This
- * encapsulates the default logic of looking in state for a set of entities or
- * looking in props for a single entity.
- *
- * Override or decorate with app specific logic in your app if needed.
- *
- * @param {Object} state The redux state
- * @param {Object} [props] A props object (typically ownProps)
- * @param {string} [modelsProperty] The property used to locate the entity or entities
- * needed for entity-level activity grants. For sets of entities, this function
- * looks in `state.models`. For a single entity, it looks in `props`
- */
-var defaultOptions = function (state, props, modelsProperty) {
-    // if implementing in app, override / decorate with app specific logic
-    return {
-        entity: modelsProperty ? props && props[modelsProperty] : undefined,
-        entities: modelsProperty ? state.models[modelsProperty] : undefined,
-        userInfo: state.models.user && state.models.user.userInfo
-    };
-};
-exports.defaultOptions = defaultOptions;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = exports.canPerformActivityGloballyOrOnSomeEntities = exports.canPerformActivityGloballyOrOnEntity = exports.canPerformActivityGlobally = exports.canPerformActivityOnSomeEntities = exports.canPerformActivityOnEntity = void 0;
+var lodash_1 = __importDefault(require("lodash"));
+var model_1 = require("./model");
+/*
+    The functions in this module all are designed as predicates to determine whether a
+    user has been granted a set of activities to perform, either at an entity-specific
+    level or at a global level.
+
+    Because Javascript doesn’t have named parameters, we use an 'options object' to
+    pass the needed items. By ensuring all these functions have the same signature,
+    we can use them interchangeably in constructing the ActivityRequiredComponent.
+
+    The options object has the following structure:
+    {
+        entities: {
+            {
+                1: {
+                        activities: [
+                            "activityName1",
+                            "activityName2"
+                            ...
+                        ]
+                    },
+                    ...
+            }
+        },
+        entity: {
+                activities: [
+                    "activityName1",
+                    "activityName2"
+                    ...
+                ]
+        }
+        userInfo: {
+            activities: [
+                "activityName1",
+                "activityName2",
+                ...
+            ]
+        }
+    }
+
+    `entity` is a single entity and `entities` is a set of entities to which a user has been granted a set of activities.
+    While we could use the array of entities and eliminate the need for the entity property, the singular property will be
+    used in most cases and it prevents to the need to stuff the entity in an array unnecessarily.
+
+    `userInfo` contains a property with an array of activities the user has been granted at a global level
+*/
+/**
+ * Return true if user has activity for the single entity
+ *
+ * @param {string} requiredActivity The activity required to return true
+ * @param {object} options See above
+ */
+var canPerformActivityOnEntity = function (requiredActivity, options) {
+    if (!requiredActivity) {
+        throw new Error('`requiredActivity` must be provided');
+    }
+    if (!options || !options.entity) {
+        throw new Error('`options.entity` must be provided');
+    }
+    return lodash_1.default.includes(options.entity.activities, requiredActivity);
+};
+exports.canPerformActivityOnEntity = canPerformActivityOnEntity;
+/**
+ * Return true if user has activity on any of the entities
+ *
+ * @param {string} requiredActivity The activity required to return true
+ * @param {object} options See above
+ */
+var canPerformActivityOnSomeEntities = function (requiredActivity, options) {
+    if (!requiredActivity) {
+        throw new Error('`requiredActivity` must be provided');
+    }
+    if (!options || !options.entities) {
+        throw new Error('`options.entities` must be provided');
+    }
+    return lodash_1.default.some(model_1.getModelArray(options.entities), function (entity) { return exports.canPerformActivityOnEntity(requiredActivity, { entity: entity }); });
+};
+exports.canPerformActivityOnSomeEntities = canPerformActivityOnSomeEntities;
+/**
+ * Return true if user has activity globally
+ *
+ * This function can accept an null/undefined userInfo property for the
+ * options argument. In which case it returns false. This is because userInfo
+ * may not be loaded yet. If it is provided however, it must contain an
+ * activities array
+ *
+ * @param {string} requiredActivity The activity required to return true
+ * @param {object} options See above
+ */
+var canPerformActivityGlobally = function (requiredActivity, options) {
+    if (!requiredActivity) {
+        throw new Error('`requiredActivity` must be provided');
+    }
+    if (!!options &&
+        !!options.userInfo &&
+        !!options.userInfo.activities &&
+        !Array.isArray(options.userInfo.activities)) {
+        throw new Error('`options.userInfo.activities` must be an array');
+    }
+    return (!!options &&
+        !!options.userInfo &&
+        !!options.userInfo.activities &&
+        lodash_1.default.includes(options.userInfo.activities, requiredActivity));
+};
+exports.canPerformActivityGlobally = canPerformActivityGlobally;
+/**
+ * Return true if user has activity either globally or on a single entity
+ *
+ * @param {string} requiredActivity The activity required to return true
+ * @param {object} options See above
+ */
+var canPerformActivityGloballyOrOnEntity = function (requiredActivity, options) {
+    return exports.canPerformActivityGlobally(requiredActivity, options) || exports.canPerformActivityOnEntity(requiredActivity, options);
+};
+exports.canPerformActivityGloballyOrOnEntity = canPerformActivityGloballyOrOnEntity;
+/**
+ * Return true if user has activity globally or on any of the entities provided
+ *
+ * @param {string} requiredActivity The activity required to return true
+ * @param {object} options See above
+ */
+var canPerformActivityGloballyOrOnSomeEntities = function (requiredActivity, options) {
+    return (exports.canPerformActivityGlobally(requiredActivity, options) ||
+        exports.canPerformActivityOnSomeEntities(requiredActivity, options));
+};
+exports.canPerformActivityGloballyOrOnSomeEntities = canPerformActivityGloballyOrOnSomeEntities;
+/**
+ * Return an options object that can be used in the functions in this module. This
+ * encapsulates the default logic of looking in state for a set of entities or
+ * looking in props for a single entity.
+ *
+ * Override or decorate with app specific logic in your app if needed.
+ *
+ * @param {Object} state The redux state
+ * @param {Object} [props] A props object (typically ownProps)
+ * @param {string} [modelsProperty] The property used to locate the entity or entities
+ * needed for entity-level activity grants. For sets of entities, this function
+ * looks in `state.models`. For a single entity, it looks in `props`
+ */
+var defaultOptions = function (state, props, modelsProperty) {
+    // if implementing in app, override / decorate with app specific logic
+    return {
+        entity: modelsProperty ? props && props[modelsProperty] : undefined,
+        entities: modelsProperty ? state.models[modelsProperty] : undefined,
+        userInfo: state.models.user && state.models.user.userInfo
+    };
+};
+exports.defaultOptions = defaultOptions;

package/lib/utils/baseRole.d.ts

@@ -1,2 +1,2 @@
-export declare const textForBaseRole: (role: string) => string;
-export declare const singularArticleForBaseRole: (role: string) => string;
+export declare const textForBaseRole: (role: string) => string;
+export declare const singularArticleForBaseRole: (role: string) => string;

package/lib/utils/baseRole.js

@@ -1,38 +1,38 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.singularArticleForBaseRole = exports.textForBaseRole = void 0;
-var baseRole_1 = __importDefault(require("../constants/baseRole"));
-var textForBaseRole = function (role) {
-    switch (role) {
-        case baseRole_1.default.SUPER_ADMIN:
-            return 'Super Admin';
-        case baseRole_1.default.ADMIN:
-            return 'Admin';
-        case baseRole_1.default.GROUP_LEARNER:
-            return 'Student';
-        case baseRole_1.default.GROUP_OWNER:
-            return 'Instructor';
-        case baseRole_1.default.GROUP_GRADER:
-            return 'Grader';
-        default:
-            throw new Error("role '" + role + "' was not found in switch statement");
-    }
-};
-exports.textForBaseRole = textForBaseRole;
-var singularArticleForBaseRole = function (role) {
-    switch (role) {
-        case baseRole_1.default.ADMIN:
-        case baseRole_1.default.GROUP_OWNER:
-            return 'an';
-        case baseRole_1.default.SUPER_ADMIN:
-        case baseRole_1.default.GROUP_LEARNER:
-        case baseRole_1.default.GROUP_GRADER:
-            return 'a';
-        default:
-            throw new Error("role '" + role + "' was not found in switch statement");
-    }
-};
-exports.singularArticleForBaseRole = singularArticleForBaseRole;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singularArticleForBaseRole = exports.textForBaseRole = void 0;
+var baseRole_1 = __importDefault(require("../constants/baseRole"));
+var textForBaseRole = function (role) {
+    switch (role) {
+        case baseRole_1.default.SUPER_ADMIN:
+            return 'Super Admin';
+        case baseRole_1.default.ADMIN:
+            return 'Admin';
+        case baseRole_1.default.GROUP_LEARNER:
+            return 'Student';
+        case baseRole_1.default.GROUP_OWNER:
+            return 'Instructor';
+        case baseRole_1.default.GROUP_GRADER:
+            return 'Grader';
+        default:
+            throw new Error("role '" + role + "' was not found in switch statement");
+    }
+};
+exports.textForBaseRole = textForBaseRole;
+var singularArticleForBaseRole = function (role) {
+    switch (role) {
+        case baseRole_1.default.ADMIN:
+        case baseRole_1.default.GROUP_OWNER:
+            return 'an';
+        case baseRole_1.default.SUPER_ADMIN:
+        case baseRole_1.default.GROUP_LEARNER:
+        case baseRole_1.default.GROUP_GRADER:
+            return 'a';
+        default:
+            throw new Error("role '" + role + "' was not found in switch statement");
+    }
+};
+exports.singularArticleForBaseRole = singularArticleForBaseRole;

package/lib/utils/collection.d.ts

@@ -1,43 +1,43 @@
-import { Dictionary } from 'lodash';
-import { Model, ModelCollection } from 'studiokit-net-js';
-import { CollectionCreateParams, CollectionDeleteParams, CollectionItemDeleteParams, CollectionItemLoadParams, CollectionItemUpdateParams, CollectionLoadParams, CollectionMethodConfiguration, CollectionSelectorMethodParams, CollectionSelectorMethodResponse, CollectionUpdateParams } from '../types/Collection';
-export declare function selectCollectionItemFromState<TModel extends Model>(params: CollectionSelectorMethodParams): CollectionSelectorMethodResponse<TModel>;
-export declare function selectCollectionFromState<TModel extends Model>(params: CollectionSelectorMethodParams): CollectionSelectorMethodResponse<TModel>;
-export declare function stopCollectionPeriodicLoad(modelName: string, taskId: string): void;
-export declare function loadCollection(config: CollectionMethodConfiguration, params?: CollectionLoadParams): void;
-export declare function loadCollectionItem(config: CollectionMethodConfiguration, params?: CollectionItemLoadParams): void;
-export declare function createItemInCollection(config: CollectionMethodConfiguration, params: CollectionCreateParams): void;
-export declare function createCollectionItem(model: Model, config: CollectionMethodConfiguration, params: CollectionCreateParams): void;
-export declare function updateItemInCollection(config: CollectionMethodConfiguration, params: CollectionUpdateParams): void;
-export declare function updateCollectionItem(model: Model, config: CollectionMethodConfiguration, params: CollectionItemUpdateParams): void;
-export declare function deleteItemFromCollection(config: CollectionMethodConfiguration, params: CollectionDeleteParams): void;
-export declare function deleteCollectionItem(model: Model, config: CollectionMethodConfiguration, params?: CollectionItemDeleteParams): void;
-/**
- * Automatically call `load`, or `changeModelStatus` to `READY`.
- *
- * Does NOT automatically load if:
- * * pathParams does not contain enough items.
- * * model is already fetching.
- * * auto load is disabled.
- */
-export declare function initializeCollectionItem(model: Model, load: (params?: CollectionItemLoadParams) => void, config: CollectionMethodConfiguration): void;
-/**
- * Automatically call `load`, or `changeModelStatus` to `READY`.
- *
- * Does NOT automatically load if:
- * * model is already fetching.
- * * auto load is disabled.
- */
-export declare function initializeCollection(model: Model, load: (params?: CollectionItemLoadParams) => void, config: CollectionMethodConfiguration): void;
-/**
- * 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;
-/**
- * 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;
-/**
- * Delete the guid in the model
- */
-export declare function cleanupCollectionGuidKey<TModel extends Model>(model: ModelCollection<TModel>, config: CollectionMethodConfiguration): void;
+import { Dictionary } from 'lodash';
+import { Model, ModelCollection } from 'studiokit-net-js';
+import { CollectionCreateParams, CollectionDeleteParams, CollectionItemDeleteParams, CollectionItemLoadParams, CollectionItemUpdateParams, CollectionLoadParams, CollectionMethodConfiguration, CollectionSelectorMethodParams, CollectionSelectorMethodResponse, CollectionUpdateParams } from '../types/Collection';
+export declare function selectCollectionItemFromState<TModel extends Model>(params: CollectionSelectorMethodParams): CollectionSelectorMethodResponse<TModel>;
+export declare function selectCollectionFromState<TModel extends Model>(params: CollectionSelectorMethodParams): CollectionSelectorMethodResponse<TModel>;
+export declare function stopCollectionPeriodicLoad(modelName: string, taskId: string): void;
+export declare function loadCollection(config: CollectionMethodConfiguration, params?: CollectionLoadParams): void;
+export declare function loadCollectionItem(config: CollectionMethodConfiguration, params?: CollectionItemLoadParams): void;
+export declare function createItemInCollection(config: CollectionMethodConfiguration, params: CollectionCreateParams): void;
+export declare function createCollectionItem(model: Model, config: CollectionMethodConfiguration, params: CollectionCreateParams): void;
+export declare function updateItemInCollection(config: CollectionMethodConfiguration, params: CollectionUpdateParams): void;
+export declare function updateCollectionItem(model: Model, config: CollectionMethodConfiguration, params: CollectionItemUpdateParams): void;
+export declare function deleteItemFromCollection(config: CollectionMethodConfiguration, params: CollectionDeleteParams): void;
+export declare function deleteCollectionItem(model: Model, config: CollectionMethodConfiguration, params?: CollectionItemDeleteParams): void;
+/**
+ * Automatically call `load`, or `changeModelStatus` to `READY`.
+ *
+ * Does NOT automatically load if:
+ * * pathParams does not contain enough items.
+ * * model is already fetching.
+ * * auto load is disabled.
+ */
+export declare function initializeCollectionItem(model: Model, load: (params?: CollectionItemLoadParams) => void, config: CollectionMethodConfiguration): void;
+/**
+ * Automatically call `load`, or `changeModelStatus` to `READY`.
+ *
+ * Does NOT automatically load if:
+ * * model is already fetching.
+ * * auto load is disabled.
+ */
+export declare function initializeCollection(model: Model, load: (params?: CollectionItemLoadParams) => void, config: CollectionMethodConfiguration): void;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Delete the guid in the model
+ */
+export declare function cleanupCollectionGuidKey<TModel extends Model>(model: ModelCollection<TModel>, config: CollectionMethodConfiguration): void;