@pie-element/fraction-model 2.1.6-next.3 → 2.2.1-beta.0

package/CHANGELOG.md

@@ -3,6 +3,35 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.2.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model@2.2.0...@pie-element/fraction-model@2.2.1) (2024-11-01)
+
+
+### Bug Fixes
+
+* update pie-lib PD-4361 ([0ed2a71](https://github.com/pie-framework/pie-elements/commit/0ed2a7156d3fef55b9c25ab9c60d0df836b86ee5))
+* update pie-lib/pie-toolbox PD-4319, PD-1460, PD-4004 ([db03ac7](https://github.com/pie-framework/pie-elements/commit/db03ac7473960cedef2c83c79920e77db06f605d))
+* update pie-lib/pie-toolbox PD-4372 ([dc73470](https://github.com/pie-framework/pie-elements/commit/dc734705a6aefa0f69eb29d3d695c57e31671ab8))
+
+
+
+
+
+# [2.2.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model@2.1.5...@pie-element/fraction-model@2.2.0) (2024-10-29)
+
+
+### Bug Fixes
+
+* fixed all tests after updating pie-toolbox [PD-1460] ([9f5293d](https://github.com/pie-framework/pie-elements/commit/9f5293d618edc06f69fabb27a042ec5eee66e151))
+
+
+### Features
+
+* used configlayout, preview layout or uilayout to enable extraCSSRules inside author and player elements [PD-1460] ([eeebb02](https://github.com/pie-framework/pie-elements/commit/eeebb02f200208620c1af56366a22bf65944ba3e))
+
+
+
+
+
 ## [2.1.5](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model@2.1.4...@pie-element/fraction-model@2.1.5) (2024-10-28)
 
 

package/configure/CHANGELOG.md

@@ -3,6 +3,35 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.1.1](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model-configure@2.1.0...@pie-element/fraction-model-configure@2.1.1) (2024-11-01)
+
+
+### Bug Fixes
+
+* update pie-lib PD-4361 ([0ed2a71](https://github.com/pie-framework/pie-elements/commit/0ed2a7156d3fef55b9c25ab9c60d0df836b86ee5))
+* update pie-lib/pie-toolbox PD-4319, PD-1460, PD-4004 ([db03ac7](https://github.com/pie-framework/pie-elements/commit/db03ac7473960cedef2c83c79920e77db06f605d))
+* update pie-lib/pie-toolbox PD-4372 ([dc73470](https://github.com/pie-framework/pie-elements/commit/dc734705a6aefa0f69eb29d3d695c57e31671ab8))
+
+
+
+
+
+# [2.1.0](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model-configure@2.0.7...@pie-element/fraction-model-configure@2.1.0) (2024-10-29)
+
+
+### Bug Fixes
+
+* fixed all tests after updating pie-toolbox [PD-1460] ([9f5293d](https://github.com/pie-framework/pie-elements/commit/9f5293d618edc06f69fabb27a042ec5eee66e151))
+
+
+### Features
+
+* used configlayout, preview layout or uilayout to enable extraCSSRules inside author and player elements [PD-1460] ([eeebb02](https://github.com/pie-framework/pie-elements/commit/eeebb02f200208620c1af56366a22bf65944ba3e))
+
+
+
+
+
 ## [2.0.7](https://github.com/pie-framework/pie-elements/compare/@pie-element/fraction-model-configure@2.0.6...@pie-element/fraction-model-configure@2.0.7) (2024-10-28)
 
 

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

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _main = require("../main");
+
+var _defaults = _interopRequireDefault(require("../defaults"));
+
+var _modelOptions = _interopRequireDefault(require("../model-options"));
+
+var _cardBar = _interopRequireDefault(require("../card-bar"));
+
+var _configUi = require("@pie-lib/pie-toolbox/config-ui");
+
+var _editableHtml = require("@pie-lib/pie-toolbox/editable-html");
+
+jest.mock('@pie-lib/pie-toolbox/config-ui', function () {
+  return {
+    layout: {
+      ConfigLayout: function ConfigLayout(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", null, props.children);
+      }
+    },
+    FormSection: function FormSection(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", props);
+    }
+  };
+});
+jest.mock('@pie-lib/pie-toolbox/editable-html', function () {
+  return {
+    EditableHtml: function EditableHtml(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", props);
+    }
+  };
+});
+jest.mock('lodash/debounce', function () {
+  return function (fn) {
+    return fn;
+  };
+});
+jest.spyOn(Math, 'random').mockReturnValue(0);
+var defaultProps = {
+  model: {
+    correctResponse: [],
+    title: '',
+    prompt: '',
+    modelTypeSelected: 'bar',
+    maxModelSelected: 1,
+    partsPerModel: 5,
+    allowedStudentConfig: false,
+    showGraphLabels: false
+  },
+  configuration: _defaults["default"].configuration
+};
+describe('Main', function () {
+  var onChange;
+  var onConfigurationChanged;
+  var uploadSoundSupport;
+  var imageSupport;
+  beforeEach(function () {
+    onChange = jest.fn();
+    onConfigurationChanged = jest.fn();
+    uploadSoundSupport = jest.mock();
+    imageSupport = jest.mock();
+  });
+
+  var wrapper = function wrapper(props) {
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_main.Main, (0, _extends2["default"])({
+      classes: {},
+      onChange: onChange,
+      onConfigurationChanged: onConfigurationChanged,
+      model: defaultProps.model,
+      configuration: defaultProps.configuration,
+      uploadSoundSupport: uploadSoundSupport,
+      imageSupport: imageSupport
+    }, props)));
+  };
+
+  it('snapshot renders', function () {
+    var component = wrapper();
+    expect(component).toMatchSnapshot();
+  });
+  it('renders correctly', function () {
+    var component = wrapper();
+    expect(component.find(_cardBar["default"]).length).toEqual(2);
+    expect(component.find(_modelOptions["default"]).length).toEqual(1);
+    expect(component.find(_configUi.FormSection).length).toEqual(4);
+    expect(component.find(_editableHtml.EditableHtml).length).toEqual(2);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/configure/lib/__tests__/model-options.test.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultProps = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _defaults = _interopRequireDefault(require("../defaults"));
+
+var _modelOptions = require("../model-options");
+
+var _cardBar = _interopRequireDefault(require("../card-bar"));
+
+var _numberTextField = require("../number-text-field");
+
+var _Select = _interopRequireDefault(require("@material-ui/core/Select"));
+
+var _configUi = require("@pie-lib/pie-toolbox/config-ui");
+
+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('@pie-lib/pie-toolbox/config-ui', function () {
+  return {
+    Checkbox: function Checkbox(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", props);
+    },
+    layout: {
+      ConfigLayout: function ConfigLayout(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", null, props.children);
+      }
+    }
+  };
+});
+jest.mock('@pie-lib/pie-toolbox/editable-html', function () {
+  return {
+    EditableHtml: function EditableHtml(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", props);
+    }
+  };
+});
+jest.mock('@material-ui/core', function () {
+  return {
+    Select: function Select(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", props);
+    }
+  };
+});
+jest.mock('lodash/debounce', function () {
+  return function (fn) {
+    return fn;
+  };
+});
+var defaultProps = {
+  model: {
+    correctResponse: [],
+    title: '',
+    prompt: '',
+    modelTypeSelected: 'bar',
+    maxModelSelected: 1,
+    partsPerModel: 5,
+    allowedStudentConfig: false,
+    showGraphLabels: false
+  },
+  modelOptions: _defaults["default"].configuration.modelOptions
+};
+exports.defaultProps = defaultProps;
+describe('Model Options', function () {
+  var wrapper;
+  var component;
+  beforeEach(function () {
+    wrapper = function wrapper(props) {
+      var configProps = _objectSpread(_objectSpread({
+        classes: {}
+      }, defaultProps), props);
+
+      return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_modelOptions.ModelOptions, configProps));
+    };
+  });
+  it('snapshot renders', function () {
+    var component = wrapper();
+    expect(component).toMatchSnapshot();
+  });
+  it('renders correctly: Components mounted correctly', function () {
+    component = wrapper();
+    expect(component.find(_cardBar["default"]).length).toEqual(1);
+    expect(component.find(_Select["default"]).length).toEqual(1);
+    expect(component.find(_numberTextField.MiniField).length).toEqual(2);
+    expect(component.find(_configUi.Checkbox).length).toEqual(1);
+  });
+  it('render correctly: update model type to Pie', function () {
+    var onChange = jest.fn();
+    component = wrapper({
+      onChange: onChange
+    });
+    component.instance().handleSelect({
+      target: {
+        value: 'pie'
+      }
+    });
+    expect(onChange).toBeCalledWith(expect.objectContaining({
+      modelTypeSelected: 'pie'
+    }), expect.objectContaining({
+      modelTypeSelected: 'pie'
+    }), false);
+  });
+  it('render correctly: update model type to Bar', function () {
+    var onChange = jest.fn();
+    component = wrapper({
+      onChange: onChange
+    });
+    component.instance().handleSelect({
+      target: {
+        value: 'bar'
+      }
+    });
+    expect(onChange).toBeCalledWith(expect.objectContaining({
+      modelTypeSelected: 'bar'
+    }), expect.objectContaining({
+      modelTypeSelected: 'bar'
+    }), false);
+  });
+  it('render correctly: update max no of model', function () {
+    var onChange = jest.fn();
+    component = wrapper({
+      onChange: onChange
+    });
+    component.instance().change('max', {}, 4);
+    expect(onChange).toBeCalledWith(expect.objectContaining({
+      maxModelSelected: defaultProps.model.maxModelSelected
+    }), expect.objectContaining({
+      maxModelSelected: 4
+    }), true);
+  });
+  it('render correctly: update parts per model', function () {
+    var onChange = jest.fn();
+    component = wrapper({
+      onChange: onChange
+    });
+    component.instance().change('part', {}, 7);
+    expect(onChange).toBeCalledWith(expect.objectContaining({
+      partsPerModel: defaultProps.model.partsPerModel
+    }), expect.objectContaining({
+      partsPerModel: 7
+    }), true);
+  });
+  it('render correctly: update student config checkbox', function () {
+    var onChange = jest.fn();
+    component = wrapper({
+      onChange: onChange
+    });
+    component.instance().change('student-config', {}, true);
+    expect(onChange).toBeCalledWith(expect.objectContaining({
+      allowedStudentConfig: defaultProps.model.allowedStudentConfig
+    }), expect.objectContaining({
+      allowedStudentConfig: true
+    }), false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/model-options.test.jsx"],"names":["jest","mock","Checkbox","props","layout","ConfigLayout","children","EditableHtml","Select","fn","defaultProps","model","correctResponse","title","prompt","modelTypeSelected","maxModelSelected","partsPerModel","allowedStudentConfig","showGraphLabels","modelOptions","defaultValues","configuration","describe","wrapper","component","beforeEach","configProps","classes","it","expect","toMatchSnapshot","find","CardBar","length","toEqual","MiniField","onChange","instance","handleSelect","target","value","toBeCalledWith","objectContaining","change"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\nimport defaultValues from '../defaults';\nimport { ModelOptions } from '../model-options';\nimport CardBar from '../card-bar';\nimport { MiniField } from '../number-text-field';\nimport Select from '@material-ui/core/Select';\nimport { Checkbox } from '@pie-lib/pie-toolbox/config-ui';\n\njest.mock('@pie-lib/pie-toolbox/config-ui', () => ({\n  Checkbox: (props) => <div {...props} />,\n  layout: {\n    ConfigLayout: (props) => <div>{props.children}</div>,\n  },\n}));\n\njest.mock('@pie-lib/pie-toolbox/editable-html', () => ({\n  EditableHtml: (props) => <div {...props} />,\n}));\n\njest.mock('@material-ui/core', () => ({\n  Select: (props) => <div {...props} />,\n}));\n\njest.mock('lodash/debounce', () => (fn) => fn);\n\nexport const defaultProps = {\n  model: {\n    correctResponse: [],\n    title: '',\n    prompt: '',\n    modelTypeSelected: 'bar',\n    maxModelSelected: 1,\n    partsPerModel: 5,\n    allowedStudentConfig: false,\n    showGraphLabels: false,\n  },\n  modelOptions: defaultValues.configuration.modelOptions,\n};\n\ndescribe('Model Options', () => {\n  let wrapper;\n  let component;\n\n  beforeEach(() => {\n    wrapper = (props) => {\n      const configProps = {\n        classes: {},\n        ...defaultProps,\n        ...props,\n      };\n      return shallow(<ModelOptions {...configProps} />);\n    };\n  });\n\n  it('snapshot renders', () => {\n    const component = wrapper();\n    expect(component).toMatchSnapshot();\n  });\n\n  it('renders correctly: Components mounted correctly', () => {\n    component = wrapper();\n    expect(component.find(CardBar).length).toEqual(1);\n    expect(component.find(Select).length).toEqual(1);\n    expect(component.find(MiniField).length).toEqual(2);\n    expect(component.find(Checkbox).length).toEqual(1);\n  });\n\n  it('render correctly: update model type to Pie', () => {\n    let onChange = jest.fn();\n\n    component = wrapper({\n      onChange,\n    });\n\n    component.instance().handleSelect({\n      target: { value: 'pie' },\n    });\n\n    expect(onChange).toBeCalledWith(\n      expect.objectContaining({ modelTypeSelected: 'pie' }),\n      expect.objectContaining({ modelTypeSelected: 'pie' }),\n      false,\n    );\n  });\n\n  it('render correctly: update model type to Bar', () => {\n    let onChange = jest.fn();\n\n    component = wrapper({\n      onChange,\n    });\n\n    component.instance().handleSelect({\n      target: { value: 'bar' },\n    });\n\n    expect(onChange).toBeCalledWith(\n      expect.objectContaining({ modelTypeSelected: 'bar' }),\n      expect.objectContaining({ modelTypeSelected: 'bar' }),\n      false,\n    );\n  });\n\n  it('render correctly: update max no of model', () => {\n    let onChange = jest.fn();\n\n    component = wrapper({\n      onChange,\n    });\n\n    component.instance().change('max', {}, 4);\n\n    expect(onChange).toBeCalledWith(\n      expect.objectContaining({ maxModelSelected: defaultProps.model.maxModelSelected }),\n      expect.objectContaining({ maxModelSelected: 4 }),\n      true,\n    );\n  });\n\n  it('render correctly: update parts per model', () => {\n    let onChange = jest.fn();\n\n    component = wrapper({\n      onChange,\n    });\n\n    component.instance().change('part', {}, 7);\n\n    expect(onChange).toBeCalledWith(\n      expect.objectContaining({ partsPerModel: defaultProps.model.partsPerModel }),\n      expect.objectContaining({ partsPerModel: 7 }),\n      true,\n    );\n  });\n\n  it('render correctly: update student config checkbox', () => {\n    let onChange = jest.fn();\n\n    component = wrapper({\n      onChange,\n    });\n\n    component.instance().change('student-config', {}, true);\n\n    expect(onChange).toBeCalledWith(\n      expect.objectContaining({ allowedStudentConfig: defaultProps.model.allowedStudentConfig }),\n      expect.objectContaining({ allowedStudentConfig: true }),\n      false,\n    );\n  });\n});\n"]}

package/configure/lib/card-bar.js

@@ -75,4 +75,4 @@ var styles = function styles(theme) {
 var _default = (0, _styles.withStyles)(styles)(CardBar);
 
 exports["default"] = _default;
-//# sourceMappingURL=card-bar.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/configure/lib/defaults.js

@@ -100,4 +100,4 @@ var _default = {
   }
 };
 exports["default"] = _default;
-//# sourceMappingURL=defaults.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/configure/lib/index.js

@@ -226,4 +226,4 @@ exports["default"] = FractionModelConfigure;
 
   return normalizedModel;
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["FractionModelConfigure","pieAuthors","document","querySelectorAll","hasPlayerAsParent","Array","from","some","author","contains","_modelCopy","_model","o","dispatchEvent","ModelUpdatedEvent","render","createDefaultModel","_configuration","defaultValues","configuration","m","c","newConfiguration","resetModelAfterConfigurationIsSet","language","enabled","languageChoices","options","length","value","settings","find","option","push","label","handler","InsertImageEvent","src","done","DeleteImageEvent","InsertSoundEvent","DeleteSoundEvent","el","React","createElement","Main","classes","model","onConfigurationChanged","onChange","imageSupport","add","insertImage","bind","onDeleteImage","uploadSoundSupport","insertSound","onDeleteSound","ReactDOM","HTMLElement","normalizedModel"],"mappings":"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","sourcesContent":["import React from 'react';\nimport ReactDOM from 'react-dom';\nimport Main from './main';\nimport {\n  ModelUpdatedEvent,\n  DeleteImageEvent,\n  InsertImageEvent,\n  InsertSoundEvent,\n  DeleteSoundEvent,\n} from '@pie-framework/pie-configure-events';\nimport defaultValues from './defaults';\n\nexport default class FractionModelConfigure extends HTMLElement {\n  /**\n   * This function makes sure you set the default values on the model\n   * @param model\n   * @returns model\n   */\n  static createDefaultModel = (model = {}) => {\n    const c = defaultValues.configuration;\n    let language = model.language || '';\n\n    if (!language && c.language && c.language.enabled) {\n      if (c.languageChoices?.options?.length) {\n        language = c.languageChoices.options[0].value;\n      }\n    }\n\n    const normalizedModel = {\n      ...defaultValues.model,\n      ...model,\n      language,\n    };\n\n    return normalizedModel;\n  };\n\n  constructor() {\n    super();\n    this._model = FractionModelConfigure.createDefaultModel();\n    this._configuration = defaultValues.configuration;\n  }\n\n  set model(m) {\n    this._model = FractionModelConfigure.createDefaultModel(m);\n    this.render();\n  }\n\n  set configuration(c) {\n    const newConfiguration = {\n      ...defaultValues.configuration,\n      ...c,\n    };\n    this._configuration = newConfiguration;\n\n    this.resetModelAfterConfigurationIsSet();\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    this.render();\n  }\n\n  resetModelAfterConfigurationIsSet = () => {\n    // In environments that use pie-player-components, model is set before configuration.\n    // This is the reason why sometimes the model gets altered non-reversible\n    // (altered using default configuration instead of client configuration, because at that point client configuration was not set yet)\n    // Therefore, in such environments, we will make sure to keep a modelCopy (initialised in set model) and use it to reset\n    // the model in set configuration (resetModelAfterConfigurationIsSet) if set configuration is ever called\n    const pieAuthors = document.querySelectorAll('pie-author');\n    this.hasPlayerAsParent = Array.from(pieAuthors).some((author) => author.contains(this));\n\n    if (this.hasPlayerAsParent) {\n      if (this._modelCopy) {\n        this._model = this._modelCopy;\n      } else {\n        delete this._modelCopy;\n      }\n    }\n  };\n\n  connectedCallback() {\n    this.render();\n  }\n\n  modelChanged(m) {\n    this._model = m;\n    this.dispatchEvent(new ModelUpdatedEvent(this._model), true);\n    this.render();\n  }\n\n  onChange = (o) => {\n    this._model = { ...this._model, ...o };\n    this.dispatchEvent(new ModelUpdatedEvent(this._model));\n    this.render();\n  };\n\n  onConfigurationChanged(c) {\n    this._configuration = c;\n    this.render();\n  }\n\n  /**\n   *\n   * @param {done, progress, file} handler\n   */\n  insertImage(handler) {\n    this.dispatchEvent(new InsertImageEvent(handler));\n  }\n\n  onDeleteImage(src, done) {\n    this.dispatchEvent(new DeleteImageEvent(src, done));\n  }\n\n  insertSound(handler) {\n    this.dispatchEvent(new InsertSoundEvent(handler));\n  }\n\n  onDeleteSound(src, done) {\n    this.dispatchEvent(new DeleteSoundEvent(src, done));\n  }\n\n  render() {\n    if (this._model) {\n      const el = React.createElement(Main, {\n        classes: {},\n        model: this._model,\n        configuration: this._configuration,\n        onConfigurationChanged: this.onConfigurationChanged,\n        onChange: this.onChange,\n        imageSupport: {\n          add: this.insertImage.bind(this),\n          delete: this.onDeleteImage.bind(this),\n        },\n        uploadSoundSupport: {\n          add: this.insertSound.bind(this),\n          delete: this.onDeleteSound.bind(this),\n        },\n      });\n\n      ReactDOM.render(el, this);\n    }\n  }\n}\n"]}

package/configure/lib/main.js

@@ -160,6 +160,7 @@ var Main = /*#__PURE__*/function (_React$Component) {
       var _ref2 = model || {},
           _ref2$errors = _ref2.errors,
           errors = _ref2$errors === void 0 ? {} : _ref2$errors,
+          extraCSSRules = _ref2.extraCSSRules,
           spellCheckEnabled = _ref2.spellCheckEnabled,
           toolbarEditorPosition = _ref2.toolbarEditorPosition;
 
@@ -175,6 +176,7 @@ var Main = /*#__PURE__*/function (_React$Component) {
 
       var fractionModelChartKey = this.generateRandomKey();
       return /*#__PURE__*/_react["default"].createElement(_configUi.layout.ConfigLayout, {
+        extraCSSRules: extraCSSRules,
         dimensions: contentDimensions,
         hideSettings: true
       }, /*#__PURE__*/_react["default"].createElement(_cardBar["default"], {
@@ -308,4 +310,4 @@ var _default = (0, _styles.withStyles)(styles, {
 })(Main);
 
 exports["default"] = _default;
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/main.jsx"],"names":["styles","theme","label","marginBottom","spacing","unit","tooltip","fontSize","typography","whiteSpace","maxWidth","errorText","color","palette","error","main","paddingTop","flexRow","display","alignItems","gap","errorMessage","marginTop","modelError","border","Main","props","correctResponse","model","onChange","oldModel","newModel","showDiag","length","setState","correctAnswerChangeDialog","open","text","Math","floor","random","state","classes","configuration","imageSupport","uploadSoundSupport","baseInputConfiguration","contentDimensions","title","prompt","modelOptions","mathMlOptions","errors","extraCSSRules","spellCheckEnabled","toolbarEditorPosition","toolbarOpts","position","getPluginProps","fractionModelChartKey","generateRandomKey","inputConfiguration","language","onModelOptionsChange","marginLeft","modelTypeSelected","maxModelSelected","partsPerModel","showGraphLabels","onCorrectAnswerChange","React","Component","PropTypes","object","isRequired","onConfigurationChanged","func","name"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { FormSection, layout, AlertDialog } from '@pie-lib/pie-toolbox/config-ui';\nimport { EditableHtml } from '@pie-lib/pie-toolbox/editable-html';\nimport PropTypes from 'prop-types';\nimport { withStyles } from '@material-ui/core/styles';\nimport CardBar from './card-bar';\nimport ModelOptions from './model-options';\nimport { FractionModelChart } from '@pie-element/fraction-model';\nimport Tooltip from '@material-ui/core/Tooltip';\nimport Info from '@material-ui/icons/Info';\n\nconst styles = (theme) => ({\n  label: {\n    marginBottom: theme.spacing.unit * 4,\n  },\n  tooltip: {\n    fontSize: theme.typography.fontSize - 2,\n    whiteSpace: 'pre',\n    maxWidth: '500px',\n  },\n  errorText: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    paddingTop: theme.spacing.unit,\n  },\n  flexRow: {\n    display: 'flex',\n    alignItems: 'center',\n    gap: '10px',\n  },\n  errorMessage: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    marginTop: theme.spacing.unit,\n  },\n  modelError: {\n    border: `2px solid ${theme.palette.error.main}`,\n  },\n});\n\nexport class Main extends React.Component {\n  static propTypes = {\n    classes: PropTypes.object.isRequired,\n    model: PropTypes.object.isRequired,\n    configuration: PropTypes.object.isRequired,\n    onConfigurationChanged: PropTypes.func.isRequired,\n    onChange: PropTypes.func.isRequired,\n    uploadSoundSupport: PropTypes.object.isRequired,\n  };\n\n  constructor(props) {\n    super(props);\n\n    this.state = {\n      correctAnswerChangeDialog: {\n        open: false,\n        text: '',\n      },\n    };\n  }\n\n  /*\n   * Method to handle correct answer change\n   * @param {array} correctResponse - correct response\n   * */\n  onCorrectAnswerChange = (correctResponse) => {\n    const { model, onChange } = this.props;\n    model.correctResponse = correctResponse;\n    onChange({ ...model });\n  };\n\n  /*\n   * Method to handle model options change\n   * @param {object} oldModel - old model\n   * @param {object} newModel - new model\n   * @param {boolean} showDiag - show dialog or not\n   * */\n  onModelOptionsChange = (oldModel, newModel, showDiag) => {\n    const { onChange } = this.props;\n    if (showDiag && oldModel.correctResponse.length > 0) {\n      this.setState({\n        correctAnswerChangeDialog: {\n          open: true,\n          oldModel: oldModel,\n          newModel: newModel,\n          text: 'Changing either the Number of Models or Parts per Model will remove added correct answer. Are you sure you want to continue?',\n        },\n      });\n    } else {\n      onChange({ ...newModel });\n    }\n  };\n\n  /*\n   * Method to generate random key\n   * */\n  generateRandomKey = () => {\n    return Math.floor(Math.random() * 10000);\n  };\n\n  render() {\n    const { classes, model, onChange, configuration, imageSupport, uploadSoundSupport } = this.props;\n    const {\n      baseInputConfiguration = {},\n      contentDimensions = {},\n      title = {},\n      prompt = {},\n      modelOptions = {},\n      mathMlOptions = {},\n    } = configuration || {};\n\n    const { errors = {}, extraCSSRules, spellCheckEnabled, toolbarEditorPosition } = model || {};\n\n    const { correctAnswerChangeDialog } = this.state;\n\n    const toolbarOpts = {\n      position: toolbarEditorPosition === 'top' ? 'top' : 'bottom',\n    };\n\n    const getPluginProps = (props = {}) => ({\n      ...baseInputConfiguration,\n      ...props,\n    });\n\n    const fractionModelChartKey = this.generateRandomKey();\n\n    return (\n      <layout.ConfigLayout extraCSSRules={extraCSSRules} dimensions={contentDimensions} hideSettings={true}>\n        <CardBar header=\"Set Up\"></CardBar>\n\n        <FormSection label={title?.label || 'Title'} className={classes.label}>\n          <EditableHtml\n            className={classes.title}\n            markup={model.title || ''}\n            onChange={(title) => onChange({ title })}\n            toolbarOpts={toolbarOpts}\n            activePlugins={[\n              'bold',\n              'html',\n              'italic',\n              'underline',\n              'strikethrough',\n              'image',\n              'math',\n              'languageCharacters',\n              'responseArea',\n            ]}\n            pluginProps={getPluginProps(title?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection label={prompt?.label || 'Question'} className={classes.label}>\n          <EditableHtml\n            markup={model.prompt || ''}\n            minHeight={60}\n            onChange={(prompt) => onChange({ prompt })}\n            toolbarOpts={toolbarOpts}\n            pluginProps={getPluginProps(prompt?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            imageSupport={imageSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection>\n          <ModelOptions model={model} onChange={this.onModelOptionsChange} modelOptions={modelOptions} />\n        </FormSection>\n\n        <FormSection>\n          <CardBar\n            header=\"Correct Answer\"\n            info={\n              <Tooltip\n                classes={{ tooltip: classes.tooltip }}\n                disableFocusListener\n                disableTouchListener\n                placement={'right'}\n                title={'The correct answer should include no more than one partially-filled model'}\n              >\n                <Info fontSize={'small'} color={'primary'} style={{ marginLeft: '8px' }} />\n              </Tooltip>\n            }\n          ></CardBar>\n\n          <br />\n          <label className={classes.label}>\n            Click/touch the number of parts to represent the correct fraction model\n          </label>\n          <br />\n\n          <div className={errors.correctResponse && classes.modelError}>\n            <FractionModelChart\n              key={fractionModelChartKey}\n              value={model.correctResponse}\n              modelType={model.modelTypeSelected}\n              noOfModels={model.maxModelSelected}\n              partsPerModel={model.partsPerModel}\n              showLabel={model.showGraphLabels}\n              onChange={this.onCorrectAnswerChange}\n            ></FractionModelChart>\n          </div>\n\n          {errors.correctResponse && <div className={classes.errorMessage}>{errors.correctResponse}</div>}\n        </FormSection>\n\n        <AlertDialog\n          open={correctAnswerChangeDialog.open}\n          title=\"Warning\"\n          text={correctAnswerChangeDialog.text}\n          onConfirm={() => {\n            let newModel = this.state.correctAnswerChangeDialog.newModel;\n            newModel.correctResponse = [];\n            onChange({ ...newModel });\n            this.setState({\n              correctAnswerChangeDialog: { open: false },\n            });\n          }}\n          onClose={() => {\n            const oldModel = this.state.correctAnswerChangeDialog.oldModel;\n            onChange({ ...oldModel });\n            this.setState({ correctAnswerChangeDialog: { open: false } });\n          }}\n          onConfirmText={'OK'}\n          onCloseText={'Cancel'}\n        />\n      </layout.ConfigLayout>\n    );\n  }\n}\n\nexport default withStyles(styles, { name: 'Main' })(Main);\n"]}

package/configure/lib/main.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/main.jsx"],"names":["styles","theme","label","marginBottom","spacing","unit","tooltip","fontSize","typography","whiteSpace","maxWidth","errorText","color","palette","error","main","paddingTop","flexRow","display","alignItems","gap","errorMessage","marginTop","modelError","border","Main","props","correctResponse","model","onChange","oldModel","newModel","showDiag","length","setState","correctAnswerChangeDialog","open","text","Math","floor","random","state","classes","configuration","imageSupport","uploadSoundSupport","baseInputConfiguration","contentDimensions","title","prompt","modelOptions","mathMlOptions","errors","spellCheckEnabled","toolbarEditorPosition","toolbarOpts","position","getPluginProps","fractionModelChartKey","generateRandomKey","inputConfiguration","language","onModelOptionsChange","marginLeft","modelTypeSelected","maxModelSelected","partsPerModel","showGraphLabels","onCorrectAnswerChange","React","Component","PropTypes","object","isRequired","onConfigurationChanged","func","name"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { FormSection, layout, AlertDialog } from '@pie-lib/pie-toolbox/config-ui';\nimport { EditableHtml } from '@pie-lib/pie-toolbox/editable-html';\nimport PropTypes from 'prop-types';\nimport { withStyles } from '@material-ui/core/styles';\nimport CardBar from './card-bar';\nimport ModelOptions from './model-options';\nimport { FractionModelChart } from '@pie-element/fraction-model';\nimport Tooltip from '@material-ui/core/Tooltip';\nimport Info from '@material-ui/icons/Info';\n\nconst styles = (theme) => ({\n  label: {\n    marginBottom: theme.spacing.unit * 4,\n  },\n  tooltip: {\n    fontSize: theme.typography.fontSize - 2,\n    whiteSpace: 'pre',\n    maxWidth: '500px',\n  },\n  errorText: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    paddingTop: theme.spacing.unit,\n  },\n  flexRow: {\n    display: 'flex',\n    alignItems: 'center',\n    gap: '10px',\n  },\n  errorMessage: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    marginTop: theme.spacing.unit,\n  },\n  modelError: {\n    border: `2px solid ${theme.palette.error.main}`,\n  },\n});\n\nexport class Main extends React.Component {\n  static propTypes = {\n    classes: PropTypes.object.isRequired,\n    model: PropTypes.object.isRequired,\n    configuration: PropTypes.object.isRequired,\n    onConfigurationChanged: PropTypes.func.isRequired,\n    onChange: PropTypes.func.isRequired,\n    uploadSoundSupport: PropTypes.object.isRequired,\n  };\n\n  constructor(props) {\n    super(props);\n\n    this.state = {\n      correctAnswerChangeDialog: {\n        open: false,\n        text: '',\n      },\n    };\n  }\n\n  /*\n   * Method to handle correct answer change\n   * @param {array} correctResponse - correct response\n   * */\n  onCorrectAnswerChange = (correctResponse) => {\n    const { model, onChange } = this.props;\n    model.correctResponse = correctResponse;\n    onChange({ ...model });\n  };\n\n  /*\n   * Method to handle model options change\n   * @param {object} oldModel - old model\n   * @param {object} newModel - new model\n   * @param {boolean} showDiag - show dialog or not\n   * */\n  onModelOptionsChange = (oldModel, newModel, showDiag) => {\n    const { onChange } = this.props;\n    if (showDiag && oldModel.correctResponse.length > 0) {\n      this.setState({\n        correctAnswerChangeDialog: {\n          open: true,\n          oldModel: oldModel,\n          newModel: newModel,\n          text: 'Changing either the Number of Models or Parts per Model will remove added correct answer. Are you sure you want to continue?',\n        },\n      });\n    } else {\n      onChange({ ...newModel });\n    }\n  };\n\n  /*\n   * Method to generate random key\n   * */\n  generateRandomKey = () => {\n    return Math.floor(Math.random() * 10000);\n  };\n\n  render() {\n    const { classes, model, onChange, configuration, imageSupport, uploadSoundSupport } = this.props;\n    const {\n      baseInputConfiguration = {},\n      contentDimensions = {},\n      title = {},\n      prompt = {},\n      modelOptions = {},\n      mathMlOptions = {},\n    } = configuration || {};\n\n    const { errors = {}, spellCheckEnabled, toolbarEditorPosition } = model || {};\n\n    const { correctAnswerChangeDialog } = this.state;\n\n    const toolbarOpts = {\n      position: toolbarEditorPosition === 'top' ? 'top' : 'bottom',\n    };\n\n    const getPluginProps = (props = {}) => ({\n      ...baseInputConfiguration,\n      ...props,\n    });\n\n    const fractionModelChartKey = this.generateRandomKey();\n\n    return (\n      <layout.ConfigLayout dimensions={contentDimensions} hideSettings={true}>\n        <CardBar header=\"Set Up\"></CardBar>\n\n        <FormSection label={title?.label || 'Title'} className={classes.label}>\n          <EditableHtml\n            className={classes.title}\n            markup={model.title || ''}\n            onChange={(title) => onChange({ title })}\n            toolbarOpts={toolbarOpts}\n            activePlugins={[\n              'bold',\n              'html',\n              'italic',\n              'underline',\n              'strikethrough',\n              'image',\n              'math',\n              'languageCharacters',\n              'responseArea',\n            ]}\n            pluginProps={getPluginProps(title?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection label={prompt?.label || 'Question'} className={classes.label}>\n          <EditableHtml\n            markup={model.prompt || ''}\n            minHeight={60}\n            onChange={(prompt) => onChange({ prompt })}\n            toolbarOpts={toolbarOpts}\n            pluginProps={getPluginProps(prompt?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            imageSupport={imageSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection>\n          <ModelOptions model={model} onChange={this.onModelOptionsChange} modelOptions={modelOptions} />\n        </FormSection>\n\n        <FormSection>\n          <CardBar\n            header=\"Correct Answer\"\n            info={\n              <Tooltip\n                classes={{ tooltip: classes.tooltip }}\n                disableFocusListener\n                disableTouchListener\n                placement={'right'}\n                title={'The correct answer should include no more than one partially-filled model'}\n              >\n                <Info fontSize={'small'} color={'primary'} style={{ marginLeft: '8px' }} />\n              </Tooltip>\n            }\n          ></CardBar>\n\n          <br />\n          <label className={classes.label}>\n            Click/touch the number of parts to represent the correct fraction model\n          </label>\n          <br />\n\n          <div className={errors.correctResponse && classes.modelError}>\n            <FractionModelChart\n              key={fractionModelChartKey}\n              value={model.correctResponse}\n              modelType={model.modelTypeSelected}\n              noOfModels={model.maxModelSelected}\n              partsPerModel={model.partsPerModel}\n              showLabel={model.showGraphLabels}\n              onChange={this.onCorrectAnswerChange}\n            ></FractionModelChart>\n          </div>\n\n          {errors.correctResponse && <div className={classes.errorMessage}>{errors.correctResponse}</div>}\n        </FormSection>\n\n        <AlertDialog\n          open={correctAnswerChangeDialog.open}\n          title=\"Warning\"\n          text={correctAnswerChangeDialog.text}\n          onConfirm={() => {\n            let newModel = this.state.correctAnswerChangeDialog.newModel;\n            newModel.correctResponse = [];\n            onChange({ ...newModel });\n            this.setState({\n              correctAnswerChangeDialog: { open: false },\n            });\n          }}\n          onClose={() => {\n            const oldModel = this.state.correctAnswerChangeDialog.oldModel;\n            onChange({ ...oldModel });\n            this.setState({ correctAnswerChangeDialog: { open: false } });\n          }}\n          onConfirmText={'OK'}\n          onCloseText={'Cancel'}\n        />\n      </layout.ConfigLayout>\n    );\n  }\n}\n\nexport default withStyles(styles, { name: 'Main' })(Main);\n"],"file":"main.js"}
+{"version":3,"sources":["../src/main.jsx"],"names":["styles","theme","label","marginBottom","spacing","unit","tooltip","fontSize","typography","whiteSpace","maxWidth","errorText","color","palette","error","main","paddingTop","flexRow","display","alignItems","gap","errorMessage","marginTop","modelError","border","Main","props","correctResponse","model","onChange","oldModel","newModel","showDiag","length","setState","correctAnswerChangeDialog","open","text","Math","floor","random","state","classes","configuration","imageSupport","uploadSoundSupport","baseInputConfiguration","contentDimensions","title","prompt","modelOptions","mathMlOptions","errors","extraCSSRules","spellCheckEnabled","toolbarEditorPosition","toolbarOpts","position","getPluginProps","fractionModelChartKey","generateRandomKey","inputConfiguration","language","onModelOptionsChange","marginLeft","modelTypeSelected","maxModelSelected","partsPerModel","showGraphLabels","onCorrectAnswerChange","React","Component","PropTypes","object","isRequired","onConfigurationChanged","func","name"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { FormSection, layout, AlertDialog } from '@pie-lib/pie-toolbox/config-ui';\nimport { EditableHtml } from '@pie-lib/pie-toolbox/editable-html';\nimport PropTypes from 'prop-types';\nimport { withStyles } from '@material-ui/core/styles';\nimport CardBar from './card-bar';\nimport ModelOptions from './model-options';\nimport { FractionModelChart } from '@pie-element/fraction-model';\nimport Tooltip from '@material-ui/core/Tooltip';\nimport Info from '@material-ui/icons/Info';\n\nconst styles = (theme) => ({\n  label: {\n    marginBottom: theme.spacing.unit * 4,\n  },\n  tooltip: {\n    fontSize: theme.typography.fontSize - 2,\n    whiteSpace: 'pre',\n    maxWidth: '500px',\n  },\n  errorText: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    paddingTop: theme.spacing.unit,\n  },\n  flexRow: {\n    display: 'flex',\n    alignItems: 'center',\n    gap: '10px',\n  },\n  errorMessage: {\n    fontSize: theme.typography.fontSize - 2,\n    color: theme.palette.error.main,\n    marginTop: theme.spacing.unit,\n  },\n  modelError: {\n    border: `2px solid ${theme.palette.error.main}`,\n  },\n});\n\nexport class Main extends React.Component {\n  static propTypes = {\n    classes: PropTypes.object.isRequired,\n    model: PropTypes.object.isRequired,\n    configuration: PropTypes.object.isRequired,\n    onConfigurationChanged: PropTypes.func.isRequired,\n    onChange: PropTypes.func.isRequired,\n    uploadSoundSupport: PropTypes.object.isRequired,\n  };\n\n  constructor(props) {\n    super(props);\n\n    this.state = {\n      correctAnswerChangeDialog: {\n        open: false,\n        text: '',\n      },\n    };\n  }\n\n  /*\n   * Method to handle correct answer change\n   * @param {array} correctResponse - correct response\n   * */\n  onCorrectAnswerChange = (correctResponse) => {\n    const { model, onChange } = this.props;\n    model.correctResponse = correctResponse;\n    onChange({ ...model });\n  };\n\n  /*\n   * Method to handle model options change\n   * @param {object} oldModel - old model\n   * @param {object} newModel - new model\n   * @param {boolean} showDiag - show dialog or not\n   * */\n  onModelOptionsChange = (oldModel, newModel, showDiag) => {\n    const { onChange } = this.props;\n    if (showDiag && oldModel.correctResponse.length > 0) {\n      this.setState({\n        correctAnswerChangeDialog: {\n          open: true,\n          oldModel: oldModel,\n          newModel: newModel,\n          text: 'Changing either the Number of Models or Parts per Model will remove added correct answer. Are you sure you want to continue?',\n        },\n      });\n    } else {\n      onChange({ ...newModel });\n    }\n  };\n\n  /*\n   * Method to generate random key\n   * */\n  generateRandomKey = () => {\n    return Math.floor(Math.random() * 10000);\n  };\n\n  render() {\n    const { classes, model, onChange, configuration, imageSupport, uploadSoundSupport } = this.props;\n    const {\n      baseInputConfiguration = {},\n      contentDimensions = {},\n      title = {},\n      prompt = {},\n      modelOptions = {},\n      mathMlOptions = {},\n    } = configuration || {};\n\n    const { errors = {}, extraCSSRules, spellCheckEnabled, toolbarEditorPosition } = model || {};\n\n    const { correctAnswerChangeDialog } = this.state;\n\n    const toolbarOpts = {\n      position: toolbarEditorPosition === 'top' ? 'top' : 'bottom',\n    };\n\n    const getPluginProps = (props = {}) => ({\n      ...baseInputConfiguration,\n      ...props,\n    });\n\n    const fractionModelChartKey = this.generateRandomKey();\n\n    return (\n      <layout.ConfigLayout extraCSSRules={extraCSSRules} dimensions={contentDimensions} hideSettings={true}>\n        <CardBar header=\"Set Up\"></CardBar>\n\n        <FormSection label={title?.label || 'Title'} className={classes.label}>\n          <EditableHtml\n            className={classes.title}\n            markup={model.title || ''}\n            onChange={(title) => onChange({ title })}\n            toolbarOpts={toolbarOpts}\n            activePlugins={[\n              'bold',\n              'html',\n              'italic',\n              'underline',\n              'strikethrough',\n              'image',\n              'math',\n              'languageCharacters',\n              'responseArea',\n            ]}\n            pluginProps={getPluginProps(title?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection label={prompt?.label || 'Question'} className={classes.label}>\n          <EditableHtml\n            markup={model.prompt || ''}\n            minHeight={60}\n            onChange={(prompt) => onChange({ prompt })}\n            toolbarOpts={toolbarOpts}\n            pluginProps={getPluginProps(prompt?.inputConfiguration)}\n            spellCheck={spellCheckEnabled}\n            uploadSoundSupport={uploadSoundSupport}\n            imageSupport={imageSupport}\n            languageCharactersProps={[{ language: 'spanish' }, { language: 'special' }]}\n            mathMlOptions={mathMlOptions}\n          />\n        </FormSection>\n\n        <FormSection>\n          <ModelOptions model={model} onChange={this.onModelOptionsChange} modelOptions={modelOptions} />\n        </FormSection>\n\n        <FormSection>\n          <CardBar\n            header=\"Correct Answer\"\n            info={\n              <Tooltip\n                classes={{ tooltip: classes.tooltip }}\n                disableFocusListener\n                disableTouchListener\n                placement={'right'}\n                title={'The correct answer should include no more than one partially-filled model'}\n              >\n                <Info fontSize={'small'} color={'primary'} style={{ marginLeft: '8px' }} />\n              </Tooltip>\n            }\n          ></CardBar>\n\n          <br />\n          <label className={classes.label}>\n            Click/touch the number of parts to represent the correct fraction model\n          </label>\n          <br />\n\n          <div className={errors.correctResponse && classes.modelError}>\n            <FractionModelChart\n              key={fractionModelChartKey}\n              value={model.correctResponse}\n              modelType={model.modelTypeSelected}\n              noOfModels={model.maxModelSelected}\n              partsPerModel={model.partsPerModel}\n              showLabel={model.showGraphLabels}\n              onChange={this.onCorrectAnswerChange}\n            ></FractionModelChart>\n          </div>\n\n          {errors.correctResponse && <div className={classes.errorMessage}>{errors.correctResponse}</div>}\n        </FormSection>\n\n        <AlertDialog\n          open={correctAnswerChangeDialog.open}\n          title=\"Warning\"\n          text={correctAnswerChangeDialog.text}\n          onConfirm={() => {\n            let newModel = this.state.correctAnswerChangeDialog.newModel;\n            newModel.correctResponse = [];\n            onChange({ ...newModel });\n            this.setState({\n              correctAnswerChangeDialog: { open: false },\n            });\n          }}\n          onClose={() => {\n            const oldModel = this.state.correctAnswerChangeDialog.oldModel;\n            onChange({ ...oldModel });\n            this.setState({ correctAnswerChangeDialog: { open: false } });\n          }}\n          onConfirmText={'OK'}\n          onCloseText={'Cancel'}\n        />\n      </layout.ConfigLayout>\n    );\n  }\n}\n\nexport default withStyles(styles, { name: 'Main' })(Main);\n"],"file":"main.js"}

package/configure/lib/model-options.js

@@ -218,4 +218,4 @@ var _default = (0, _styles.withStyles)(styles, {
 })(ModelOptions);
 
 exports["default"] = _default;
-//# sourceMappingURL=model-options.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/model-options.jsx"],"names":["ModelOptions","props","value","model","onChange","modelTypeSelected","target","changeMaxModel","change","bind","changePartModel","studentConfig","key","event","oldModel","newModel","showDiag","maxModelSelected","partsPerModel","allowedStudentConfig","classes","modelOptions","maxOfModel","modelTypeChoices","groupInline","group","inputLabel","container2","handleSelect","map","choice","index","label","min","max","checkbox","chkLabel","React","Component","PropTypes","object","isRequired","func","styles","alignItems","display","gap","margin","marginBottom","labelWidth","width","height","verticalAlign","border","borderRadius","paddingLeft","marginLeft","name"],"mappings":"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","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport { MiniField } from './number-text-field';\nimport { withStyles } from '@material-ui/core/styles';\nimport Select from '@material-ui/core/Select';\nimport MenuItem from '@material-ui/core/MenuItem';\nimport CardBar from './card-bar';\nimport { Checkbox } from '@pie-lib/pie-toolbox/config-ui';\nimport cloneDeep from 'lodash/cloneDeep';\n\nexport class ModelOptions extends React.Component {\n  static propTypes = {\n    model: PropTypes.object.isRequired,\n    classes: PropTypes.object,\n    onChange: PropTypes.func,\n    modelOptions: PropTypes.object.isRequired,\n  };\n\n  constructor(props) {\n    super(props);\n    this.changeMaxModel = this.change.bind(this, 'max');\n    this.changePartModel = this.change.bind(this, 'part');\n    this.studentConfig = this.change.bind(this, 'student-config');\n  }\n\n  /**\n   * Function to trigger when DOM elements value change for Number type\n   * @param {string} key contains key of element\n   * @param {object} event contains event object\n   * @param {string} value contains value of DOM element\n   */\n  change(key, event, value) {\n    const { model, onChange } = this.props;\n    const oldModel = cloneDeep(model);\n    let newModel = cloneDeep(model);\n    let showDiag = false;\n    if (key === 'max') {\n      newModel.maxModelSelected = value;\n      showDiag = true;\n    } else if (key === 'part') {\n      newModel.partsPerModel = value;\n      showDiag = true;\n    } else if (key === 'student-config') {\n      newModel.allowedStudentConfig = value;\n      showDiag = false;\n    }\n    onChange(oldModel, newModel, showDiag);\n  }\n\n  /**\n   * Function to trigger on change of dropdown value model type\n   * @param {string} value contains selection value\n   */\n  handleSelect = (value) => {\n    const { model, onChange } = this.props;\n    model.modelTypeSelected = value?.target.value;\n    onChange(model, { ...model }, false);\n  };\n\n  render() {\n    const { model, classes, modelOptions } = this.props;\n    const { maxOfModel, partsPerModel, modelTypeChoices } = modelOptions;\n\n    return (\n      <div>\n        <CardBar header=\"Configure Fraction Model\"></CardBar>\n        <br />\n        <div className={classes.groupInline}>\n          <div className={classes.group}>\n            <label className={classes.inputLabel}>Model Type</label>\n            <Select className={classes.container2} onChange={this.handleSelect} value={model.modelTypeSelected}>\n              {modelTypeChoices.map((choice, index) => (\n                <MenuItem key={'item_' + index} value={choice.value}>\n                  {choice.label}\n                </MenuItem>\n              ))}\n            </Select>\n          </div>\n          <div className={classes.group}>\n            <label className={classes.inputLabel}>Max # of Models</label>\n            <MiniField\n              min={maxOfModel.min}\n              max={maxOfModel.max}\n              value={model.maxModelSelected}\n              name=\"max-model\"\n              onChange={this.changeMaxModel}\n            />\n          </div>\n          <div className={classes.group}>\n            <label className={classes.inputLabel}>Parts per Model</label>\n            <MiniField\n              min={partsPerModel.min}\n              max={partsPerModel.max}\n              value={model.partsPerModel}\n              name=\"model-parts\"\n              onChange={this.changePartModel}\n            />\n          </div>\n        </div>\n        <div className={classes.checkbox}>\n          <Checkbox onChange={this.studentConfig} checked={model.allowedStudentConfig} label={''} />\n          <span className={classes.chkLabel}>Allow student to configure number of models and parts per model</span>\n        </div>\n      </div>\n    );\n  }\n}\n\nconst styles = () => ({\n  groupInline: {\n    alignItems: 'center',\n    display: 'flex',\n    gap: '20px',\n  },\n  group: {\n    margin: '12px 0',\n  },\n  inputLabel: {\n    display: 'block',\n    marginBottom: '4px',\n  },\n  labelWidth: {\n    width: '35%',\n  },\n  container2: {\n    width: '80px',\n    alignItems: 'center',\n    height: '40px',\n    verticalAlign: 'top',\n    border: '1px solid rgb(0, 0, 0, 0.23)',\n    borderRadius: '4px',\n    marginBottom: '8px',\n    paddingLeft: '10px',\n    ':hover': {\n      border: '1px solid rgb(0, 0, 0, 0.87)',\n    },\n  },\n  checkbox: {\n    marginLeft: '-15px',\n  },\n  chkLabel: {\n    verticalAlign: 'middle',\n  },\n});\n\nexport default withStyles(styles, { name: 'ModelOptions' })(ModelOptions);\n"]}