@instructure/outcomes-ui 2.1.2 → 2.1.3

package/es/translated/vi/store/OutcomePicker/reducers.js

@@ -0,0 +1,57 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { Set } from 'immutable';
+import { RESET_OUTCOME_PICKER } from "../../constants.js";
+import { setFocusedOutcomeAction, toggleExpandedIds } from "./actions.js";
+import search from "../search/reducers.js";
+import tray from "../OutcomeTray/reducers.js";
+var focusedOutcome = handleActions(_defineProperty({}, setFocusedOutcomeAction, function (state, action) {
+  return action.payload;
+}), null);
+var expandedIds = handleActions(_defineProperty({}, toggleExpandedIds, function (state, action) {
+  if (state.has(action.payload.id.toString()) && !action.payload.forceOpen) {
+    return state.delete(action.payload.id.toString());
+  } else {
+    return state.add(action.payload.id.toString());
+  }
+}), Set());
+var selected = handleActions({
+  SELECT_OUTCOME_IDS: function SELECT_OUTCOME_IDS(state, action) {
+    return state.union(action.payload.map(function (id) {
+      return id.toString();
+    }));
+  },
+  UNSELECT_OUTCOME_IDS: function UNSELECT_OUTCOME_IDS(state, action) {
+    return state.subtract(action.payload.map(function (id) {
+      return id.toString();
+    }));
+  },
+  SET_SELECTED_OUTCOME_IDS: function SET_SELECTED_OUTCOME_IDS(state, action) {
+    return Set(action.payload);
+  }
+}, Set());
+var activeCollection = handleActions({
+  SET_ACTIVE_COLLECTION_ID: function SET_ACTIVE_COLLECTION_ID(state, action) {
+    return action.payload;
+  }
+}, null);
+var state = handleActions({
+  SET_OUTCOME_PICKER_STATE: function SET_OUTCOME_PICKER_STATE(state, action) {
+    return action.payload;
+  }
+}, 'closed');
+var OutcomePickerReducer = combineReducers({
+  state: state,
+  selected: selected,
+  focusedOutcome: focusedOutcome,
+  activeCollection: activeCollection,
+  expandedIds: expandedIds,
+  search: search,
+  tray: tray
+});
+export default (function (state, action) {
+  return action.type === RESET_OUTCOME_PICKER // When the reducer receives a close action, reset
+  // the state of the picker to default values
+  ? OutcomePickerReducer(void 0, action) : OutcomePickerReducer(state, action);
+});

package/es/translated/vi/store/OutcomePicker/selectors.js

@@ -0,0 +1,99 @@
+import { Map } from 'immutable';
+import { isEqual } from 'lodash';
+import { createSelector, createSelectorCreator, defaultMemoize } from 'reselect';
+import createCachedSelector from 're-reselect';
+import { getOutcome, isGroup, makeGetOutcomeSummary } from "../context/selectors.js";
+import { getAnyOutcome } from "../alignments/selectors.js"; // Deep compare objects to avoid rerendering when contents are the same
+
+var customDeepComparisonSelector = createSelectorCreator(defaultMemoize, isEqual);
+
+function restrict(state, scope) {
+  return state.getIn([scope, 'OutcomePicker']) || Map();
+}
+
+function selectedOutcomeIds(state, scope) {
+  return restrict(state, scope).get('selected');
+}
+
+export var getSelectedOutcomeIds = createCachedSelector(selectedOutcomeIds, function (ids) {
+  return ids ? ids.toJS() : [];
+})(function (_state, scope) {
+  return scope;
+});
+export function getFocusedOutcome(state, scope) {
+  return restrict(state, scope).get('focusedOutcome');
+}
+export var getExpandedIds = createSelector(function (state, scope) {
+  return restrict(state, scope).get('expandedIds');
+}, function (ids) {
+  return ids ? ids.toJS() : [];
+});
+export var makeIsOutcomeSelected = createCachedSelector(selectedOutcomeIds, function (selected) {
+  return function (id) {
+    return selected ? selected.has(id.toString()) : false;
+  };
+})(function (_state, scope) {
+  return scope;
+});
+export function anyOutcomeSelected(state, scope) {
+  var ids = restrict(state, scope).get('selected');
+  return ids ? !ids.isEmpty() : false;
+}
+export function getActiveCollectionId(state, scope) {
+  return restrict(state, scope).get('activeCollection') || '';
+}
+export var getOutcomePickerState = function getOutcomePickerState(state, scope) {
+  return restrict(state, scope).get('state');
+};
+
+var getActiveCollectionOutcome = function getActiveCollectionOutcome(state, scope) {
+  var id = getActiveCollectionId(state, scope);
+  return id ? getOutcome(state, scope, id) : null;
+};
+
+export var getActiveCollection = createCachedSelector(getActiveCollectionOutcome, function (state, scope) {
+  var id = getActiveCollectionId(state, scope);
+  return id ? makeGetOutcomeSummary(state, scope)(id) : '';
+}, function (outcome, summary) {
+  return {
+    header: outcome ? outcome.title : '',
+    id: outcome ? outcome.id : '',
+    description: outcome ? outcome.description : '',
+    summary: summary
+  };
+})(getActiveCollectionId);
+export var getActiveChildren = createCachedSelector(function (state, scope) {
+  var active = getActiveCollectionOutcome(state, scope);
+
+  if (active && active.child_ids) {
+    return active.child_ids.map(function (id) {
+      return getOutcome(state, scope, id);
+    });
+  }
+
+  return [];
+}, function (childOutcomes) {
+  var _childOutcomes$reduce = childOutcomes.reduce(function (acc, val) {
+    isGroup(val) ? acc.groups.push(val) : acc.nonGroups.push(val);
+    return acc;
+  }, {
+    groups: [],
+    nonGroups: []
+  }),
+      groups = _childOutcomes$reduce.groups,
+      nonGroups = _childOutcomes$reduce.nonGroups;
+
+  return {
+    groups: groups,
+    nonGroups: nonGroups
+  };
+})(getActiveCollectionId, {
+  selectorCreator: customDeepComparisonSelector
+});
+export var getSelectedOutcomes = customDeepComparisonSelector(function (state, scope) {
+  return getSelectedOutcomeIds(state, scope).map(function (id) {
+    return getAnyOutcome(state, scope, id);
+  });
+}, function (outcomes) {
+  return outcomes;
+});

package/es/translated/vi/store/OutcomeTray/__tests__/actions.test.js

@@ -0,0 +1,111 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+
+/* eslint-disable promise/always-return */
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import sinon from 'sinon';
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+import * as actions from "../actions.js";
+import { setError } from "../../../store/context/actions.js";
+import { setOutcomePickerState } from "../../../store/OutcomePicker/actions.js";
+var scopedActions = scopeActions(_objectSpread(_objectSpread({}, actions), {}, {
+  setError: setError,
+  setOutcomePickerState: setOutcomePickerState
+}));
+describe('OutcomeTray/actions', function () {
+  var state = fromJS({
+    scopeForTest: {
+      OutcomePicker: {
+        tray: {
+          pagination: {
+            page: 1,
+            total: null
+          },
+          list: [],
+          selected: ['2', '3', '4']
+        }
+      }
+    }
+  });
+  var outcomes = [{
+    id: '1',
+    name: 'red'
+  }, {
+    id: '2',
+    name: 'blue'
+  }];
+  var response = {
+    outcomes: outcomes,
+    total: 2
+  };
+  var service = {
+    listOutcomes: sinon.stub().returns(Promise.resolve(response))
+  };
+  afterEach(function () {
+    return service.listOutcomes.resetHistory();
+  });
+  describe('getOutcomesList', function () {
+    it('dispatches state change to loading', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.getOutcomesList()).then(function () {
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setOutcomePickerState('loading'));
+      });
+    });
+    it('dispatches listOutcomes', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.getOutcomesList()).then(function () {
+        return expect(service.listOutcomes.calledOnce).to.be.true;
+      });
+    });
+    it('dispatches in correct order', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.getOutcomesList()).then(function () {
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setOutcomeList(outcomes));
+        expect(store.getActions()[3]).to.deep.equal(scopedActions.setOutcomes(_defineProperty({}, void 0, {
+          '1': outcomes[0],
+          '2': outcomes[1]
+        })));
+        expect(store.getActions()[4]).to.deep.equal(scopedActions.setListTotal(response.total));
+        expect(store.getActions()[5]).to.deep.equal(scopedActions.setOutcomePickerState('choosing'));
+      });
+    });
+    it('dispatches setPage if a page is provided', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.getOutcomesList({
+        page: 2
+      })).then(function () {
+        return expect(store.getActions()[0]).to.deep.equal(scopedActions.setListPage(2));
+      });
+    });
+    it('dispatches setError on listOutcomes failure', function () {
+      var error = {
+        message: 'foo bar baz'
+      };
+      var service = {
+        listOutcomes: sinon.stub().returns(Promise.reject(error))
+      };
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.getOutcomesList()).then(function () {
+        expect(store.getActions()).to.have.length(3);
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setError(error));
+      });
+    });
+  });
+  describe('setInitialSelectedOutcomes', function () {
+    var alignedOutcomes = [{
+      id: '1'
+    }, {
+      id: '999'
+    }];
+    var alignmentState = state.setIn(['scopeForTest', 'alignments', 'alignedOutcomes'], fromJS(alignedOutcomes));
+    it('dispatches setSelectedOutcomeIds', function () {
+      var store = createMockStore(alignmentState, service);
+      return store.dispatch(actions.setInitialSelectedOutcomes()).then(function () {
+        expect(store.getActions()).to.have.length(1);
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setSelectedOutcomeIds(['1', '999']));
+        expect(store.getActions()[0].payload).to.deep.equal(['1', '999']);
+      });
+    });
+  });
+});

package/es/translated/vi/store/OutcomeTray/__tests__/reducers.test.js

@@ -0,0 +1,31 @@
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import * as actions from "../actions.js";
+import reducer from "../reducers.js";
+describe('OutcomeTray/reducers', function () {
+  var state = fromJS({
+    entries: [],
+    pagination: {
+      page: 1,
+      total: null
+    }
+  });
+  describe('list', function () {
+    it('is set by setOutcomeList', function () {
+      var next = reducer(state, actions.setOutcomeList(['1', '2']));
+      expect(next.get('list')).to.deep.equal(fromJS(['1', '2']));
+    });
+  });
+  describe('page', function () {
+    it('is set by setListPage', function () {
+      var next = reducer(state, actions.setListPage(111));
+      expect(next.get('pagination').get('page')).to.equal(111);
+    });
+  });
+  describe('total', function () {
+    it('is set by setListTotal', function () {
+      var next = reducer(state, actions.setListTotal(9));
+      expect(next.get('pagination').get('total')).to.equal(9);
+    });
+  });
+});

package/es/translated/vi/store/OutcomeTray/__tests__/selectors.test.js

@@ -0,0 +1,37 @@
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import { getOutcomeList, getListPage, getListTotal } from "../selectors.js";
+describe('OutcomeTray/selectors', function () {
+  var scope = 'scopeForTest';
+  var state = fromJS({
+    scopeForTest: {
+      config: {
+        contextUuid: 'course_100'
+      },
+      OutcomePicker: {
+        tray: {
+          list: [],
+          pagination: {
+            page: 7,
+            total: 100
+          }
+        }
+      }
+    }
+  });
+  describe('getOutcomeList', function () {
+    it('returns the outcome list', function () {
+      expect(getOutcomeList(state, scope)).to.deep.equal([]);
+    });
+  });
+  describe('getListPage', function () {
+    it('returns the current page', function () {
+      expect(getListPage(state, scope)).to.equal(7);
+    });
+  });
+  describe('getListTotal', function () {
+    it('returns the current total', function () {
+      expect(getListTotal(state, scope)).to.equal(100);
+    });
+  });
+});

package/es/translated/vi/store/OutcomeTray/actions.js

@@ -0,0 +1,66 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { getConfig } from "../config/selectors.js";
+import { SET_OUTCOME_LIST, SET_OUTCOMES, SET_LIST_PAGE, SET_LIST_TOTAL, SET_SELECTED_OUTCOME_IDS } from "../../constants.js";
+import { setOutcomePickerState } from "../OutcomePicker/actions.js";
+import { setError } from "../context/actions.js";
+import { getAlignedOutcomeIds } from "../alignments/selectors.js";
+import { getListPage } from "./selectors.js";
+export var setOutcomeList = createAction(SET_OUTCOME_LIST);
+export var setOutcomes = createAction(SET_OUTCOMES);
+export var setListPage = createAction(SET_LIST_PAGE);
+export var setListTotal = createAction(SET_LIST_TOTAL);
+export var setSelectedOutcomeIds = createAction(SET_SELECTED_OUTCOME_IDS);
+export var getOutcomesList = function getOutcomesList() {
+  var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {},
+      page = _ref.page;
+
+  return function (dispatch, getState, _arg, scope) {
+    var initialPage = page || getListPage(getState(), scope);
+
+    if (page) {
+      dispatch(setListPage(page));
+    }
+
+    dispatch(setOutcomePickerState('loading'));
+
+    var _getConfig = getConfig(getState(), scope),
+        host = _getConfig.host,
+        jwt = _getConfig.jwt,
+        contextUuid = _getConfig.contextUuid,
+        artifactId = _getConfig.artifactId,
+        artifactType = _getConfig.artifactType;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'listOutcomes',
+        args: [host, jwt, initialPage, contextUuid, artifactId, artifactType]
+      }
+    }).then(function (json) {
+      if (getListPage(getState(), scope) === initialPage) {
+        dispatch(setOutcomeList(json.outcomes));
+        var outcomes = json.outcomes.reduce(function (map, obj) {
+          // eslint-disable-next-line no-param-reassign
+          map[obj.id] = obj;
+          return map;
+        }, {});
+        dispatch(setOutcomes(_defineProperty({}, contextUuid, outcomes)));
+        dispatch(setListTotal(json.total));
+        dispatch(setOutcomePickerState('choosing'));
+      }
+
+      return Promise.resolve(json.outcomes);
+    }).catch(function (e) {
+      dispatch(setError(e));
+    });
+  };
+};
+export var setInitialSelectedOutcomes = function setInitialSelectedOutcomes() {
+  return function (dispatch, getState, _arg, scope) {
+    dispatch(setSelectedOutcomeIds(getAlignedOutcomeIds(getState(), scope)));
+    return Promise.resolve();
+  };
+};

package/es/translated/vi/store/OutcomeTray/reducers.js

@@ -0,0 +1,13 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { List, fromJS } from 'immutable';
+import { setOutcomeList } from "./actions.js";
+import paginationReducer from "../utils/paginationReducer.js";
+var list = handleActions(_defineProperty({}, setOutcomeList, function (state, action) {
+  return fromJS(action.payload);
+}), List());
+export default combineReducers({
+  list: list,
+  pagination: paginationReducer('LIST')
+});

package/es/translated/vi/store/OutcomeTray/selectors.js

@@ -0,0 +1,25 @@
+import { Map } from 'immutable';
+import createCachedSelector from 're-reselect';
+
+var getTray = function getTray(state, scope) {
+  return state.getIn([scope, 'OutcomePicker', 'tray']) || Map();
+};
+
+export var getOutcomeList = createCachedSelector(function (state, scope) {
+  return getTray(state, scope).get('list');
+}, function (list) {
+  return list ? list.toJS() : [];
+})(function (_, scope) {
+  return scope;
+});
+
+var pagination = function pagination(state, scope) {
+  return getTray(state, scope).get('pagination') || Map();
+};
+
+export var getListPage = function getListPage(state, scope) {
+  return pagination(state, scope).get('page');
+};
+export var getListTotal = function getListTotal(state, scope) {
+  return pagination(state, scope).get('total');
+};

package/es/translated/vi/store/__tests__/index.test.js

@@ -0,0 +1,58 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { getStore, makeScope, makeUserScope } from "../index.js";
+var host = 'http://outcomes.docker';
+var jwt = 'jwt';
+describe('getStore', function () {
+  it('exports a function', function () {
+    expect(getStore).to.be.a('function');
+  });
+  it('returns an object', function () {
+    var store = getStore(host, jwt, 'scope');
+    expect(store).to.be.an('object');
+  });
+  it('returns a well formed store', function () {
+    var store = getStore(host, jwt, 'scope');
+    expect(store).to.contain.all.keys('dispatch subscribe getState replaceReducer'.split(' '));
+  });
+  it('returns the same store for multiple scopes', function () {
+    var store = getStore(host, jwt, 'scope');
+    var store2 = getStore(host, jwt, 'scope2');
+    expect(store2).to.equal(store);
+  });
+  it('creates state for each scope', function () {
+    var store = getStore(host, jwt, 'scope');
+    getStore(host, jwt, 'scope2');
+    expect(store.getState().toJS()).to.include.keys('scope', 'scope2');
+  });
+  it('calls replaceReducer per unique scope', function () {
+    var store = getStore(host, jwt, 'scope');
+    var stub = sinon.stub(store, 'replaceReducer');
+    getStore(host, jwt, 'scope');
+    getStore(host, jwt, 'scopefoo');
+    getStore(host, jwt, 'scopefoo');
+    getStore(host, jwt, 'scopebar');
+    getStore(host, jwt, 'scopebar'); // replaceReducer already called once for 'scope' before we stub
+
+    expect(stub).to.have.been.calledTwice;
+  });
+});
+describe('makeScope', function () {
+  it('returns unique scope string for different ids', function () {
+    var thing1 = makeScope('thing', 1);
+    var thing2 = makeScope('thing', 2);
+    expect(thing1).not.to.equal(thing2);
+  });
+  it('returns unique scope for different types', function () {
+    var foo = makeScope('foo', 1);
+    var bar = makeScope('bar', 1);
+    expect(foo).not.to.equal(bar);
+  });
+});
+describe('makeUserScope', function () {
+  it('returns unique user scope string for different user uuids', function () {
+    var thing1 = makeUserScope('user1');
+    var thing2 = makeUserScope('user2');
+    expect(thing1).not.to.equal(thing2);
+  });
+});

package/es/translated/vi/store/activePicker/__tests__/action.test.js

@@ -0,0 +1,12 @@
+import { expect } from 'chai';
+import { SET_SCOPE } from "../../../constants.js";
+import * as actions from "../actions.js";
+describe('activePicker/actions', function () {
+  describe('setScope', function () {
+    it('creates an action', function () {
+      var action = actions.setScope('scope_1');
+      expect(action.type).to.equal(SET_SCOPE);
+      expect(action.payload).to.deep.equal('scope_1');
+    });
+  });
+});

package/es/translated/vi/store/activePicker/__tests__/reducers.test.js

@@ -0,0 +1,19 @@
+import { expect } from 'chai';
+import { SET_SCOPE } from "../../../constants.js";
+import reducer from "../reducers.js";
+describe('activePicker/reducers', function () {
+  var state = 'begin_scope';
+
+  var reduce = function reduce(state, type, payload) {
+    return reducer(state, {
+      type: type,
+      payload: payload
+    });
+  };
+
+  it('SET_SCOPE updates the scope', function () {
+    var scope = 'current_scope';
+    var newState = reduce(state, SET_SCOPE, scope);
+    expect(newState).to.deep.equal('current_scope');
+  });
+});

package/es/translated/vi/store/activePicker/__tests__/selectors.test.js

@@ -0,0 +1,25 @@
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import { getScope, isOpen } from "../selectors.js";
+describe('activePicker/selectors', function () {
+  var state = fromJS({
+    activePicker: 'current_scope'
+  });
+  describe('getScope', function () {
+    it('retrieves the current scope', function () {
+      expect(getScope(state)).to.equal('current_scope');
+    });
+    it('returns `` when empty', function () {
+      var newState = state.setIn(['activePicker'], '');
+      expect(getScope(newState)).to.equal('');
+    });
+  });
+  describe('isOpen', function () {
+    it('returns true if the scope matches', function () {
+      expect(isOpen(state, 'current_scope')).to.equal(true);
+    });
+    it('returns false if the scope doesnt match', function () {
+      expect(isOpen(state, '')).to.equal(false);
+    });
+  });
+});

package/es/translated/vi/store/activePicker/actions.js

@@ -0,0 +1,3 @@
+import { createAction } from 'redux-actions';
+import { SET_SCOPE } from "../../constants.js";
+export var setScope = createAction(SET_SCOPE);

package/es/translated/vi/store/activePicker/reducers.js

@@ -0,0 +1,6 @@
+import { handleActions } from 'redux-actions';
+export default handleActions({
+  SET_SCOPE: function SET_SCOPE(_state, action) {
+    return action.payload;
+  }
+}, '');

package/es/translated/vi/store/activePicker/selectors.js

@@ -0,0 +1,10 @@
+function restrict(state) {
+  return state.getIn(['activePicker']) || '';
+}
+
+export function isOpen(state, scope) {
+  return restrict(state) === scope;
+}
+export function getScope(state) {
+  return restrict(state);
+}