@pie-element/ebsr 9.1.2-next.72 → 9.2.0-next.1

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [9.2.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/ebsr@9.1.1...@pie-element/ebsr@9.2.0) (2023-12-19)
+
+
+### Bug Fixes
+
+* update pie-lib/pie-toolbox PD-2068 ([34eccd5](https://github.com/pie-framework/pie-elements/commit/34eccd52c44259eddf3e2b816b00b82f83bc2bf8))
+
+
+### Features
+
+* update pie-lib/pie-toolbox PD-2555 ([86d4fd9](https://github.com/pie-framework/pie-elements/commit/86d4fd909180dd1fcbc446bd8b29c23af21a1c69))
+* update pie-lib/pie-toolbox PD-3307, PD-2067, PD-3271, PD-3041, PD-2068 ([2eabcbd](https://github.com/pie-framework/pie-elements/commit/2eabcbd036e318bb24552f4140ca7384ad865951))
+
+
+
+
+
 ## [9.1.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/ebsr@9.1.0...@pie-element/ebsr@9.1.1) (2023-11-27)
 
 

package/configure/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [9.1.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/ebsr-configure@9.0.3...@pie-element/ebsr-configure@9.1.0) (2023-12-19)
+
+
+### Bug Fixes
+
+* update pie-lib/pie-toolbox PD-2068 ([34eccd5](https://github.com/pie-framework/pie-elements/commit/34eccd52c44259eddf3e2b816b00b82f83bc2bf8))
+
+
+### Features
+
+* update pie-lib/pie-toolbox PD-2555 ([86d4fd9](https://github.com/pie-framework/pie-elements/commit/86d4fd909180dd1fcbc446bd8b29c23af21a1c69))
+* update pie-lib/pie-toolbox PD-3307, PD-2067, PD-3271, PD-3041, PD-2068 ([2eabcbd](https://github.com/pie-framework/pie-elements/commit/2eabcbd036e318bb24552f4140ca7384ad865951))
+
+
+
+
+
 ## [9.0.3](https://github.com/pie-framework/pie-elements/compare/@pie-element/ebsr-configure@9.0.2...@pie-element/ebsr-configure@9.0.3) (2023-11-27)
 
 

package/configure/lib/__tests__/index.test.js

@@ -0,0 +1,434 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _enzyme = require("enzyme");
+
+var _pieConfigureEvents = require("@pie-framework/pie-configure-events");
+
+var _configUi = require("@pie-lib/pie-toolbox/config-ui");
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _defaults = _interopRequireDefault(require("../defaults"));
+
+var _main = require("../main");
+
+var _index = _interopRequireDefault(require("../index"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+jest.mock('react-dom', function () {
+  return {
+    render: jest.fn()
+  };
+});
+jest.mock('@pie-framework/pie-configure-events', function () {
+  return {
+    ModelUpdatedEvent: function ModelUpdatedEvent(update) {
+      return {
+        update: update,
+        preventDefault: jest.fn(),
+        stopImmediatePropagation: jest.fn()
+      };
+    }
+  };
+});
+jest.mock('@pie-lib/pie-toolbox/config-ui', function () {
+  return {
+    choiceUtils: {
+      firstAvailableIndex: jest.fn()
+    },
+    settings: {
+      Panel: function Panel(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", props);
+      },
+      toggle: jest.fn(),
+      radio: jest.fn(),
+      dropdown: jest.fn()
+    },
+    layout: {
+      ConfigLayout: function ConfigLayout(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", null, props.children);
+      }
+    }
+  };
+});
+jest.mock('@pie-element/multiple-choice/configure/lib', function () {
+  return /*#__PURE__*/(0, _createClass2["default"])(function MockConfigure() {
+    (0, _classCallCheck2["default"])(this, MockConfigure);
+  });
+});
+var PART_A = 'partA';
+var PART_B = 'partB';
+
+var createDefaultModel = function createDefaultModel(model) {
+  var newModel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return _objectSpread(_objectSpread(_objectSpread({}, model), newModel), {}, {
+    partA: _objectSpread(_objectSpread({}, model.partA), newModel.partA),
+    partB: _objectSpread(_objectSpread({}, model.partB), newModel.partB)
+  });
+};
+
+var model = createDefaultModel(_defaults["default"].model, {
+  partA: {
+    choiceMode: 'radio',
+    choices: [{
+      value: 'yellow',
+      label: 'Yellow',
+      correct: true,
+      feedback: {
+        type: 'custom',
+        value: 'foo'
+      }
+    }, {
+      value: 'green',
+      label: 'Green',
+      feedback: {
+        type: 'default'
+      }
+    }],
+    choicePrefix: 'numbers',
+    prompt: "prompt ".concat(PART_A),
+    errors: {}
+  },
+  partB: {
+    choiceMode: 'radio',
+    choices: [{
+      value: 'orange',
+      label: 'Orange',
+      correct: true,
+      feedback: {
+        type: 'custom',
+        value: 'foo'
+      }
+    }, {
+      value: 'purple',
+      label: 'Purple',
+      feedback: {
+        type: 'default'
+      }
+    }],
+    choicePrefix: 'numbers',
+    prompt: "prompt ".concat(PART_B),
+    errors: {}
+  }
+});
+describe('index', function () {
+  var Def;
+  var el;
+  var onModelChanged = jest.fn();
+  var onConfigurationChanged = jest.fn();
+  var main;
+  beforeAll(function () {
+    Def = require('../index')["default"];
+  });
+  beforeEach(function () {
+    el = new Def();
+    el.model = model;
+    el.configuration = _defaults["default"].configuration;
+    el.onModelChanged = onModelChanged;
+    el.onConfigurationChanged = onConfigurationChanged;
+    el.connectedCallback();
+    el.dispatchEvent = el.onModelUpdated;
+    main = (0, _enzyme.mount)( /*#__PURE__*/_react["default"].createElement(_main.Main, {
+      classes: {},
+      model: el._model,
+      configuration: _defaults["default"].configuration,
+      onConfigurationChanged: el.onConfigurationChanged,
+      onModelChanged: el.onModelChanged
+    })); // mock onModelChanged to dispatch a MODEL_UPDATED event (as multiple-choice does)
+
+    main.instance().partA.onModelChanged = function (m) {
+      var event = new _pieConfigureEvents.ModelUpdatedEvent(m, false);
+      el.dispatchEvent(_objectSpread(_objectSpread({}, event), {}, {
+        target: {
+          getAttribute: jest.fn().mockReturnValue('A')
+        }
+      }));
+    };
+
+    main.instance().partB.onModelChanged = function (m) {
+      var event = new _pieConfigureEvents.ModelUpdatedEvent(m, false);
+      el.dispatchEvent(_objectSpread(_objectSpread({}, event), {}, {
+        target: {
+          getAttribute: jest.fn().mockReturnValue('B')
+        }
+      }));
+    };
+  });
+  describe('createDefaultModel', function () {
+    it('default-snapshot', function () {
+      var m = _index["default"].createDefaultModel({});
+
+      expect(m).toMatchSnapshot();
+    });
+    it('with-overrides-snapshot', function () {
+      var m = _index["default"].createDefaultModel({
+        partA: {
+          rationale: 'foo',
+          teacherInstructions: 'ti'
+        }
+      });
+
+      expect(m).toMatchSnapshot();
+    });
+  });
+  describe('set model', function () {
+    it('calls ReactDOM.render', function () {
+      el.model = model;
+      expect(el._model).toEqual(model);
+      expect(_reactDom["default"].render).toHaveBeenCalled();
+    });
+    it('should have set the model for partA and partB', function () {
+      expect(main.instance().partA._model).toEqual(model.partA);
+      expect(main.instance().partB._model).toEqual(model.partB);
+    });
+  });
+  describe('set configuration', function () {
+    it('calls ReactDOM.render', function () {
+      el.configuration = _defaults["default"].configuration;
+      expect(_reactDom["default"].render).toHaveBeenCalled();
+    });
+    it('should have set the configuration for partA and partB', function () {
+      expect(main.instance().partA.configuration).toEqual(_objectSpread(_objectSpread({}, _defaults["default"].configuration.partA), {}, {
+        partLabels: _defaults["default"].configuration.partLabels,
+        settingsPanelDisabled: true
+      }));
+      expect(main.instance().partB.configuration).toEqual(_objectSpread(_objectSpread({}, _defaults["default"].configuration.partB), {}, {
+        partLabels: _defaults["default"].configuration.partLabels,
+        settingsPanelDisabled: true
+      }));
+    });
+  });
+
+  var assetOnModelUpdated = function assetOnModelUpdated(label, key, updatedPart, expected) {
+    it(label, function () {
+      var event = new _pieConfigureEvents.ModelUpdatedEvent(updatedPart, false);
+      el.dispatchEvent(_objectSpread(_objectSpread({}, event), {}, {
+        target: {
+          getAttribute: jest.fn().mockReturnValue(key)
+        }
+      }));
+      expect(_reactDom["default"].render).toBeCalled();
+      expect(el._model["part".concat(key)]).toEqual(expected);
+    });
+  };
+
+  describe('onModelUpdated', function () {
+    assetOnModelUpdated('dispatching MODEL_UPDATED updates model.partA', 'A', {
+      updatedA: true
+    }, {
+      updatedA: true
+    });
+    assetOnModelUpdated('dispatching MODEL_UPDATED updates model.partB', 'B', {
+      updatedB: true
+    }, {
+      updatedB: true
+    });
+    assetOnModelUpdated('dispatching MODEL_UPDATED with update undefined does not update model.partA', 'A', undefined, createDefaultModel(model).partA);
+    assetOnModelUpdated('dispatching MODEL_UPDATED with update undefined does not update model.partB', 'B', undefined, createDefaultModel(model).partB);
+  });
+
+  var assetPartUpdate = function assetPartUpdate(label, key, updatedModel) {
+    it("".concat(key, " - ").concat(label), function () {
+      main.instance()[key].onModelChanged(updatedModel);
+      expect(el._model[key]).toEqual(updatedModel);
+      expect(_reactDom["default"].render).toBeCalled();
+    });
+  };
+
+  describe('part update', function () {
+    assetPartUpdate('Dispatching Model Updated Event will update Teacher Instructions', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      teacherInstructions: 'Part A Teacher Instructions'
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Teacher Instructions', 'partB', _objectSpread(_objectSpread({}, model.partB), {}, {
+      teacherInstructions: 'Part B Teacher Instructions'
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Prompt', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      prompt: 'Prompt A'
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Prompt', 'partB', _objectSpread(_objectSpread({}, model.partA), {}, {
+      prompt: 'Prompt B'
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - ADD CHOICE', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      choices: [].concat((0, _toConsumableArray2["default"])(model.partA.choices), [{
+        label: 'label',
+        value: _configUi.choiceUtils.firstAvailableIndex(model.partA.choices.map(function (c) {
+          return c.value;
+        }), 0),
+        feedback: {
+          type: 'none'
+        }
+      }])
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - ADD CHOICE', 'partB', _objectSpread(_objectSpread({}, model.partB), {}, {
+      choices: [].concat((0, _toConsumableArray2["default"])(model.partB.choices), [{
+        label: 'label',
+        value: _configUi.choiceUtils.firstAvailableIndex(model.partB.choices.map(function (c) {
+          return c.value;
+        }), 0),
+        feedback: {
+          type: 'none'
+        }
+      }])
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - REMOVE CHOICE', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      choices: model.partA.choices.splice(0, 2)
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - REMOVE CHOICE', 'partB', _objectSpread(_objectSpread({}, model.partB), {}, {
+      choices: model.partB.choices.splice(0, 2)
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - CHANGE CHOICE', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      choices: model.partA.choices.splice(1, 1, {
+        correct: true,
+        value: 'green',
+        label: function label(value) {
+          return value.charAt(0).toUpperCase() + value.slice(1);
+        },
+        feedback: {
+          type: 'none',
+          value: ''
+        }
+      })
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices - CHANGE CHOICE', 'partB', _objectSpread(_objectSpread({}, model.partB), {}, {
+      choices: model.partB.choices.splice(1, 1, {
+        correct: true,
+        value: 'green',
+        label: function label(value) {
+          return value.charAt(0).toUpperCase() + value.slice(1);
+        },
+        feedback: {
+          type: 'none',
+          value: ''
+        }
+      })
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices', 'partA', _objectSpread(_objectSpread({}, model.partA), {}, {
+      choices: []
+    }));
+    assetPartUpdate('Dispatching Model Updated Event will update Choices', 'partB', _objectSpread(_objectSpread({}, model.partB), {}, {
+      choices: []
+    }));
+  });
+});
+describe('main', function () {
+  var Def;
+  var el;
+  var main;
+  beforeAll(function () {
+    Def = require('../index')["default"];
+  });
+  beforeEach(function () {
+    el = new Def();
+    el.model = model;
+    el.configuration = _defaults["default"].configuration;
+    el.dispatchEvent = el.onModelUpdated;
+    main = (0, _enzyme.mount)( /*#__PURE__*/_react["default"].createElement(_main.Main, {
+      classes: {},
+      model: el._model,
+      configuration: _defaults["default"].configuration,
+      onConfigurationChanged: el.onConfigurationChanged,
+      onModelChanged: el.onModelChanged
+    }));
+  });
+
+  var assertOnModelChanged = function assertOnModelChanged(label, updatedModel, expected) {
+    it(label, function () {
+      main.instance().props.onModelChanged(updatedModel);
+      expect(el._model).toEqual(createDefaultModel(model, expected));
+    });
+  };
+
+  describe('onModelChanged', function () {
+    assertOnModelChanged('does not change the model', {}, model);
+    assertOnModelChanged('changes partA - checkbox', {
+      partA: {
+        choiceMode: 'checkbox'
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partA: {
+        choiceMode: 'checkbox'
+      }
+    }));
+    assertOnModelChanged('changes partA - choicePrefix', {
+      partA: {
+        choicePrefix: 'numbers'
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partA: {
+        choicePrefix: 'numbers'
+      }
+    }));
+    assertOnModelChanged('changes partA - partialScoring', {
+      partialScoring: false
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partialScoring: false
+    }));
+    assertOnModelChanged('changes partA - lockChoiceOrder', {
+      partA: {
+        lockChoiceOrder: true
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partA: {
+        lockChoiceOrder: true
+      }
+    }));
+    assertOnModelChanged('changes partA - scoringType', {
+      scoringType: 'auto'
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      scoringType: 'auto'
+    }));
+    assertOnModelChanged('changes partB - checkbox', {
+      partB: {
+        choiceMode: 'checkbox'
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partB: {
+        choiceMode: 'checkbox'
+      }
+    }));
+    assertOnModelChanged('changes partB - choicePrefix', {
+      partB: {
+        choicePrefix: 'numbers'
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partB: {
+        choicePrefix: 'numbers'
+      }
+    }));
+    assertOnModelChanged('changes partB - partialScoring', {
+      partialScoring: false
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partialScoring: false
+    }));
+    assertOnModelChanged('changes partB - lockChoiceOrder', {
+      partB: {
+        lockChoiceOrder: true
+      }
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      partB: {
+        lockChoiceOrder: true
+      }
+    }));
+    assertOnModelChanged('changes partB - scoringType', {
+      scoringType: 'auto'
+    }, _objectSpread(_objectSpread({}, model), {}, {
+      scoringType: 'auto'
+    }));
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/index.test.js"],"names":["jest","mock","render","fn","ModelUpdatedEvent","update","preventDefault","stopImmediatePropagation","choiceUtils","firstAvailableIndex","settings","Panel","props","toggle","radio","dropdown","layout","ConfigLayout","children","PART_A","PART_B","createDefaultModel","model","newModel","partA","partB","defaults","choiceMode","choices","value","label","correct","feedback","type","choicePrefix","prompt","errors","describe","Def","el","onModelChanged","onConfigurationChanged","main","beforeAll","require","beforeEach","configuration","connectedCallback","dispatchEvent","onModelUpdated","_model","instance","m","event","target","getAttribute","mockReturnValue","it","EbsrConfigure","expect","toMatchSnapshot","rationale","teacherInstructions","toEqual","ReactDOM","toHaveBeenCalled","partLabels","settingsPanelDisabled","assetOnModelUpdated","key","updatedPart","expected","toBeCalled","updatedA","updatedB","undefined","assetPartUpdate","updatedModel","utils","map","c","splice","charAt","toUpperCase","slice","assertOnModelChanged","partialScoring","lockChoiceOrder","scoringType"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { mount } from 'enzyme';\nimport { ModelUpdatedEvent } from '@pie-framework/pie-configure-events';\nimport { choiceUtils as utils } from '@pie-lib/pie-toolbox/config-ui';\nimport ReactDOM from 'react-dom';\nimport defaults from '../defaults';\nimport { Main } from '../main';\nimport EbsrConfigure from '../index';\n\njest.mock('react-dom', () => ({\n  render: jest.fn(),\n}));\n\njest.mock('@pie-framework/pie-configure-events', () => ({\n  ModelUpdatedEvent: (update) => {\n    return {\n      update,\n      preventDefault: jest.fn(),\n      stopImmediatePropagation: jest.fn(),\n    };\n  },\n}));\n\njest.mock('@pie-lib/pie-toolbox/config-ui', () => ({\n  choiceUtils: {\n    firstAvailableIndex: jest.fn(),\n  },\n  settings: {\n    Panel: (props) => <div {...props} />,\n    toggle: jest.fn(),\n    radio: jest.fn(),\n    dropdown: jest.fn(),\n  },\n  layout: {\n    ConfigLayout: (props) => <div>{props.children}</div>,\n  },\n}));\n\njest.mock('@pie-element/multiple-choice/configure/lib', () => class MockConfigure {});\n\nconst PART_A = 'partA';\nconst PART_B = 'partB';\n\nconst createDefaultModel = (model, newModel = {}) => ({\n  ...model,\n  ...newModel,\n  partA: {\n    ...model.partA,\n    ...newModel.partA,\n  },\n  partB: {\n    ...model.partB,\n    ...newModel.partB,\n  },\n});\n\nconst model = createDefaultModel(defaults.model, {\n  partA: {\n    choiceMode: 'radio',\n    choices: [\n      {\n        value: 'yellow',\n        label: 'Yellow',\n        correct: true,\n        feedback: {\n          type: 'custom',\n          value: 'foo',\n        },\n      },\n      {\n        value: 'green',\n        label: 'Green',\n        feedback: {\n          type: 'default',\n        },\n      },\n    ],\n    choicePrefix: 'numbers',\n    prompt: `prompt ${PART_A}`,\n    errors: {},\n  },\n  partB: {\n    choiceMode: 'radio',\n    choices: [\n      {\n        value: 'orange',\n        label: 'Orange',\n        correct: true,\n        feedback: {\n          type: 'custom',\n          value: 'foo',\n        },\n      },\n      {\n        value: 'purple',\n        label: 'Purple',\n        feedback: {\n          type: 'default',\n        },\n      },\n    ],\n    choicePrefix: 'numbers',\n    prompt: `prompt ${PART_B}`,\n    errors: {},\n  },\n});\n\ndescribe('index', () => {\n  let Def;\n  let el;\n  let onModelChanged = jest.fn();\n  let onConfigurationChanged = jest.fn();\n  let main;\n\n  beforeAll(() => {\n    Def = require('../index').default;\n  });\n\n  beforeEach(() => {\n    el = new Def();\n    el.model = model;\n    el.configuration = defaults.configuration;\n    el.onModelChanged = onModelChanged;\n    el.onConfigurationChanged = onConfigurationChanged;\n    el.connectedCallback();\n    el.dispatchEvent = el.onModelUpdated;\n\n    main = mount(\n      <Main\n        classes={{}}\n        model={el._model}\n        configuration={defaults.configuration}\n        onConfigurationChanged={el.onConfigurationChanged}\n        onModelChanged={el.onModelChanged}\n      />,\n    );\n\n    // mock onModelChanged to dispatch a MODEL_UPDATED event (as multiple-choice does)\n    main.instance().partA.onModelChanged = (m) => {\n      const event = new ModelUpdatedEvent(m, false);\n\n      el.dispatchEvent({\n        ...event,\n        target: {\n          getAttribute: jest.fn().mockReturnValue('A'),\n        },\n      });\n    };\n    main.instance().partB.onModelChanged = (m) => {\n      const event = new ModelUpdatedEvent(m, false);\n\n      el.dispatchEvent({\n        ...event,\n        target: {\n          getAttribute: jest.fn().mockReturnValue('B'),\n        },\n      });\n    };\n  });\n\n  describe('createDefaultModel', () => {\n    it('default-snapshot', () => {\n      const m = EbsrConfigure.createDefaultModel({});\n      expect(m).toMatchSnapshot();\n    });\n    it('with-overrides-snapshot', () => {\n      const m = EbsrConfigure.createDefaultModel({\n        partA: { rationale: 'foo', teacherInstructions: 'ti' },\n      });\n      expect(m).toMatchSnapshot();\n    });\n  });\n\n  describe('set model', () => {\n    it('calls ReactDOM.render', () => {\n      el.model = model;\n\n      expect(el._model).toEqual(model);\n      expect(ReactDOM.render).toHaveBeenCalled();\n    });\n\n    it('should have set the model for partA and partB', () => {\n      expect(main.instance().partA._model).toEqual(model.partA);\n      expect(main.instance().partB._model).toEqual(model.partB);\n    });\n  });\n\n  describe('set configuration', () => {\n    it('calls ReactDOM.render', () => {\n      el.configuration = defaults.configuration;\n\n      expect(ReactDOM.render).toHaveBeenCalled();\n    });\n\n    it('should have set the configuration for partA and partB', () => {\n      expect(main.instance().partA.configuration).toEqual({\n        ...defaults.configuration.partA,\n        partLabels: defaults.configuration.partLabels,\n        settingsPanelDisabled: true,\n      });\n      expect(main.instance().partB.configuration).toEqual({\n        ...defaults.configuration.partB,\n        partLabels: defaults.configuration.partLabels,\n        settingsPanelDisabled: true,\n      });\n    });\n  });\n\n  const assetOnModelUpdated = (label, key, updatedPart, expected) => {\n    it(label, () => {\n      const event = new ModelUpdatedEvent(updatedPart, false);\n\n      el.dispatchEvent({\n        ...event,\n        target: {\n          getAttribute: jest.fn().mockReturnValue(key),\n        },\n      });\n\n      expect(ReactDOM.render).toBeCalled();\n      expect(el._model[`part${key}`]).toEqual(expected);\n    });\n  };\n\n  describe('onModelUpdated', () => {\n    assetOnModelUpdated('dispatching MODEL_UPDATED updates model.partA', 'A', { updatedA: true }, { updatedA: true });\n    assetOnModelUpdated('dispatching MODEL_UPDATED updates model.partB', 'B', { updatedB: true }, { updatedB: true });\n\n    assetOnModelUpdated(\n      'dispatching MODEL_UPDATED with update undefined does not update model.partA',\n      'A',\n      undefined,\n      createDefaultModel(model).partA,\n    );\n    assetOnModelUpdated(\n      'dispatching MODEL_UPDATED with update undefined does not update model.partB',\n      'B',\n      undefined,\n      createDefaultModel(model).partB,\n    );\n  });\n\n  const assetPartUpdate = (label, key, updatedModel) => {\n    it(`${key} - ${label}`, () => {\n      main.instance()[key].onModelChanged(updatedModel);\n\n      expect(el._model[key]).toEqual(updatedModel);\n      expect(ReactDOM.render).toBeCalled();\n    });\n  };\n\n  describe('part update', () => {\n    assetPartUpdate('Dispatching Model Updated Event will update Teacher Instructions', 'partA', {\n      ...model.partA,\n      teacherInstructions: 'Part A Teacher Instructions',\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Teacher Instructions', 'partB', {\n      ...model.partB,\n      teacherInstructions: 'Part B Teacher Instructions',\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Prompt', 'partA', {\n      ...model.partA,\n      prompt: 'Prompt A',\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Prompt', 'partB', {\n      ...model.partA,\n      prompt: 'Prompt B',\n    });\n\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - ADD CHOICE', 'partA', {\n      ...model.partA,\n      choices: [\n        ...model.partA.choices,\n        {\n          label: 'label',\n          value: utils.firstAvailableIndex(\n            model.partA.choices.map((c) => c.value),\n            0,\n          ),\n          feedback: {\n            type: 'none',\n          },\n        },\n      ],\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - ADD CHOICE', 'partB', {\n      ...model.partB,\n      choices: [\n        ...model.partB.choices,\n        {\n          label: 'label',\n          value: utils.firstAvailableIndex(\n            model.partB.choices.map((c) => c.value),\n            0,\n          ),\n          feedback: {\n            type: 'none',\n          },\n        },\n      ],\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - REMOVE CHOICE', 'partA', {\n      ...model.partA,\n      choices: model.partA.choices.splice(0, 2),\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - REMOVE CHOICE', 'partB', {\n      ...model.partB,\n      choices: model.partB.choices.splice(0, 2),\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - CHANGE CHOICE', 'partA', {\n      ...model.partA,\n      choices: model.partA.choices.splice(1, 1, {\n        correct: true,\n        value: 'green',\n        label: (value) => value.charAt(0).toUpperCase() + value.slice(1),\n        feedback: {\n          type: 'none',\n          value: '',\n        },\n      }),\n    });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices - CHANGE CHOICE', 'partB', {\n      ...model.partB,\n      choices: model.partB.choices.splice(1, 1, {\n        correct: true,\n        value: 'green',\n        label: (value) => value.charAt(0).toUpperCase() + value.slice(1),\n        feedback: {\n          type: 'none',\n          value: '',\n        },\n      }),\n    });\n\n    assetPartUpdate('Dispatching Model Updated Event will update Choices', 'partA', { ...model.partA, choices: [] });\n    assetPartUpdate('Dispatching Model Updated Event will update Choices', 'partB', { ...model.partB, choices: [] });\n  });\n});\n\ndescribe('main', () => {\n  let Def;\n  let el;\n  let main;\n\n  beforeAll(() => {\n    Def = require('../index').default;\n  });\n\n  beforeEach(() => {\n    el = new Def();\n    el.model = model;\n    el.configuration = defaults.configuration;\n    el.dispatchEvent = el.onModelUpdated;\n\n    main = mount(\n      <Main\n        classes={{}}\n        model={el._model}\n        configuration={defaults.configuration}\n        onConfigurationChanged={el.onConfigurationChanged}\n        onModelChanged={el.onModelChanged}\n      />,\n    );\n  });\n\n  const assertOnModelChanged = (label, updatedModel, expected) => {\n    it(label, () => {\n      main.instance().props.onModelChanged(updatedModel);\n\n      expect(el._model).toEqual(createDefaultModel(model, expected));\n    });\n  };\n\n  describe('onModelChanged', () => {\n    assertOnModelChanged('does not change the model', {}, model);\n    assertOnModelChanged(\n      'changes partA - checkbox',\n      {\n        partA: {\n          choiceMode: 'checkbox',\n        },\n      },\n      {\n        ...model,\n        partA: {\n          choiceMode: 'checkbox',\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partA - choicePrefix',\n      {\n        partA: {\n          choicePrefix: 'numbers',\n        },\n      },\n      {\n        ...model,\n        partA: {\n          choicePrefix: 'numbers',\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partA - partialScoring',\n      {\n        partialScoring: false,\n      },\n      {\n        ...model,\n        partialScoring: false,\n      },\n    );\n    assertOnModelChanged(\n      'changes partA - lockChoiceOrder',\n      {\n        partA: {\n          lockChoiceOrder: true,\n        },\n      },\n      {\n        ...model,\n        partA: {\n          lockChoiceOrder: true,\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partA - scoringType',\n      {\n        scoringType: 'auto',\n      },\n      {\n        ...model,\n        scoringType: 'auto',\n      },\n    );\n    assertOnModelChanged(\n      'changes partB - checkbox',\n      {\n        partB: {\n          choiceMode: 'checkbox',\n        },\n      },\n      {\n        ...model,\n        partB: {\n          choiceMode: 'checkbox',\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partB - choicePrefix',\n      {\n        partB: {\n          choicePrefix: 'numbers',\n        },\n      },\n      {\n        ...model,\n        partB: {\n          choicePrefix: 'numbers',\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partB - partialScoring',\n      {\n        partialScoring: false,\n      },\n      {\n        ...model,\n        partialScoring: false,\n      },\n    );\n    assertOnModelChanged(\n      'changes partB - lockChoiceOrder',\n      {\n        partB: {\n          lockChoiceOrder: true,\n        },\n      },\n      {\n        ...model,\n        partB: {\n          lockChoiceOrder: true,\n        },\n      },\n    );\n    assertOnModelChanged(\n      'changes partB - scoringType',\n      {\n        scoringType: 'auto',\n      },\n      {\n        ...model,\n        scoringType: 'auto',\n      },\n    );\n  });\n});\n"]}

package/configure/lib/defaults.js

@@ -148,4 +148,4 @@ var _default = {
   }
 };
 exports["default"] = _default;
-//# sourceMappingURL=defaults.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/defaults.js"],"names":["defaultConfig","addChoiceButton","settings","label","choiceMode","choicePrefix","deleteChoice","feedback","lockChoiceOrder","prompt","rationale","settingsPanelDisabled","studentInstructions","teacherInstructions","choicesLayout","gridColumns","spellCheck","enabled","maxImageWidth","choices","maxImageHeight","mathMlOptions","mmlOutput","mmlEditing","partModel","base","rationaleEnabled","feedbackEnabled","promptEnabled","teacherInstructionsEnabled","studentInstructionsEnabled","spellCheckEnabled","model","partLabels","partLabelType","partA","partB","configuration","partialScoring","scoringType","language","languageChoices","options"],"mappings":"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","sourcesContent":["import cloneDeep from 'lodash/cloneDeep';\n\nconst defaultConfig = {\n  addChoiceButton: {\n    settings: true,\n    label: 'Add a Choice',\n  },\n  choiceMode: {\n    settings: true,\n    label: 'Response Type',\n  },\n  choicePrefix: {\n    settings: true,\n    label: 'Choice Labels',\n  },\n  deleteChoice: {\n    settings: true,\n  },\n  feedback: {\n    settings: true,\n    label: 'Feedback',\n  },\n  lockChoiceOrder: {\n    settings: true,\n    label: 'Lock Choice Order',\n  },\n  prompt: {\n    settings: true,\n    label: 'Prompt',\n  },\n  rationale: {\n    settings: true,\n    label: 'Rationale',\n  },\n  settingsPanelDisabled: true,\n  studentInstructions: {\n    settings: false,\n    label: 'Student Instructions',\n  },\n  teacherInstructions: {\n    settings: true,\n    label: 'Teacher Instructions',\n  },\n  choicesLayout: {\n    settings: false,\n    label: 'Choices Layout',\n  },\n  gridColumns: {\n    label: 'Grid columns',\n  },\n  spellCheck: {\n    label: 'Spellcheck',\n    settings: false,\n    enabled: true,\n  },\n  maxImageWidth: {\n    teacherInstructions: 300,\n    prompt: 300,\n    rationale: 636,\n    choices: 636,\n  },\n  maxImageHeight: {\n    teacherInstructions: 300,\n    prompt: 300,\n    rationale: 300,\n    choices: 300,\n  },\n  mathMlOptions: {\n    mmlOutput: false,\n    mmlEditing: false,\n  },\n};\n\nconst partModel = (base) => ({\n  choiceMode: 'radio',\n  choices: [],\n  choicePrefix: 'numbers',\n  prompt: 'Prompt',\n  rationaleEnabled: true,\n  feedbackEnabled: false,\n  promptEnabled: true,\n  teacherInstructions: '',\n  rationale: '',\n  teacherInstructionsEnabled: true,\n  studentInstructionsEnabled: true,\n  spellCheckEnabled: true,\n  choicesLayout: 'vertical',\n  gridColumns: '2',\n  ...base,\n});\n\nexport default {\n  model: {\n    partLabels: true,\n    partLabelType: 'Letters',\n    // partialScoring: false,\n    partA: partModel({ prompt: 'Prompt A' }),\n    partB: partModel({ prompt: 'Prompt B' }),\n  },\n  configuration: {\n    partialScoring: {\n      label: 'Allow Partial Scoring',\n      // this will turn off partial scoring toggle in the settings tab by default for the interaction\n      // as we'd like partial scoring to be controlled from the environment entirely\n      // if any other consumers would like to enable it for themselves, they can do so from their model directly.\n      settings: false,\n    },\n    scoringType: {\n      settings: false,\n      label: 'Scoring Type',\n    },\n    partA: cloneDeep(defaultConfig),\n    partB: cloneDeep(defaultConfig),\n    partLabels: {\n      settings: true,\n      label: 'Part Labels',\n    },\n    settingsPanelDisabled: false,\n    language: {\n      settings: false,\n      label: 'Specify Language',\n      enabled: false,\n    },\n    languageChoices: {\n      label: 'Language Choices',\n      options: [],\n    }\n  },\n};\n"]}

package/configure/lib/index.js

@@ -240,4 +240,4 @@ exports["default"] = EbsrConfigure;
     })
   });
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["MODEL_UPDATED","ModelUpdatedEvent","TYPE","MC_TAG_NAME","EbsrMCConfigure","MultipleChoiceConfigure","defineMultipleChoice","customElements","get","define","prepareCustomizationObject","config","model","configuration","sensibleDefaults","settingsPanelDisabled","modelDefault","EbsrConfigure","m","reset","_model","createDefaultModel","dispatchModelUpdated","_render","e","target","preventDefault","stopImmediatePropagation","id","getAttribute","update","dispatchEvent","_configuration","onConfigurationChanged","bind","resetValue","c","info","newConfiguration","language","enabled","languageChoices","options","length","value","settings","find","option","push","label","onModelChanged","addEventListener","onModelUpdated","removeEventListener","element","React","createElement","Main","ReactDOM","render","HTMLElement","partA","partB","defaults","choicesLayout","verticalMode"],"mappings":"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","sourcesContent":["import React from 'react';\nimport ReactDOM from 'react-dom';\nimport { ModelUpdatedEvent } from '@pie-framework/pie-configure-events';\nimport MultipleChoiceConfigure from '@pie-element/multiple-choice/configure/lib';\nimport defaults from 'lodash/defaults';\nimport Main from './main';\n\nimport sensibleDefaults from './defaults';\n\nconst MODEL_UPDATED = ModelUpdatedEvent.TYPE;\nconst MC_TAG_NAME = 'ebsr-multiple-choice-configure';\n\nclass EbsrMCConfigure extends MultipleChoiceConfigure {}\n\nconst defineMultipleChoice = () => {\n  if (!customElements.get(MC_TAG_NAME)) {\n    customElements.define(MC_TAG_NAME, EbsrMCConfigure);\n  }\n};\n\ndefineMultipleChoice();\n\nconst prepareCustomizationObject = (config, model) => {\n  const configuration = defaults(config, sensibleDefaults.configuration);\n  configuration.settingsPanelDisabled = true;\n\n  return {\n    configuration,\n    model,\n  };\n};\n\nconst { model: modelDefault } = sensibleDefaults || {};\n\nexport default class EbsrConfigure extends HTMLElement {\n  static createDefaultModel = ({ partA = {}, partB = {}, ...model } = {}, defaults = modelDefault) => ({\n    ...defaults,\n    ...model,\n    partA: {\n      ...defaults.partA,\n      ...partA,\n      choicesLayout:\n        partA.choicesLayout || (partA.verticalMode === false && 'horizontal') || defaults.partA.choicesLayout,\n    },\n    partB: {\n      ...defaults.partB,\n      ...partB,\n      choicesLayout:\n        partB.choicesLayout || (partB.verticalMode === false && 'horizontal') || defaults.partB.choicesLayout,\n    },\n  });\n\n  constructor() {\n    super();\n\n    this._model = EbsrConfigure.createDefaultModel();\n\n    this._configuration = sensibleDefaults.configuration;\n    this.onConfigurationChanged = this.onConfigurationChanged.bind(this);\n  }\n\n  set model(m) {\n    this._model = EbsrConfigure.createDefaultModel(m, this._model);\n\n    this._render();\n  }\n\n  dispatchModelUpdated(reset) {\n    const resetValue = !!reset;\n\n    this.dispatchEvent(new ModelUpdatedEvent(this._model, resetValue));\n  }\n\n  onModelChanged = (m, reset) => {\n    this._model = EbsrConfigure.createDefaultModel(m, this._model);\n\n    this.dispatchModelUpdated(reset);\n    this._render();\n  };\n\n  set configuration(c) {\n    const info = prepareCustomizationObject(c, this._model);\n\n    const newConfiguration = {\n      ...sensibleDefaults.configuration,\n      ...info.configuration,\n    };\n\n    this._configuration = newConfiguration;\n\n    // if language:enabled is true, then the corresponding default item model should include a language value;\n    // if it is false, then the language field should be omitted from the item model.\n    // if a default item model includes a language value (e.g., en_US) and the corresponding authoring view settings have language:settings = true,\n    // then (a) language:enabled should also be true, and (b) that default language value should be represented in languageChoices[] (as a key).\n    if (newConfiguration?.language?.enabled) {\n      if (newConfiguration?.languageChoices?.options?.length) {\n        this._model.language = newConfiguration?.languageChoices.options[0].value;\n      }\n    } else if (newConfiguration.language.settings && this._model.language) {\n      this._configuration.language.enabled = true;\n\n      if (!this._configuration.languageChoices.options || !this._configuration.languageChoices.options.length) {\n        this._configuration.languageChoices.options = [];\n      }\n\n      // check if the language is already included in the languageChoices.options array\n      // and if not, then add it.\n      if (!this._configuration.languageChoices.options.find(option => option.value === this._model.language)) {\n        this._configuration.languageChoices.options.push({\n          value: this._model.language,\n          label: this._model.language,\n        });\n      }\n    } else {\n      delete this._model.language;\n    }\n\n    this._render();\n  }\n\n  onConfigurationChanged(c) {\n    this._configuration = prepareCustomizationObject(c, this._model).configuration;\n\n    if (this._model) {\n      this.onModelChanged(this._model);\n    }\n\n    this._render();\n  }\n\n  onModelUpdated = (e) => {\n    if (e.target === this) {\n      return;\n    }\n\n    e.preventDefault();\n    e.stopImmediatePropagation();\n\n    const id = e.target && e.target.getAttribute('id');\n\n    if (id) {\n      if (e.update) {\n        this._model[`part${id}`] = e.update;\n      }\n\n      this.dispatchEvent(new ModelUpdatedEvent(this._model));\n    }\n  };\n\n  connectedCallback() {\n    this.addEventListener(MODEL_UPDATED, this.onModelUpdated);\n    this._render();\n  }\n\n  disconnectedCallback() {\n    this.removeEventListener(MODEL_UPDATED, this.onModelUpdated);\n  }\n\n  _render() {\n    let element = React.createElement(Main, {\n      model: this._model,\n      configuration: this._configuration,\n      onModelChanged: this.onModelChanged,\n      onConfigurationChanged: this.onConfigurationChanged,\n    });\n\n    ReactDOM.render(element, this);\n  }\n}\n"]}