@instructure/outcomes-ui 2.1.0 → 2.1.3

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

@@ -0,0 +1,230 @@
+import { expect } from 'chai';
+import { List, fromJS } from 'immutable';
+import { hasContextOutcomes, getOutcome, isOutcomeGroup, makeGetOutcomeSummary, getRootOutcomeIds, getCollectionData, getDescriptor, getChildrenToLoad, hasRootOutcomes, getContext, getContextByScope } from "../selectors.js";
+describe('context/selectors', function () {
+  var scope = 'scopeForTest';
+  var state = fromJS({
+    scopeForTest: {
+      config: {
+        contextUuid: 'course_100'
+      }
+    },
+    context: {
+      outcomes: {
+        course_100: {
+          1: {
+            id: 1,
+            label: 'l1',
+            title: 't1',
+            child_ids: ['2', '3']
+          },
+          2: {
+            id: 2,
+            label: 'l2',
+            title: 't2',
+            child_ids: ['4']
+          },
+          3: {
+            id: 3,
+            label: 'l3',
+            title: 't3',
+            child_ids: []
+          },
+          4: {
+            id: 4,
+            label: 'l4',
+            title: 't4'
+          }
+        }
+      },
+      contexts: {
+        course_100: {
+          loading: false,
+          data: {
+            id: 1
+          }
+        }
+      },
+      rootOutcomeIds: {
+        course_100: [1]
+      }
+    }
+  });
+  describe('getContext', function () {
+    it('returns context when outcomes exist', function () {
+      expect(getContext(state, 'course_100').data.id).to.be.equal(1);
+    });
+    it('returns undefined when does not exists', function () {
+      expect(getContext(state, 'course_101')).to.be.undefined;
+    });
+  });
+  describe('getContextByScope', function () {
+    it('returns context when outcomes exist', function () {
+      expect(getContextByScope(state, scope).data.id).to.be.equal(1);
+    });
+    it('returns undefined when does not exists', function () {
+      expect(getContextByScope(state, 'any_scope')).to.be.undefined;
+    });
+  });
+  describe('hasContextOutcomes', function () {
+    it('returns true when outcomes exist', function () {
+      expect(hasContextOutcomes(state, scope)).to.equal(true);
+    });
+    it('returns false when empty', function () {
+      var newState = state.setIn(['context', 'outcomes'], List());
+      expect(hasContextOutcomes(newState, scope)).to.equal(false);
+    });
+    it('returns false when unset', function () {
+      var newState = state.deleteIn(['context', 'outcomes']);
+      expect(hasContextOutcomes(newState, scope)).to.equal(false);
+    });
+  });
+  describe('hasRootOutcomes', function () {
+    it('returns true when outcomes exist', function () {
+      expect(hasRootOutcomes(state, scope)).to.equal(true);
+    });
+    it('returns false when empty', function () {
+      var newState = state.setIn(['context', 'rootOutcomeIds', 'course_100'], List());
+      expect(hasRootOutcomes(newState, scope)).to.equal(false);
+    });
+    it('returns false when unset', function () {
+      var newState = state.deleteIn(['context', 'rootOutcomeIds']);
+      expect(hasRootOutcomes(newState, scope)).to.equal(false);
+    });
+  });
+  describe('getOutcome', function () {
+    it('retrieves the correct value', function () {
+      expect(getOutcome(state, scope, '3')).to.have.property('id', 3);
+    });
+    it('returns null if not present', function () {
+      expect(getOutcome(state, scope, '10')).to.be.null;
+    });
+  });
+  describe('getRootOutcomeIds', function () {
+    it('retrieves the correct value', function () {
+      expect(getRootOutcomeIds(state, scope)).to.deep.equal([1]);
+    });
+    it('returns [] if not present', function () {
+      var newState = state.deleteIn(['context', 'rootOutcomeIds', 'course_100']);
+      expect(getRootOutcomeIds(newState, scope)).to.deep.equal([]);
+    });
+  });
+  describe('isOutcomeGroup', function () {
+    it('returns true for outcome groups', function () {
+      expect(isOutcomeGroup(state, scope, '1')).to.be.ok;
+    });
+    it('returns false if not present', function () {
+      expect(isOutcomeGroup(state, scope, '5')).to.not.be.ok;
+    });
+    it('returns false for non-outcome groups', function () {
+      expect(isOutcomeGroup(state, scope, '3')).to.not.be.ok;
+      expect(isOutcomeGroup(state, scope, '4')).to.not.be.ok;
+    });
+  });
+  describe('makeGetOutcomeSummary', function () {
+    it('returns the correct summary', function () {
+      expect(makeGetOutcomeSummary(state, scope)('1')).to.equal('1 Group | 1 Outcome');
+    });
+  });
+  describe('getCollectionData', function () {
+    it('returns collections', function () {
+      var collections = getCollectionData(state, scope);
+      expect(collections).to.be.present;
+      expect(Object.keys(collections).length).to.equal(2);
+    });
+    it('returns proper collection and subCollection data', function () {
+      var collections = getCollectionData(state, scope);
+      var subCollectionId = collections['1'].collections[0];
+      expect(collections['1'].name).to.equal('t1');
+      expect(collections[subCollectionId].name).to.equal('t2');
+    });
+    it('caches its result', function () {
+      var collections = getCollectionData(state, scope);
+      var collections2 = getCollectionData(state, scope);
+      expect(collections).to.equal(collections2);
+    });
+    it('updates its cache if the outcomes change', function () {
+      var collections = getCollectionData(state, scope);
+      var newState = state.deleteIn(['context', 'outcomes', 'course_100', '4']);
+      var collections2 = getCollectionData(newState, scope);
+      expect(collections).not.to.equal(collections2);
+    });
+  });
+  describe('getDescriptor', function () {
+    describe('with groups and outcomes', function () {
+      it('returns a properly formatted string', function () {
+        expect(getDescriptor(2, 3)).to.equal('2 Groups | 3 Outcomes');
+      });
+    });
+    describe('with only groups', function () {
+      it('returns a properly formatted string', function () {
+        expect(getDescriptor(1, 0)).to.equal('1 Group');
+      });
+    });
+    describe('with only outcomes', function () {
+      it('returns a properly formatted string', function () {
+        expect(getDescriptor(0, 1)).to.equal('1 Outcome');
+      });
+    });
+    describe('with no groups or outcomes', function () {
+      it('returns a properly formatted string', function () {
+        expect(getDescriptor(0, 0)).to.equal('');
+      });
+    });
+  });
+  describe('getChildrenToLoad', function () {
+    var partialState = state.setIn(['context', 'outcomes', 'course_100'], fromJS({
+      5: {
+        id: 5,
+        label: 'l5',
+        title: 't5',
+        has_children: true,
+        child_ids: ['6', '7', '8']
+      },
+      6: {
+        id: 6,
+        label: 'l6',
+        title: 't6',
+        has_children: true,
+        is_partial: true
+      },
+      7: {
+        id: 7,
+        label: 'l7',
+        title: 't7',
+        has_children: false,
+        is_partial: true
+      },
+      8: {
+        id: 8,
+        label: 'l8',
+        title: 't8',
+        has_children: true
+      },
+      9: {
+        id: 9,
+        label: 'l9',
+        title: 't9'
+      }
+    }));
+    it('returns an empty array if using the old state', function () {
+      ['1', '2', '3', '4'].forEach(function (id) {
+        expect(getChildrenToLoad(state, scope, id)).to.deep.equal([]);
+      });
+    });
+    it('returns the given id if the outcome is not in state', function () {
+      var newState = partialState.deleteIn(['context', 'outcomes', 'course_100', '5']);
+      expect(getChildrenToLoad(newState, scope, '5')).to.deep.equal(['5']);
+    });
+    it('returns the given id if the outcome is not fully loaded', function () {
+      var newState = partialState.setIn(['context', 'outcomes', 'course_100', '5', 'is_partial'], true);
+      expect(getChildrenToLoad(newState, scope, '5')).to.deep.equal(['5']);
+    });
+    it('returns the child ids which are groups and which are not fully loaded', function () {
+      expect(getChildrenToLoad(partialState, scope, '5')).to.deep.equal(['6']);
+    });
+    it('returns an empty array if the outcome is not a group', function () {
+      expect(getChildrenToLoad(partialState, scope, '9')).to.deep.equal([]);
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { SET_ERROR, SET_OUTCOMES, SET_ROOT_OUTCOME_IDS, SET_CONTEXT, SET_SCORING_METHOD } from "../../constants.js";
+import { hasRootOutcomes, getChildrenToLoad, getContext } from "./selectors.js";
+import { getConfig } from "../config/selectors.js";
+export var setContext = createAction(SET_CONTEXT);
+export var setOutcomes = createAction(SET_OUTCOMES);
+export var setRootOutcomeIds = createAction(SET_ROOT_OUTCOME_IDS);
+export var setError = createAction(SET_ERROR);
+export var setScoringMethod = createAction(SET_SCORING_METHOD);
+export var loadContext = function loadContext(host, jwt, contextUuid) {
+  return function (dispatch, getState) {
+    if (getContext(getState(), contextUuid)) {
+      return Promise.resolve();
+    }
+
+    dispatch(setContext(_defineProperty({}, contextUuid, {
+      loading: true
+    })));
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getContext',
+        args: [host, jwt, contextUuid]
+      }
+    }).then(function (json) {
+      return dispatch(setContext(_defineProperty({}, contextUuid, {
+        loading: false,
+        data: json
+      })));
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};
+export var loadRootOutcomes = function loadRootOutcomes() {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig = getConfig(getState(), scope),
+        contextUuid = _getConfig.contextUuid;
+
+    if (hasRootOutcomes(getState(), scope)) {
+      return Promise.resolve();
+    }
+
+    return dispatch(loadOutcomes(null)).then(function (json) {
+      Object.assign(json.outcomes, {
+        root: {
+          id: 'root',
+          title: "C\u01A1 S\u1EDF",
+          description: "Nh\xF3m v\xE0 k\u1EBFt qu\u1EA3 c\u1EA5p c\u01A1 s\u1EDF",
+          child_ids: json.root_ids.map(function (id) {
+            return id.toString();
+          })
+        }
+      });
+      dispatch(setOutcomes(_defineProperty({}, contextUuid, json.outcomes)));
+      dispatch(setRootOutcomeIds(_defineProperty({}, contextUuid, json.root_ids)));
+      return Promise.resolve();
+    }).catch(function (e) {
+      dispatch(setError(e));
+    });
+  };
+};
+export var loadMoreOutcomes = function loadMoreOutcomes(id) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig2 = getConfig(getState(), scope),
+        contextUuid = _getConfig2.contextUuid;
+
+    var idsToLoad = getChildrenToLoad(getState(), scope, id);
+
+    if (idsToLoad.length === 0) {
+      return Promise.resolve();
+    }
+
+    return dispatch(loadOutcomes(idsToLoad)).then(function (json) {
+      dispatch(setOutcomes(_defineProperty({}, contextUuid, json.outcomes)));
+      return Promise.resolve();
+    }).catch(function (e) {
+      dispatch(setError(e));
+    });
+  };
+};
+
+var loadOutcomes = function loadOutcomes(ids) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig3 = getConfig(getState(), scope),
+        host = _getConfig3.host,
+        jwt = _getConfig3.jwt,
+        contextUuid = _getConfig3.contextUuid;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'loadOutcomes',
+        args: [host, jwt, contextUuid, ids]
+      }
+    }).then(function (json) {
+      return Promise.resolve(json);
+    });
+  };
+};

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

@@ -0,0 +1,26 @@
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { Map, fromJS } from 'immutable';
+var outcomes = handleActions({
+  SET_OUTCOMES: function SET_OUTCOMES(state, action) {
+    return state.mergeDeep(fromJS(action.payload));
+  },
+  SET_SCORING_METHOD: function SET_SCORING_METHOD(state, action) {
+    return state.setIn([action.payload.context_uuid, action.payload.id, 'scoring_method'], fromJS(action.payload.scoring_method));
+  }
+}, Map());
+var contexts = handleActions({
+  SET_CONTEXT: function SET_CONTEXT(state, action) {
+    return state.merge(fromJS(action.payload));
+  }
+}, Map());
+var rootOutcomeIds = handleActions({
+  SET_ROOT_OUTCOME_IDS: function SET_ROOT_OUTCOME_IDS(state, action) {
+    return state.merge(fromJS(action.payload));
+  }
+}, Map());
+export default combineReducers({
+  outcomes: outcomes,
+  rootOutcomeIds: rootOutcomeIds,
+  contexts: contexts
+});

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

@@ -0,0 +1,160 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+var _default_vi_number = Intl.NumberFormat("vi", { style: "decimal" }).format;
+import { Map } from 'immutable';
+import { createSelector } from 'reselect';
+import createCachedSelector, { LruObjectCache } from 're-reselect';
+import { getConfig } from "../config/selectors.js";
+
+function restrict(state, contextUuid) {
+  return state.getIn(['context', contextUuid]) || Map();
+}
+
+function getContextUuid(state, scope) {
+  return getConfig(state, scope).contextUuid || '';
+}
+
+export var isGroup = function isGroup(outcome) {
+  return outcome && (outcome.has_children || outcome.child_ids && outcome.child_ids.length > 0);
+};
+var getContextOutcomes = createSelector(function (state, scope) {
+  var uuid = getContextUuid(state, scope);
+  return restrict(state, 'outcomes').get(uuid);
+}, function (contextOutcomes) {
+  return contextOutcomes ? contextOutcomes.toJS() : {};
+});
+export var hasContextOutcomes = function hasContextOutcomes(state, scope) {
+  var contextOutcomes = getContextOutcomes(state, scope);
+  return Object.keys(contextOutcomes).length > 0;
+};
+export var getOutcome = createCachedSelector(function (state, scope, id) {
+  var uuid = getContextUuid(state, scope);
+  return restrict(state, 'outcomes').getIn([uuid, id.toString()]);
+}, function (outcome) {
+  return outcome ? outcome.toJS() : null;
+})({
+  keySelector: function keySelector(state, scope, id) {
+    return "".concat(getContextUuid(state, scope), "#").concat(id);
+  },
+  cacheObject: new LruObjectCache({
+    cacheSize: 50
+  })
+});
+export function isOutcomeGroup(state, scope, id) {
+  var outcome = getOutcome(state, scope, id);
+  return isGroup(outcome);
+}
+export var getRootOutcomeIds = createSelector(function (state, scope) {
+  var uuid = getContextUuid(state, scope);
+  return restrict(state, 'rootOutcomeIds').get(uuid);
+}, function (ids) {
+  return ids ? ids.toJS() : [];
+});
+export var hasRootOutcomes = function hasRootOutcomes(state, scope) {
+  var rootIds = getRootOutcomeIds(state, scope);
+  return rootIds.length > 0;
+};
+export var getContext = function getContext(state, contextUuid) {
+  var _state$getIn;
+
+  return (_state$getIn = state.getIn(['context', 'contexts', contextUuid])) === null || _state$getIn === void 0 ? void 0 : _state$getIn.toJS();
+};
+export var getContextByScope = createSelector(function (state) {
+  return state;
+}, getContextUuid, getContext);
+export var makeGetOutcomeSummary = createSelector([getContextOutcomes], function (outcomes) {
+  return function (id) {
+    return getCollectionDetails(outcomes, id).descriptor;
+  };
+});
+export var getCollectionData = createSelector(getContextOutcomes, function (outcomes) {
+  if (outcomes.length === 0) {
+    return; // return null so tree doesnt try to render an empty object
+  }
+
+  var collections = {};
+
+  for (var _i = 0, _Object$keys = Object.keys(outcomes); _i < _Object$keys.length; _i++) {
+    var id = _Object$keys[_i];
+
+    // eslint-disable-line no-unused-vars
+    if (!isCollectionId(outcomes, id)) {
+      continue; // eslint-disable-line no-continue
+    }
+
+    collections[id] = getCollectionDetails(outcomes, id); // eslint-disable-line immutable/no-mutation
+  }
+
+  return collections;
+});
+
+var isCollectionId = function isCollectionId(outcomes, id) {
+  var outcome = outcomes[id];
+  return outcome && (outcome.has_children || outcome.child_ids && outcome.child_ids.length > 0);
+};
+
+var getGroupText = function getGroupText(count) {
+  var _s, _n;
+
+  if (!(count > 0)) {
+    return;
+  }
+
+  return _default_vi_number(count) + " Nh\xF3m";
+};
+
+var getOutcomeText = function getOutcomeText(count) {
+  var _s2, _n2;
+
+  if (!(count > 0)) {
+    return;
+  }
+
+  return _default_vi_number(count) + " K\u1EBFt Qu\u1EA3";
+};
+
+export var getDescriptor = function getDescriptor(groupCount, outcomeCount) {
+  var groupText = getGroupText(groupCount);
+  var outcomeText = getOutcomeText(outcomeCount);
+
+  if (groupText && outcomeText) {
+    return "".concat(groupText, " | ").concat(outcomeText);
+  } else if (groupText) {
+    return groupText;
+  } else if (outcomeText) {
+    return outcomeText;
+  }
+
+  return '';
+};
+
+var getCollectionDetails = function getCollectionDetails(outcomes, id) {
+  var outcome = outcomes[id.toString()];
+  var childIds = outcome.child_ids || [];
+  var subcollections = childIds.filter(function (id) {
+    return isCollectionId(outcomes, id);
+  });
+  var groupCount = subcollections.length;
+  var outcomeCount = childIds.length - groupCount;
+  return _objectSpread(_objectSpread({}, outcome), {}, {
+    name: outcome.title,
+    collections: subcollections,
+    descriptor: getDescriptor(groupCount, outcomeCount)
+  });
+};
+
+export var getChildrenToLoad = function getChildrenToLoad(state, scope, id) {
+  var outcome = getOutcome(state, scope, id);
+
+  if (!outcome || outcome.is_partial) {
+    return [id];
+  }
+
+  if (!outcome.child_ids) {
+    return [];
+  }
+
+  return outcome.child_ids.filter(function (id) {
+    var o = getOutcome(state, scope, id);
+    return o.is_partial && o.has_children;
+  });
+};

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

@@ -0,0 +1,82 @@
+import { expect } from 'chai';
+import { Map } from 'immutable';
+import sinon from 'sinon';
+import * as constants from "../../../constants.js";
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+import * as actions from "../actions.js";
+var scopedActions = scopeActions(actions);
+var response = ['feature_1', 'feature_2'];
+describe('features/actions', function () {
+  describe('setFeatures', function () {
+    it('creates an action', function () {
+      var action = actions.setFeatures(['feature_1']);
+      expect(action.type).to.equal(constants.SET_FEATURES);
+      expect(action.payload).to.deep.equal(['feature_1']);
+    });
+  });
+  describe('loadFeatures', function () {
+    describe('with existing feature flags', function () {
+      var getFeaturesStub;
+      beforeEach(function () {
+        getFeaturesStub = sinon.stub(constants, 'getFeatureFlags').returns(['feature_1', 'feature_2']);
+      });
+      afterEach(function () {
+        getFeaturesStub.restore();
+      });
+      it('calls outcome service to load features', function () {
+        var service = {
+          getFeatures: sinon.stub().returns(Promise.resolve(response))
+        };
+        var store = createMockStore(Map(), service);
+        return store.dispatch(actions.loadFeatures()).then(function () {
+          expect(service.getFeatures.calledOnce).to.be.true;
+          return null;
+        });
+      });
+      it('dispatches setFeatures on outcome service success', function () {
+        var service = {
+          getFeatures: sinon.stub().returns(Promise.resolve(response))
+        };
+        var store = createMockStore(Map(), service);
+        return store.dispatch(actions.loadFeatures()).then(function () {
+          expect(store.getActions()).to.have.length(2);
+          expect(store.getActions()).to.deep.include(scopedActions.setFeatures(['feature_1', 'feature_2']));
+          return null;
+        });
+      });
+      it('dispatches setError on outcome service failure', function () {
+        var error = {
+          message: 'foo bar baz'
+        };
+        var service = {
+          getFeatures: sinon.stub().returns(Promise.reject(error))
+        };
+        var store = createMockStore(Map(), service);
+        return store.dispatch(actions.loadFeatures()).then(function () {
+          expect(store.getActions()).to.have.length(2);
+          expect(store.getActions()[1]).to.deep.equal(scopedActions.setError(error));
+          return null;
+        });
+      });
+    });
+    describe('with no existing feature flags', function () {
+      var getFeaturesStub;
+      beforeEach(function () {
+        getFeaturesStub = sinon.stub(constants, 'getFeatureFlags').returns([]);
+      });
+      afterEach(function () {
+        getFeaturesStub.restore();
+      });
+      it('does not call the outcome service to load features', function () {
+        var service = {
+          getFeatures: sinon.stub().returns(Promise.resolve(response))
+        };
+        var store = createMockStore(Map(), service);
+        return store.dispatch(actions.loadFeatures()).then(function () {
+          expect(service.getFeatures.calledOnce).to.be.false;
+          return null;
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,21 @@
+import { expect } from 'chai';
+import { SET_FEATURES } from "../../../constants.js";
+import reducer from "../reducers.js";
+describe('features/reducers', function () {
+  var state = [];
+
+  var reduce = function reduce(state, type, payload) {
+    return reducer(state, {
+      type: type,
+      payload: payload
+    });
+  };
+
+  context('features', function () {
+    it('updates features list', function () {
+      var features = ['feature_1', 'feature_2'];
+      var newState = reduce(state, SET_FEATURES, features);
+      expect(newState.toJS()).to.deep.equal(['feature_1', 'feature_2']);
+    });
+  });
+});

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

@@ -0,0 +1,21 @@
+import { expect } from 'chai';
+import { List, fromJS } from 'immutable';
+import { getFeatures } from "../selectors.js";
+describe('context/selectors', function () {
+  var state = fromJS({
+    features: ['feature_1', 'feature_2']
+  });
+  describe('getFeatures', function () {
+    it('retrieves the list of features', function () {
+      expect(getFeatures(state)).to.deep.equal(['feature_1', 'feature_2']);
+    });
+    it('returns [] when empty', function () {
+      var newState = state.setIn(['features'], List());
+      expect(getFeatures(newState)).to.deep.equal([]);
+    });
+    it('returns [] when unset', function () {
+      var newState = state.deleteIn(['features']);
+      expect(getFeatures(newState)).to.deep.equal([]);
+    });
+  });
+});

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

@@ -0,0 +1,25 @@
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { SET_ERROR, SET_FEATURES, getFeatureFlags } from "../../constants.js";
+export var setError = createAction(SET_ERROR);
+export var setFeatures = createAction(SET_FEATURES);
+export var loadFeatures = function loadFeatures(host, jwt) {
+  return function (dispatch) {
+    if (getFeatureFlags().length === 0) {
+      return Promise.resolve();
+    }
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getFeatures',
+        args: [host, jwt]
+      }
+    }).then(function (json) {
+      return dispatch(setFeatures(json));
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};

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

@@ -0,0 +1,7 @@
+import { handleActions } from 'redux-actions';
+import { fromJS, List } from 'immutable';
+export default handleActions({
+  SET_FEATURES: function SET_FEATURES(state, action) {
+    return fromJS(action.payload);
+  }
+}, List());

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

@@ -0,0 +1,6 @@
+import { createSelector } from 'reselect';
+export var getFeatures = createSelector(function (state) {
+  return state.getIn(['features']);
+}, function (features) {
+  return features ? features.toJS() : [];
+});