@pie-element/drag-in-the-blank 8.0.1 → 8.2.0-mui-update.0

package/CHANGELOG.md

@@ -3,6 +3,87 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.3.3](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.3.2...@pie-element/drag-in-the-blank@8.3.3) (2025-11-27)
+
+
+### Bug Fixes
+
+* bump libs PD-5274, PD-5211, PD-5248 ([7610b25](https://github.com/pie-framework/pie-elements/commit/7610b25423956b6492f33322513b3430051fca77))
+
+
+
+
+
+## [8.3.2](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.3.1...@pie-element/drag-in-the-blank@8.3.2) (2025-10-22)
+
+
+### Bug Fixes
+
+* bump libs PD-5265 ([184a978](https://github.com/pie-framework/pie-elements/commit/184a978f57a2a84dc6ba87c1eba0b92d5cdd9eae))
+
+
+
+
+
+## [8.3.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.2.1...@pie-element/drag-in-the-blank@8.3.1) (2025-10-16)
+
+
+### Bug Fixes
+
+* bump pie-lib versions and pslb module versions ([393d39f](https://github.com/pie-framework/pie-elements/commit/393d39fb850ad055568f4d20464213e9043f208f))
+
+
+
+
+
+# [8.3.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.2.0...@pie-element/drag-in-the-blank@8.3.0) (2025-10-15)
+
+
+### Bug Fixes
+
+* bump libs ([2616ab2](https://github.com/pie-framework/pie-elements/commit/2616ab24f776f4df02302f5855c381ee52527665))
+
+
+
+
+
+## [8.2.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.2.0...@pie-element/drag-in-the-blank@8.2.1) (2025-10-14)
+
+
+### Bug Fixes
+
+* bump libs ([2616ab2](https://github.com/pie-framework/pie-elements/commit/2616ab24f776f4df02302f5855c381ee52527665))
+
+
+
+
+
+# [8.2.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@8.0.0...@pie-element/drag-in-the-blank@8.2.0) (2025-10-10)
+
+
+### Bug Fixes
+
+* tests ([a473075](https://github.com/pie-framework/pie-elements/commit/a473075d3942e900b1e7137483ea6064951549c2))
+* **drag-in-the-blank:** prevent duplicate IDs when adding choices after removal PD-5225 ([31c1357](https://github.com/pie-framework/pie-elements/commit/31c13578e73397ae1334b7abd06545f3299cdf28))
+
+
+### Features
+
+* update completion rule for categorize, ditb, and image-cloze PD-5179 ([cd03a6e](https://github.com/pie-framework/pie-elements/commit/cd03a6e56e51cc3778749b3679b87f9122405936))
+* update libs PD-5208, PD-5211, PD-5199, PD-5218, PD-5217 ([da327fa](https://github.com/pie-framework/pie-elements/commit/da327fa501f6e9eff1c0b30b5ef092426a91f78b))
+
+
+
+
+
+# [8.1.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@7.0.0...@pie-element/drag-in-the-blank@8.1.0) (2025-10-07)
+
+**Note:** Version bump only for package @pie-element/drag-in-the-blank
+
+
+
+
+
 # [8.0.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank@6.13.4...@pie-element/drag-in-the-blank@8.0.0) (2025-10-02)
 
 

package/configure/CHANGELOG.md

@@ -3,6 +3,86 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [7.3.3](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.3.2...@pie-element/drag-in-the-blank-configure@7.3.3) (2025-11-27)
+
+
+### Bug Fixes
+
+* bump libs PD-5274, PD-5211, PD-5248 ([7610b25](https://github.com/pie-framework/pie-elements/commit/7610b25423956b6492f33322513b3430051fca77))
+
+
+
+
+
+## [7.3.2](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.3.1...@pie-element/drag-in-the-blank-configure@7.3.2) (2025-10-22)
+
+
+### Bug Fixes
+
+* bump libs PD-5265 ([184a978](https://github.com/pie-framework/pie-elements/commit/184a978f57a2a84dc6ba87c1eba0b92d5cdd9eae))
+
+
+
+
+
+## [7.3.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.2.1...@pie-element/drag-in-the-blank-configure@7.3.1) (2025-10-16)
+
+
+### Bug Fixes
+
+* bump pie-lib versions and pslb module versions ([393d39f](https://github.com/pie-framework/pie-elements/commit/393d39fb850ad055568f4d20464213e9043f208f))
+
+
+
+
+
+# [7.3.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.2.0...@pie-element/drag-in-the-blank-configure@7.3.0) (2025-10-15)
+
+
+### Bug Fixes
+
+* bump libs ([2616ab2](https://github.com/pie-framework/pie-elements/commit/2616ab24f776f4df02302f5855c381ee52527665))
+
+
+
+
+
+## [7.2.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.2.0...@pie-element/drag-in-the-blank-configure@7.2.1) (2025-10-14)
+
+
+### Bug Fixes
+
+* bump libs ([2616ab2](https://github.com/pie-framework/pie-elements/commit/2616ab24f776f4df02302f5855c381ee52527665))
+
+
+
+
+
+# [7.2.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.0.1...@pie-element/drag-in-the-blank-configure@7.2.0) (2025-10-10)
+
+
+### Bug Fixes
+
+* tests ([a473075](https://github.com/pie-framework/pie-elements/commit/a473075d3942e900b1e7137483ea6064951549c2))
+* **drag-in-the-blank:** prevent duplicate IDs when adding choices after removal PD-5225 ([31c1357](https://github.com/pie-framework/pie-elements/commit/31c13578e73397ae1334b7abd06545f3299cdf28))
+
+
+### Features
+
+* update libs PD-5208, PD-5211, PD-5199, PD-5218, PD-5217 ([da327fa](https://github.com/pie-framework/pie-elements/commit/da327fa501f6e9eff1c0b30b5ef092426a91f78b))
+
+
+
+
+
+# [7.1.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@7.0.0...@pie-element/drag-in-the-blank-configure@7.1.0) (2025-10-07)
+
+**Note:** Version bump only for package @pie-element/drag-in-the-blank-configure
+
+
+
+
+
 ## [7.0.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/drag-in-the-blank-configure@6.7.0...@pie-element/drag-in-the-blank-configure@7.0.1) (2025-10-02)
 
 **Note:** Version bump only for package @pie-element/drag-in-the-blank-configure

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

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _enzyme = require("enzyme");
+var _react = _interopRequireDefault(require("react"));
+var _choice = _interopRequireWildcard(require("../choice"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+describe('Choice', () => {
+  let onClick;
+  let onRemoveChoice;
+  let connectDragSource;
+  let connectDragPreview;
+  beforeEach(() => {
+    onClick = jest.fn();
+    onRemoveChoice = jest.fn();
+    connectDragSource = jest.fn();
+    connectDragPreview = jest.fn();
+  });
+  const wrapper = extras => {
+    const props = {
+      classes: {},
+      key: '0',
+      duplicates: true,
+      choice: {
+        value: '<div>6</div>',
+        id: '0'
+      },
+      targetId: '0',
+      onClick,
+      onRemoveChoice,
+      connectDragSource,
+      connectDragPreview,
+      ...extras
+    };
+    return (0, _enzyme.shallow)(/*#__PURE__*/_react.default.createElement(_choice.default, props));
+  };
+  describe('snapshot', () => {
+    it('renders', () => {
+      const w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+});
+describe('spec', () => {
+  describe('canDrag', () => {
+    it('returns true if category has any value and is enabled', () => {
+      const result = _choice.tileSource.canDrag({
+        choice: {
+          value: '<div>6</div>',
+          id: '0'
+        },
+        disabled: false
+      });
+      expect(result).toEqual(true);
+    });
+    it('returns false if category has any value and is disabled', () => {
+      const jsdomAlert = window.alert; // remember the jsdom alert
+      window.alert = () => {};
+      const result = _choice.tileSource.canDrag({
+        choice: {
+          value: '<div>6</div>',
+          id: '0'
+        },
+        disabled: true
+      });
+      expect(result).toEqual(false);
+      window.alert = jsdomAlert;
+    });
+    it('returns false if category value is empty', () => {
+      const jsdomAlert = window.alert; // remember the jsdom alert
+      window.alert = () => {};
+      const result = _choice.tileSource.canDrag({
+        choice: {
+          value: '',
+          id: '0'
+        }
+      });
+      expect(result).toEqual(false);
+      window.alert = jsdomAlert;
+    });
+  });
+  describe('beginDrag', () => {
+    it('returns the proper object', () => {
+      const result = _choice.tileSource.beginDrag({
+        choice: {
+          value: '<div>0</div>',
+          id: '0'
+        },
+        instanceId: '1',
+        targetId: '0'
+      });
+      expect(result).toEqual({
+        id: '0',
+        instanceId: '1',
+        value: {
+          value: '<div>0</div>',
+          id: '0'
+        }
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_enzyme","require","_react","_interopRequireDefault","_choice","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","describe","onClick","onRemoveChoice","connectDragSource","connectDragPreview","beforeEach","jest","fn","wrapper","extras","props","classes","key","duplicates","choice","value","id","targetId","shallow","createElement","it","w","expect","toMatchSnapshot","result","tileSource","canDrag","disabled","toEqual","jsdomAlert","window","alert","beginDrag","instanceId"],"sources":["../../src/__tests__/choice.test.jsx"],"sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\nimport Choice, { tileSource } from '../choice';\n\ndescribe('Choice', () => {\n  let onClick;\n  let onRemoveChoice;\n  let connectDragSource;\n  let connectDragPreview;\n\n  beforeEach(() => {\n    onClick = jest.fn();\n    onRemoveChoice = jest.fn();\n    connectDragSource = jest.fn();\n    connectDragPreview = jest.fn();\n  });\n\n  const wrapper = (extras) => {\n    const props = {\n      classes: {},\n      key: '0',\n      duplicates: true,\n      choice: {\n        value: '<div>6</div>',\n        id: '0',\n      },\n      targetId: '0',\n      onClick,\n      onRemoveChoice,\n      connectDragSource,\n      connectDragPreview,\n      ...extras,\n    };\n\n    return shallow(<Choice {...props} />);\n  };\n  describe('snapshot', () => {\n    it('renders', () => {\n      const w = wrapper();\n      expect(w).toMatchSnapshot();\n    });\n  });\n});\n\ndescribe('spec', () => {\n  describe('canDrag', () => {\n    it('returns true if category has any value and is enabled', () => {\n      const result = tileSource.canDrag({ choice: { value: '<div>6</div>', id: '0' }, disabled: false });\n      expect(result).toEqual(true);\n    });\n\n    it('returns false if category has any value and is disabled', () => {\n      const jsdomAlert = window.alert; // remember the jsdom alert\n      window.alert = () => {};\n\n      const result = tileSource.canDrag({ choice: { value: '<div>6</div>', id: '0' }, disabled: true });\n      expect(result).toEqual(false);\n\n      window.alert = jsdomAlert;\n    });\n\n    it('returns false if category value is empty', () => {\n      const jsdomAlert = window.alert; // remember the jsdom alert\n      window.alert = () => {};\n\n      const result = tileSource.canDrag({ choice: { value: '', id: '0' } });\n      expect(result).toEqual(false);\n\n      window.alert = jsdomAlert;\n    });\n  });\n\n  describe('beginDrag', () => {\n    it('returns the proper object', () => {\n      const result = tileSource.beginDrag({\n        choice: { value: '<div>0</div>', id: '0' },\n        instanceId: '1',\n        targetId: '0',\n      });\n      expect(result).toEqual({ id: '0', instanceId: '1', value: { value: '<div>0</div>', id: '0' } });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,326 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _enzyme = require("enzyme");
+var _react = _interopRequireDefault(require("react"));
+var _choices = require("../choices");
+var _defaults = _interopRequireDefault(require("../defaults"));
+var _markupUtils = require("../markupUtils");
+jest.mock('@pie-lib/config-ui', () => ({
+  choiceUtils: {
+    firstAvailableIndex: jest.fn()
+  },
+  settings: {
+    Panel: props => /*#__PURE__*/_react.default.createElement("div", props),
+    toggle: jest.fn(),
+    radio: jest.fn(),
+    dropdown: jest.fn()
+  },
+  layout: {
+    ConfigLayout: props => /*#__PURE__*/_react.default.createElement("div", null, props.children)
+  }
+}));
+const model = {
+  markup: '{{0}} + {{1}} = 15',
+  prompt: '<p>Solve the equation below.</p>',
+  choices: [{
+    value: '<div>6</div>',
+    id: '0'
+  }, {
+    value: '<div>9</div>',
+    id: '1'
+  }, {
+    value: '<div>12</div>',
+    id: '2'
+  }],
+  choicesPosition: 'below',
+  correctResponse: {
+    0: '0',
+    1: '1'
+  },
+  duplicates: true,
+  alternateResponses: [['1'], ['0']],
+  rationale: '<p>A correct response is shown below:</p><ul><li>2/6 = 1/3</li><li>4/8 = 1/2</li><li>6/10 = 3/5</li><li>9/12 = 3/4</li></ul>'
+};
+const prepareModel = (model = {}) => {
+  const joinedObj = {
+    ..._defaults.default.model,
+    ...model
+  };
+  const slateMarkup = model.slateMarkup || (0, _markupUtils.createSlateMarkup)(joinedObj.markup, joinedObj.choices, joinedObj.correctResponse);
+  const processedMarkup = (0, _markupUtils.processMarkup)(slateMarkup);
+  return {
+    ...joinedObj,
+    slateMarkup,
+    markup: processedMarkup.markup,
+    correctResponse: processedMarkup.correctResponse
+  };
+};
+describe('Choices', () => {
+  let onChange;
+  beforeEach(() => {
+    onChange = jest.fn();
+  });
+  const wrapper = extras => {
+    const defaults = {
+      onChange,
+      classes: {},
+      model: prepareModel(model),
+      duplicates: true,
+      ...extras
+    };
+    const props = {
+      ...defaults
+    };
+    return (0, _enzyme.shallow)(/*#__PURE__*/_react.default.createElement(_choices.Choices, props), {
+      disableLifecycleMethods: true
+    });
+  };
+  describe('snapshot', () => {
+    it('renders with duplicates', () => {
+      expect(wrapper()).toMatchSnapshot();
+    });
+    it('renders without duplicates', () => {
+      expect(wrapper({
+        duplicates: false
+      })).toMatchSnapshot();
+    });
+  });
+  describe('logic', () => {
+    let w;
+    beforeEach(() => {
+      w = wrapper();
+    });
+    describe('onChoiceChanged', () => {
+      it('removes a choice if its new value is empty', () => {
+        w.instance().onChoiceChanged('<div>12</div>', '', '2');
+        expect(onChange).toBeCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }]);
+      });
+      it('does not add new choice if it is identical to another choice', () => {
+        w.instance().onChoiceChanged('', '<div>9</div>', '2');
+        expect(onChange).toBeCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }]);
+      });
+      it('does not change choice if it would be identical to another choice', () => {
+        w.instance().onChoiceChanged('<div>6</div>', '<div>9</div>', '0');
+        expect(onChange).toHaveBeenCalledTimes(0);
+      });
+      it('does not remove a choice if its new value is empty, but is used in correct response', () => {
+        const jsdomAlert = window.alert; // remember the jsdom alert
+
+        window.alert = () => {};
+        w.instance().onChoiceChanged('<div>9</div>', '', '1');
+        expect(onChange).not.toBeCalled();
+        window.alert = jsdomAlert;
+      });
+      it('does not remove a choice if its new value is empty, but is used in alternate response', () => {
+        const jsdomAlert = window.alert; // remember the jsdom alert
+
+        window.alert = () => {};
+        wrapper({
+          markup: '{{0}}'
+        }).instance().onChoiceChanged('<div>9</div>', '', '1');
+        expect(onChange).not.toBeCalled();
+        window.alert = jsdomAlert;
+      });
+      it('does not remove a choice if its new value is empty, but the old value was empty as well (at focusing a new choice without editing)', () => {
+        const jsdomAlert = window.alert; // remember the jsdom alert
+
+        window.alert = () => {};
+        wrapper({
+          markup: '{{0}}'
+        }).instance().onChoiceChanged('', '', '1');
+        expect(onChange).not.toBeCalled();
+        window.alert = jsdomAlert;
+      });
+      it('updates choices', () => {
+        w.instance().onChoiceChanged('<div>9</div>', '<div>3*3</div>', '1');
+        expect(onChange).toBeCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>3*3</div>',
+          id: '1'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }]);
+      });
+    });
+    describe('onChoiceFocus', () => {
+      it('sets focused element id on state', () => {
+        w.instance().onChoiceFocus('1');
+        expect(w.instance().state.focusedEl).toEqual('1');
+      });
+    });
+    describe('onAddChoice', () => {
+      it('adds a choice', () => {
+        wrapper().instance().onAddChoice();
+        expect(onChange).toBeCalledWith([...model.choices, {
+          id: '3',
+          value: ''
+        }]);
+      });
+    });
+    describe('onChoiceRemove', () => {
+      it('removes a choice', () => {
+        wrapper().instance().onChoiceRemove('1');
+        expect(onChange).toBeCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }]);
+      });
+    });
+    describe('onChoiceRemove & onAddChoice', () => {
+      it('prevents duplicate IDs when adding choices after removing some', () => {
+        const initialWrapper = wrapper();
+        initialWrapper.instance().onChoiceRemove('1');
+        expect(onChange).toHaveBeenCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }]);
+        const updatedChoices = [{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }];
+        const wrapperWithUpdatedState = wrapper({
+          model: {
+            ...model,
+            choices: updatedChoices
+          }
+        });
+        wrapperWithUpdatedState.instance().onAddChoice();
+        expect(onChange).toHaveBeenLastCalledWith([{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }, {
+          id: '3',
+          value: ''
+        }]);
+      });
+    });
+    describe('getVisibleChoices', () => {
+      it('choices are null => returns []', () => {
+        const visibleChoices = wrapper({
+          model: {
+            choices: null
+          }
+        }).instance().getVisibleChoices();
+        expect(visibleChoices).toEqual([]);
+      });
+      it('duplicates = true', () => {
+        const choices = [{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }];
+        const visibleChoices = wrapper({
+          model: {
+            duplicates: true,
+            choices: choices,
+            correctResponse: {
+              0: '0',
+              1: '1'
+            }
+          }
+        }).instance().getVisibleChoices();
+        expect(visibleChoices).toEqual(choices);
+      });
+      it('duplicates = false', () => {
+        const choices = [{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }];
+        const visibleChoices = wrapper({
+          duplicates: false,
+          model: {
+            choices: choices,
+            correctResponse: {
+              0: '0',
+              1: '1'
+            }
+          }
+        }).instance().getVisibleChoices();
+        expect(visibleChoices).toEqual([{
+          value: '<div>12</div>',
+          id: '2'
+        }]);
+      });
+      it('duplicates = false, empty correctResponse', () => {
+        const choices = [{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }];
+        const visibleChoices = wrapper({
+          duplicates: false,
+          model: {
+            choices: choices,
+            correctResponse: {}
+          }
+        }).instance().getVisibleChoices();
+        expect(visibleChoices).toEqual(choices);
+      });
+      it('duplicates = false, correctResponse = null', () => {
+        const choices = [{
+          value: '<div>6</div>',
+          id: '0'
+        }, {
+          value: '<div>9</div>',
+          id: '1'
+        }, {
+          value: '<div>12</div>',
+          id: '2'
+        }];
+        const visibleChoices = wrapper({
+          duplicates: false,
+          model: {
+            choices: choices,
+            correctResponse: null
+          }
+        }).instance().getVisibleChoices();
+        expect(visibleChoices).toEqual(choices);
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_enzyme","require","_react","_interopRequireDefault","_choices","_defaults","_markupUtils","jest","mock","choiceUtils","firstAvailableIndex","fn","settings","Panel","props","default","createElement","toggle","radio","dropdown","layout","ConfigLayout","children","model","markup","prompt","choices","value","id","choicesPosition","correctResponse","duplicates","alternateResponses","rationale","prepareModel","joinedObj","sensibleDefaults","slateMarkup","createSlateMarkup","processedMarkup","processMarkup","describe","onChange","beforeEach","wrapper","extras","defaults","classes","shallow","Choices","disableLifecycleMethods","it","expect","toMatchSnapshot","w","instance","onChoiceChanged","toBeCalledWith","toHaveBeenCalledTimes","jsdomAlert","window","alert","not","toBeCalled","onChoiceFocus","state","focusedEl","toEqual","onAddChoice","onChoiceRemove","initialWrapper","toHaveBeenCalledWith","updatedChoices","wrapperWithUpdatedState","toHaveBeenLastCalledWith","visibleChoices","getVisibleChoices"],"sources":["../../src/__tests__/choices.test.jsx"],"sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\n\nimport { Choices } from '../choices';\nimport sensibleDefaults from '../defaults';\nimport { createSlateMarkup, processMarkup } from '../markupUtils';\n\njest.mock('@pie-lib/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\nconst model = {\n  markup: '{{0}} + {{1}} = 15',\n  prompt: '<p>Solve the equation below.</p>',\n  choices: [\n    { value: '<div>6</div>', id: '0' },\n    { value: '<div>9</div>', id: '1' },\n    { value: '<div>12</div>', id: '2' },\n  ],\n  choicesPosition: 'below',\n  correctResponse: {\n    0: '0',\n    1: '1',\n  },\n  duplicates: true,\n  alternateResponses: [['1'], ['0']],\n  rationale:\n    '<p>A correct response is shown below:</p><ul><li>2/6 = 1/3</li><li>4/8 = 1/2</li><li>6/10 = 3/5</li><li>9/12 = 3/4</li></ul>',\n};\n\nconst prepareModel = (model = {}) => {\n  const joinedObj = {\n    ...sensibleDefaults.model,\n    ...model,\n  };\n  const slateMarkup =\n    model.slateMarkup || createSlateMarkup(joinedObj.markup, joinedObj.choices, joinedObj.correctResponse);\n  const processedMarkup = processMarkup(slateMarkup);\n\n  return {\n    ...joinedObj,\n    slateMarkup,\n    markup: processedMarkup.markup,\n    correctResponse: processedMarkup.correctResponse,\n  };\n};\n\ndescribe('Choices', () => {\n  let onChange;\n\n  beforeEach(() => {\n    onChange = jest.fn();\n  });\n\n  const wrapper = (extras) => {\n    const defaults = {\n      onChange,\n      classes: {},\n      model: prepareModel(model),\n      duplicates: true,\n      ...extras,\n    };\n    const props = { ...defaults };\n\n    return shallow(<Choices {...props} />, { disableLifecycleMethods: true });\n  };\n\n  describe('snapshot', () => {\n    it('renders with duplicates', () => {\n      expect(wrapper()).toMatchSnapshot();\n    });\n\n    it('renders without duplicates', () => {\n      expect(wrapper({ duplicates: false })).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    let w;\n\n    beforeEach(() => {\n      w = wrapper();\n    });\n\n    describe('onChoiceChanged', () => {\n      it('removes a choice if its new value is empty', () => {\n        w.instance().onChoiceChanged('<div>12</div>', '', '2');\n\n        expect(onChange).toBeCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n        ]);\n      });\n\n      it('does not add new choice if it is identical to another choice', () => {\n        w.instance().onChoiceChanged('', '<div>9</div>', '2');\n\n        expect(onChange).toBeCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n        ]);\n      });\n\n      it('does not change choice if it would be identical to another choice', () => {\n        w.instance().onChoiceChanged('<div>6</div>', '<div>9</div>', '0');\n\n        expect(onChange).toHaveBeenCalledTimes(0);\n      });\n\n      it('does not remove a choice if its new value is empty, but is used in correct response', () => {\n        const jsdomAlert = window.alert; // remember the jsdom alert\n\n        window.alert = () => {};\n\n        w.instance().onChoiceChanged('<div>9</div>', '', '1');\n\n        expect(onChange).not.toBeCalled();\n\n        window.alert = jsdomAlert;\n      });\n\n      it('does not remove a choice if its new value is empty, but is used in alternate response', () => {\n        const jsdomAlert = window.alert; // remember the jsdom alert\n\n        window.alert = () => {};\n\n        wrapper({ markup: '{{0}}' }).instance().onChoiceChanged('<div>9</div>', '', '1');\n\n        expect(onChange).not.toBeCalled();\n\n        window.alert = jsdomAlert;\n      });\n\n      it('does not remove a choice if its new value is empty, but the old value was empty as well (at focusing a new choice without editing)', () => {\n        const jsdomAlert = window.alert; // remember the jsdom alert\n\n        window.alert = () => {};\n\n        wrapper({ markup: '{{0}}' }).instance().onChoiceChanged('', '', '1');\n\n        expect(onChange).not.toBeCalled();\n\n        window.alert = jsdomAlert;\n      });\n\n      it('updates choices', () => {\n        w.instance().onChoiceChanged('<div>9</div>', '<div>3*3</div>', '1');\n\n        expect(onChange).toBeCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>3*3</div>', id: '1' },\n          { value: '<div>12</div>', id: '2' },\n        ]);\n      });\n    });\n\n    describe('onChoiceFocus', () => {\n      it('sets focused element id on state', () => {\n        w.instance().onChoiceFocus('1');\n\n        expect(w.instance().state.focusedEl).toEqual('1');\n      });\n    });\n\n    describe('onAddChoice', () => {\n      it('adds a choice', () => {\n        wrapper().instance().onAddChoice();\n\n        expect(onChange).toBeCalledWith([...model.choices, { id: '3', value: '' }]);\n      });\n    });\n\n    describe('onChoiceRemove', () => {\n      it('removes a choice', () => {\n        wrapper().instance().onChoiceRemove('1');\n\n        expect(onChange).toBeCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>12</div>', id: '2' },\n        ]);\n      });\n    });\n\n    describe('onChoiceRemove & onAddChoice', () => {\n      it('prevents duplicate IDs when adding choices after removing some', () => {\n        const initialWrapper = wrapper();\n\n        initialWrapper.instance().onChoiceRemove('1');\n\n        expect(onChange).toHaveBeenCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>12</div>', id: '2' },\n        ]);\n\n        const updatedChoices = [\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>12</div>', id: '2' },\n        ];\n        \n        const wrapperWithUpdatedState = wrapper({\n          model: { ...model, choices: updatedChoices }\n        });\n\n        wrapperWithUpdatedState.instance().onAddChoice();\n\n        expect(onChange).toHaveBeenLastCalledWith([\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>12</div>', id: '2' },\n          { id: '3', value: '' }\n        ]);\n      });\n    });\n\n    describe('getVisibleChoices', () => {\n      it('choices are null => returns []', () => {\n        const visibleChoices = wrapper({ model: { choices: null } })\n          .instance()\n          .getVisibleChoices();\n\n        expect(visibleChoices).toEqual([]);\n      });\n\n      it('duplicates = true', () => {\n        const choices = [\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n          { value: '<div>12</div>', id: '2' },\n        ];\n        const visibleChoices = wrapper({\n          model: {\n            duplicates: true,\n            choices: choices,\n            correctResponse: {\n              0: '0',\n              1: '1',\n            },\n          },\n        })\n          .instance()\n          .getVisibleChoices();\n\n        expect(visibleChoices).toEqual(choices);\n      });\n\n      it('duplicates = false', () => {\n        const choices = [\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n          { value: '<div>12</div>', id: '2' },\n        ];\n        const visibleChoices = wrapper({\n          duplicates: false,\n          model: {\n            choices: choices,\n            correctResponse: {\n              0: '0',\n              1: '1',\n            },\n          },\n        })\n          .instance()\n          .getVisibleChoices();\n\n        expect(visibleChoices).toEqual([{ value: '<div>12</div>', id: '2' }]);\n      });\n\n      it('duplicates = false, empty correctResponse', () => {\n        const choices = [\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n          { value: '<div>12</div>', id: '2' },\n        ];\n        const visibleChoices = wrapper({\n          duplicates: false,\n          model: {\n            choices: choices,\n            correctResponse: {},\n          },\n        })\n          .instance()\n          .getVisibleChoices();\n\n        expect(visibleChoices).toEqual(choices);\n      });\n\n      it('duplicates = false, correctResponse = null', () => {\n        const choices = [\n          { value: '<div>6</div>', id: '0' },\n          { value: '<div>9</div>', id: '1' },\n          { value: '<div>12</div>', id: '2' },\n        ];\n        const visibleChoices = wrapper({\n          duplicates: false,\n          model: {\n            choices: choices,\n            correctResponse: null,\n          },\n        })\n          .instance()\n          .getVisibleChoices();\n\n        expect(visibleChoices).toEqual(choices);\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}