@pie-element/placement-ordering 14.3.1 → 14.3.2-beta.3

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

@@ -0,0 +1,283 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+require("@testing-library/jest-dom");
+var _choiceTile = require("../choice-tile");
+// Mock dependencies
+jest.mock('@dnd-kit/core', () => ({
+  useDraggable: () => ({
+    attributes: {
+      'data-draggable': 'true'
+    },
+    listeners: {
+      onPointerDown: jest.fn()
+    },
+    setNodeRef: jest.fn(),
+    transform: null,
+    isDragging: false
+  }),
+  useDroppable: () => ({
+    setNodeRef: jest.fn(),
+    isOver: false
+  })
+}));
+jest.mock('@pie-lib/editable-html-tip-tap', () => ({
+  __esModule: true,
+  default: ({
+    markup,
+    onChange,
+    disabled,
+    placeholder,
+    error
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "editable-html"
+  }, /*#__PURE__*/_react.default.createElement("input", {
+    "data-testid": "editable-input",
+    value: markup,
+    onChange: e => onChange(e.target.value),
+    disabled: disabled,
+    placeholder: placeholder
+  }), error && /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "editable-error"
+  }, error)),
+  DEFAULT_PLUGINS: ['bold', 'italic', 'underline', 'bulleted-list', 'numbered-list']
+}));
+jest.mock('@pie-lib/render-ui', () => ({
+  color: {
+    tertiary: () => '#666666'
+  }
+}));
+describe('ChoiceTile', () => {
+  let defaultProps;
+  beforeEach(() => {
+    defaultProps = {
+      choice: {
+        id: 'c1',
+        label: 'Test choice',
+        editable: true,
+        type: 'choice'
+      },
+      index: 0,
+      choices: [],
+      onChoiceChange: jest.fn(),
+      onDelete: jest.fn(),
+      imageSupport: {
+        add: jest.fn(),
+        delete: jest.fn()
+      },
+      spellCheck: true,
+      toolbarOpts: {},
+      pluginProps: {},
+      maxImageWidth: {
+        unit: 'px',
+        value: 300
+      },
+      maxImageHeight: {
+        unit: 'px',
+        value: 300
+      },
+      error: null,
+      mathMlOptions: {}
+    };
+  });
+  describe('rendering', () => {
+    it('should render without crashing', () => {
+      const {
+        container
+      } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      expect(container).toBeTruthy();
+    });
+    it('should render with correct label', () => {
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      const input = _react2.screen.getByTestId('editable-input');
+      expect(input).toHaveValue('Test choice');
+    });
+    it('should render drag handle', () => {
+      const {
+        container
+      } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      const dragHandle = container.querySelector('[data-testid="DragHandleIcon"]');
+      expect(container.querySelector('[data-draggable="true"]')).toBeInTheDocument();
+    });
+    it('should render delete button when editable', () => {
+      const {
+        container
+      } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      const deleteButton = container.querySelector('button');
+      expect(deleteButton).toBeInTheDocument();
+    });
+    it('should not render delete button when not editable', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          editable: false
+        }
+      };
+      const {
+        container
+      } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const buttons = container.querySelectorAll('button');
+      // No delete button when not editable
+      expect(buttons.length).toBe(0);
+    });
+    it('should show placeholder for empty choice', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          label: ''
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const input = _react2.screen.getByTestId('editable-input');
+      expect(input).toHaveAttribute('placeholder', 'Enter a choice');
+    });
+    it('should not show placeholder for target type', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          type: 'target',
+          label: ''
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const input = _react2.screen.getByTestId('editable-input');
+      expect(input).toHaveAttribute('placeholder', '');
+    });
+    it('should not show placeholder for LaTeX content', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          label: '<span data-latex="\\frac{1}{2}"></span>'
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const input = _react2.screen.getByTestId('editable-input');
+      expect(input).toHaveAttribute('placeholder', '');
+    });
+  });
+  describe('interactions', () => {
+    it('should call onDelete when delete button is clicked', () => {
+      const {
+        container
+      } = (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      const deleteButton = container.querySelector('button');
+      _react2.fireEvent.click(deleteButton);
+      expect(defaultProps.onDelete).toHaveBeenCalled();
+    });
+    it('should call onChoiceChange when label is changed', () => {
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      const input = _react2.screen.getByTestId('editable-input');
+      _react2.fireEvent.change(input, {
+        target: {
+          value: 'Updated choice'
+        }
+      });
+      expect(defaultProps.onChoiceChange).toHaveBeenCalledWith({
+        ...defaultProps.choice,
+        label: 'Updated choice'
+      });
+    });
+    it('should not allow changes when disabled', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          editable: false
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const input = _react2.screen.getByTestId('editable-input');
+      expect(input).toBeDisabled();
+    });
+  });
+  describe('errors', () => {
+    it('should display error message when editable and error exists', () => {
+      const props = {
+        ...defaultProps,
+        error: 'This field is required'
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      const errorElements = _react2.screen.getAllByText('This field is required');
+      expect(errorElements).toHaveLength(2); // error appears in both EditableHtml and the component
+      expect(errorElements[0]).toBeInTheDocument();
+    });
+    it('should pass error to EditableHtml', () => {
+      const props = {
+        ...defaultProps,
+        error: 'This field is required'
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      expect(_react2.screen.getByTestId('editable-error')).toHaveTextContent('This field is required');
+    });
+    it('should not display error when not editable', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          ...defaultProps.choice,
+          editable: false
+        },
+        error: 'This field is required'
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      expect(_react2.screen.queryByText('This field is required')).not.toBeInTheDocument();
+    });
+  });
+  describe('image support', () => {
+    it('should pass imageSupport to EditableHtml', () => {
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, defaultProps));
+      expect(_react2.screen.getByTestId('editable-html')).toBeInTheDocument();
+    });
+    it('should pass maxImageWidth and maxImageHeight', () => {
+      const props = {
+        ...defaultProps,
+        maxImageWidth: {
+          unit: 'px',
+          value: 500
+        },
+        maxImageHeight: {
+          unit: 'px',
+          value: 400
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      expect(_react2.screen.getByTestId('editable-html')).toBeInTheDocument();
+    });
+  });
+  describe('drag and drop IDs', () => {
+    it('should generate correct draggable ID', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          id: 'c1',
+          label: 'Choice 1',
+          type: 'choice',
+          editable: true
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      // The component uses draggableId: `${type}-${choice.id}` => 'choice-c1'
+      expect(_react2.screen.getByTestId('editable-html')).toBeInTheDocument();
+    });
+    it('should generate correct droppable ID', () => {
+      const props = {
+        ...defaultProps,
+        choice: {
+          id: 'c1',
+          label: 'Choice 1',
+          type: 'target',
+          editable: false
+        }
+      };
+      (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_choiceTile.ChoiceTile, props));
+      // The component uses droppableId: `${type}-drop-${choice.id}` => 'target-drop-c1'
+      expect(_react2.screen.getByTestId('editable-html')).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_choiceTile","jest","mock","useDraggable","attributes","listeners","onPointerDown","fn","setNodeRef","transform","isDragging","useDroppable","isOver","__esModule","default","markup","onChange","disabled","placeholder","error","createElement","value","e","target","DEFAULT_PLUGINS","color","tertiary","describe","defaultProps","beforeEach","choice","id","label","editable","type","index","choices","onChoiceChange","onDelete","imageSupport","add","delete","spellCheck","toolbarOpts","pluginProps","maxImageWidth","unit","maxImageHeight","mathMlOptions","it","container","render","ChoiceTile","expect","toBeTruthy","input","screen","getByTestId","toHaveValue","dragHandle","querySelector","toBeInTheDocument","deleteButton","props","buttons","querySelectorAll","length","toBe","toHaveAttribute","fireEvent","click","toHaveBeenCalled","change","toHaveBeenCalledWith","toBeDisabled","errorElements","getAllByText","toHaveLength","toHaveTextContent","queryByText","not"],"sources":["../../src/__tests__/choice-tile.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, fireEvent, screen } from '@testing-library/react';\nimport '@testing-library/jest-dom';\nimport { ChoiceTile } from '../choice-tile';\n\n// Mock dependencies\njest.mock('@dnd-kit/core', () => ({\n  useDraggable: () => ({\n    attributes: { 'data-draggable': 'true' },\n    listeners: { onPointerDown: jest.fn() },\n    setNodeRef: jest.fn(),\n    transform: null,\n    isDragging: false,\n  }),\n  useDroppable: () => ({\n    setNodeRef: jest.fn(),\n    isOver: false,\n  }),\n}));\n\njest.mock('@pie-lib/editable-html-tip-tap', () => ({\n  __esModule: true,\n  default: ({ markup, onChange, disabled, placeholder, error }) => (\n    <div data-testid=\"editable-html\">\n      <input\n        data-testid=\"editable-input\"\n        value={markup}\n        onChange={(e) => onChange(e.target.value)}\n        disabled={disabled}\n        placeholder={placeholder}\n      />\n      {error && <div data-testid=\"editable-error\">{error}</div>}\n    </div>\n  ),\n  DEFAULT_PLUGINS: ['bold', 'italic', 'underline', 'bulleted-list', 'numbered-list'],\n}));\n\njest.mock('@pie-lib/render-ui', () => ({\n  color: {\n    tertiary: () => '#666666',\n  },\n}));\n\ndescribe('ChoiceTile', () => {\n  let defaultProps;\n\n  beforeEach(() => {\n    defaultProps = {\n      choice: {\n        id: 'c1',\n        label: 'Test choice',\n        editable: true,\n        type: 'choice',\n      },\n      index: 0,\n      choices: [],\n      onChoiceChange: jest.fn(),\n      onDelete: jest.fn(),\n      imageSupport: {\n        add: jest.fn(),\n        delete: jest.fn(),\n      },\n      spellCheck: true,\n      toolbarOpts: {},\n      pluginProps: {},\n      maxImageWidth: { unit: 'px', value: 300 },\n      maxImageHeight: { unit: 'px', value: 300 },\n      error: null,\n      mathMlOptions: {},\n    };\n  });\n\n  describe('rendering', () => {\n    it('should render without crashing', () => {\n      const { container } = render(<ChoiceTile {...defaultProps} />);\n      expect(container).toBeTruthy();\n    });\n\n    it('should render with correct label', () => {\n      render(<ChoiceTile {...defaultProps} />);\n      const input = screen.getByTestId('editable-input');\n      expect(input).toHaveValue('Test choice');\n    });\n\n    it('should render drag handle', () => {\n      const { container } = render(<ChoiceTile {...defaultProps} />);\n      const dragHandle = container.querySelector('[data-testid=\"DragHandleIcon\"]');\n      expect(container.querySelector('[data-draggable=\"true\"]')).toBeInTheDocument();\n    });\n\n    it('should render delete button when editable', () => {\n      const { container } = render(<ChoiceTile {...defaultProps} />);\n      const deleteButton = container.querySelector('button');\n      expect(deleteButton).toBeInTheDocument();\n    });\n\n    it('should not render delete button when not editable', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          editable: false,\n        },\n      };\n\n      const { container } = render(<ChoiceTile {...props} />);\n      const buttons = container.querySelectorAll('button');\n      // No delete button when not editable\n      expect(buttons.length).toBe(0);\n    });\n\n    it('should show placeholder for empty choice', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          label: '',\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      const input = screen.getByTestId('editable-input');\n      expect(input).toHaveAttribute('placeholder', 'Enter a choice');\n    });\n\n    it('should not show placeholder for target type', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          type: 'target',\n          label: '',\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      const input = screen.getByTestId('editable-input');\n      expect(input).toHaveAttribute('placeholder', '');\n    });\n\n    it('should not show placeholder for LaTeX content', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          label: '<span data-latex=\"\\\\frac{1}{2}\"></span>',\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      const input = screen.getByTestId('editable-input');\n      expect(input).toHaveAttribute('placeholder', '');\n    });\n  });\n\n  describe('interactions', () => {\n    it('should call onDelete when delete button is clicked', () => {\n      const { container } = render(<ChoiceTile {...defaultProps} />);\n      const deleteButton = container.querySelector('button');\n\n      fireEvent.click(deleteButton);\n\n      expect(defaultProps.onDelete).toHaveBeenCalled();\n    });\n\n    it('should call onChoiceChange when label is changed', () => {\n      render(<ChoiceTile {...defaultProps} />);\n      const input = screen.getByTestId('editable-input');\n\n      fireEvent.change(input, { target: { value: 'Updated choice' } });\n\n      expect(defaultProps.onChoiceChange).toHaveBeenCalledWith({\n        ...defaultProps.choice,\n        label: 'Updated choice',\n      });\n    });\n\n    it('should not allow changes when disabled', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          editable: false,\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      const input = screen.getByTestId('editable-input');\n\n      expect(input).toBeDisabled();\n    });\n  });\n\n  describe('errors', () => {\n    it('should display error message when editable and error exists', () => {\n      const props = {\n        ...defaultProps,\n        error: 'This field is required',\n      };\n\n      render(<ChoiceTile {...props} />);\n      const errorElements = screen.getAllByText('This field is required');\n      expect(errorElements).toHaveLength(2); // error appears in both EditableHtml and the component\n      expect(errorElements[0]).toBeInTheDocument();\n    });\n\n    it('should pass error to EditableHtml', () => {\n      const props = {\n        ...defaultProps,\n        error: 'This field is required',\n      };\n\n      render(<ChoiceTile {...props} />);\n      expect(screen.getByTestId('editable-error')).toHaveTextContent('This field is required');\n    });\n\n    it('should not display error when not editable', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          ...defaultProps.choice,\n          editable: false,\n        },\n        error: 'This field is required',\n      };\n\n      render(<ChoiceTile {...props} />);\n      expect(screen.queryByText('This field is required')).not.toBeInTheDocument();\n    });\n  });\n\n  describe('image support', () => {\n    it('should pass imageSupport to EditableHtml', () => {\n      render(<ChoiceTile {...defaultProps} />);\n      expect(screen.getByTestId('editable-html')).toBeInTheDocument();\n    });\n\n    it('should pass maxImageWidth and maxImageHeight', () => {\n      const props = {\n        ...defaultProps,\n        maxImageWidth: { unit: 'px', value: 500 },\n        maxImageHeight: { unit: 'px', value: 400 },\n      };\n\n      render(<ChoiceTile {...props} />);\n      expect(screen.getByTestId('editable-html')).toBeInTheDocument();\n    });\n  });\n\n  describe('drag and drop IDs', () => {\n    it('should generate correct draggable ID', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          id: 'c1',\n          label: 'Choice 1',\n          type: 'choice',\n          editable: true,\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      // The component uses draggableId: `${type}-${choice.id}` => 'choice-c1'\n      expect(screen.getByTestId('editable-html')).toBeInTheDocument();\n    });\n\n    it('should generate correct droppable ID', () => {\n      const props = {\n        ...defaultProps,\n        choice: {\n          id: 'c1',\n          label: 'Choice 1',\n          type: 'target',\n          editable: false,\n        },\n      };\n\n      render(<ChoiceTile {...props} />);\n      // The component uses droppableId: `${type}-drop-${choice.id}` => 'target-drop-c1'\n      expect(screen.getByTestId('editable-html')).toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,268 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+var _lodashEs = require("lodash-es");
+var _nestedProperty = require("nested-property");
+var _design = require("../design");
+var _defaults = _interopRequireDefault(require("../defaults"));
+jest.mock('@pie-lib/config-ui', () => ({
+  FeedbackConfig: props => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "feedback-config"
+  }),
+  FormSection: props => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "form-section"
+  }),
+  InputContainer: props => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "input-container"
+  }),
+  layout: {
+    ConfigLayout: props => /*#__PURE__*/_react2.default.createElement("div", {
+      "data-testid": "config-layout"
+    }, props.children)
+  },
+  settings: {
+    Panel: props => /*#__PURE__*/_react2.default.createElement("div", {
+      "data-testid": "settings-panel",
+      onChange: props.onChange
+    }),
+    toggle: jest.fn(),
+    radio: jest.fn(),
+    dropdown: jest.fn()
+  }
+}));
+jest.mock('nested-property', () => ({
+  set: jest.fn((model, modelPath, v) => {
+    model[modelPath] = v;
+    return model;
+  }),
+  get: jest.fn((value, valuePath) => {
+    switch (valuePath) {
+      case 'value':
+        return value[valuePath];
+      case 'taget.value':
+        return value.target.value;
+      default:
+        return value;
+    }
+  })
+}));
+describe('Placement Ordering', () => {
+  let onModelChanged;
+  let onConfigurationChanged;
+  let model;
+  let configuration;
+  beforeEach(() => {
+    onModelChanged = jest.fn();
+    onConfigurationChanged = jest.fn();
+    model = (0, _lodashEs.cloneDeep)(_defaults.default.model);
+    configuration = (0, _lodashEs.cloneDeep)(_defaults.default.configuration);
+  });
+  describe('logic', () => {
+    let instance;
+    let modelFn;
+    const createInstance = (extras = {}) => {
+      const defaults = {
+        classes: {},
+        className: 'className',
+        onModelChanged,
+        onConfigurationChanged,
+        model,
+        configuration
+      };
+      const props = {
+        ...defaults,
+        ...extras
+      };
+      const inst = new _design.Design(props);
+      inst.setState = jest.fn((state, callback) => {
+        Object.assign(inst.state, typeof state === 'function' ? state(inst.state) : state);
+        if (callback) callback();
+      });
+      return inst;
+    };
+    beforeEach(() => {
+      instance = createInstance();
+    });
+    describe('applyUpdate', () => {
+      beforeEach(() => {
+        modelFn = jest.fn().mockReturnValue({
+          ...model,
+          prompt: 'Updated Item Stem'
+        });
+        instance.applyUpdate(modelFn);
+      });
+      it('calls onModelChanged with updated item stem value', () => {
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          prompt: 'Updated Item Stem'
+        });
+      });
+    });
+    describe('changeHandler', () => {
+      let change;
+      beforeEach(() => {
+        change = (modelPath, valuePath, value) => {
+          const onChoiceAreaLabelChange = instance.changeHandler(modelPath, valuePath);
+          onChoiceAreaLabelChange(value);
+        };
+      });
+      it('calls onModelChanged with updated item stem', () => {
+        const modelPath = 'prompt';
+        const value = 'Updated Choice Area Label';
+        change(modelPath, undefined, value);
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          [modelPath]: value
+        });
+      });
+      it('calls onModelChanged with updated item stem', () => {
+        const modelPath = 'teacherInstructions';
+        const value = 'Updated Choice Area Label';
+        change(modelPath, undefined, value);
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          [modelPath]: value
+        });
+      });
+      it('calls onModelChanged with updated choice area label', () => {
+        const modelPath = 'choiceLabel';
+        const valuePath = 'value';
+        const value = 'Updated Choice Area Label';
+        change(modelPath, valuePath, {
+          value
+        });
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          [modelPath]: value
+        });
+      });
+      it('calls onModelChanged with updated answer area label', () => {
+        const modelPath = 'targetLabel';
+        const valuePath = 'value';
+        const value = 'Updated Answer Area Label';
+        change(modelPath, valuePath, {
+          value
+        });
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          [modelPath]: value
+        });
+      });
+      it('calls onModelChanged with updated feedback', () => {
+        const modelPath = 'feedback';
+        const value = {};
+        change(modelPath, undefined, value);
+        expect(onModelChanged).toHaveBeenCalledWith({
+          ...model,
+          [modelPath]: value
+        });
+      });
+    });
+    describe('onPromptChange', () => {
+      it('calls update model when prompt changes', () => {
+        let newItemStem = 'New item stem';
+        instance.onPromptChange(newItemStem);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          prompt: newItemStem
+        });
+      });
+    });
+    describe('onRationaleChange', () => {
+      it('calls update model when prompt changes', () => {
+        let newRationale = 'New Rationale';
+        instance.onRationaleChange(newRationale);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          rationale: newRationale
+        });
+      });
+    });
+    describe('onChoiceAreaLabelChange', () => {
+      it('calls update model when choice area label changes', () => {
+        let newChoiceAreaLabel = 'New Choice Area Label';
+        instance.onChoiceAreaLabelChange(newChoiceAreaLabel);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          choiceLabel: newChoiceAreaLabel
+        });
+      });
+    });
+    describe('onAnswerAreaLabelChange', () => {
+      it('calls update model when answer area label changes', () => {
+        let newAnswerAreaLabel = 'New Answer Area Label';
+        instance.onAnswerAreaLabelChange(newAnswerAreaLabel);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          targetLabel: newAnswerAreaLabel
+        });
+      });
+    });
+    describe('onFeedbackChange', () => {
+      it('calls update model when feedback changes', () => {
+        let newFeedback = {
+          correct: {
+            type: 'custom',
+            custom: 'CORRECT'
+          },
+          incorrect: {
+            type: 'custom',
+            custom: 'INCORRECT'
+          },
+          partial: {
+            type: 'custom',
+            custom: 'PARTIAL'
+          }
+        };
+        instance.onFeedbackChange(newFeedback);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          feedback: newFeedback
+        });
+      });
+    });
+    describe('onChoiceEditorChange', () => {
+      it('calls update model when choices array changes', () => {
+        let choices = [{
+          id: 'c1',
+          label: 'Choice 1'
+        }, {
+          id: 'c2',
+          label: 'Choice 2'
+        }];
+        let correctResponse = [{
+          id: 'c2'
+        }, {
+          id: 'c1'
+        }];
+        instance.onChoiceEditorChange(choices, correctResponse);
+        expect(onModelChanged).toBeCalledWith({
+          ...model,
+          choices,
+          correctResponse
+        });
+      });
+    });
+    describe('onSettingsChange', () => {
+      it('renders with config layout', () => {
+        const {
+          container
+        } = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_design.Design, {
+          model: model,
+          configuration: configuration,
+          classes: {},
+          className: 'className',
+          onModelChanged: onModelChanged,
+          onConfigurationChanged: onConfigurationChanged
+        }));
+
+        // Check that ConfigLayout renders
+        const configLayout = container.querySelector('[data-testid="config-layout"]');
+        expect(configLayout).toBeInTheDocument();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_lodashEs","_nestedProperty","_design","_defaults","jest","mock","FeedbackConfig","props","default","createElement","FormSection","InputContainer","layout","ConfigLayout","children","settings","Panel","onChange","toggle","fn","radio","dropdown","set","model","modelPath","v","get","value","valuePath","target","describe","onModelChanged","onConfigurationChanged","configuration","beforeEach","cloneDeep","defaultValues","instance","modelFn","createInstance","extras","defaults","classes","className","inst","Design","setState","state","callback","Object","assign","mockReturnValue","prompt","applyUpdate","it","expect","toHaveBeenCalledWith","change","onChoiceAreaLabelChange","changeHandler","undefined","newItemStem","onPromptChange","toBeCalledWith","newRationale","onRationaleChange","rationale","newChoiceAreaLabel","choiceLabel","newAnswerAreaLabel","onAnswerAreaLabelChange","targetLabel","newFeedback","correct","type","custom","incorrect","partial","onFeedbackChange","feedback","choices","id","label","correctResponse","onChoiceEditorChange","container","render","configLayout","querySelector","toBeInTheDocument"],"sources":["../../src/__tests__/design.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport React from 'react';\nimport { cloneDeep } from 'lodash-es';\n\nimport { get, set } from 'nested-property';\nimport { Design } from '../design';\nimport defaultValues from '../defaults';\n\njest.mock('@pie-lib/config-ui', () => ({\n  FeedbackConfig: (props) => <div data-testid=\"feedback-config\" />,\n  FormSection: (props) => <div data-testid=\"form-section\" />,\n  InputContainer: (props) => <div data-testid=\"input-container\" />,\n  layout: {\n    ConfigLayout: (props) => <div data-testid=\"config-layout\">{props.children}</div>,\n  },\n  settings: {\n    Panel: (props) => <div data-testid=\"settings-panel\" onChange={props.onChange} />,\n    toggle: jest.fn(),\n    radio: jest.fn(),\n    dropdown: jest.fn(),\n  },\n}));\n\njest.mock('nested-property', () => ({\n  set: jest.fn((model, modelPath, v) => {\n    model[modelPath] = v;\n\n    return model;\n  }),\n  get: jest.fn((value, valuePath) => {\n    switch (valuePath) {\n      case 'value':\n        return value[valuePath];\n      case 'taget.value':\n        return value.target.value;\n      default:\n        return value;\n    }\n  }),\n}));\n\ndescribe('Placement Ordering', () => {\n  let onModelChanged;\n  let onConfigurationChanged;\n  let model;\n  let configuration;\n\n  beforeEach(() => {\n    onModelChanged = jest.fn();\n    onConfigurationChanged = jest.fn();\n    model = cloneDeep(defaultValues.model);\n    configuration = cloneDeep(defaultValues.configuration);\n  });\n\n  describe('logic', () => {\n    let instance;\n    let modelFn;\n\n    const createInstance = (extras = {}) => {\n      const defaults = {\n        classes: {},\n        className: 'className',\n        onModelChanged,\n        onConfigurationChanged,\n        model,\n        configuration,\n      };\n      const props = { ...defaults, ...extras };\n      const inst = new Design(props);\n      inst.setState = jest.fn((state, callback) => {\n        Object.assign(inst.state, typeof state === 'function' ? state(inst.state) : state);\n        if (callback) callback();\n      });\n      return inst;\n    };\n\n    beforeEach(() => {\n      instance = createInstance();\n    });\n\n    describe('applyUpdate', () => {\n      beforeEach(() => {\n        modelFn = jest.fn().mockReturnValue({\n          ...model,\n          prompt: 'Updated Item Stem',\n        });\n\n        instance.applyUpdate(modelFn);\n      });\n\n      it('calls onModelChanged with updated item stem value', () => {\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          prompt: 'Updated Item Stem',\n        });\n      });\n    });\n\n    describe('changeHandler', () => {\n      let change;\n\n      beforeEach(() => {\n        change = (modelPath, valuePath, value) => {\n          const onChoiceAreaLabelChange = instance.changeHandler(modelPath, valuePath);\n\n          onChoiceAreaLabelChange(value);\n        };\n      });\n\n      it('calls onModelChanged with updated item stem', () => {\n        const modelPath = 'prompt';\n        const value = 'Updated Choice Area Label';\n\n        change(modelPath, undefined, value);\n\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          [modelPath]: value,\n        });\n      });\n\n      it('calls onModelChanged with updated item stem', () => {\n        const modelPath = 'teacherInstructions';\n        const value = 'Updated Choice Area Label';\n\n        change(modelPath, undefined, value);\n\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          [modelPath]: value,\n        });\n      });\n\n      it('calls onModelChanged with updated choice area label', () => {\n        const modelPath = 'choiceLabel';\n        const valuePath = 'value';\n        const value = 'Updated Choice Area Label';\n\n        change(modelPath, valuePath, { value });\n\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          [modelPath]: value,\n        });\n      });\n\n      it('calls onModelChanged with updated answer area label', () => {\n        const modelPath = 'targetLabel';\n        const valuePath = 'value';\n        const value = 'Updated Answer Area Label';\n\n        change(modelPath, valuePath, { value });\n\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          [modelPath]: value,\n        });\n      });\n\n      it('calls onModelChanged with updated feedback', () => {\n        const modelPath = 'feedback';\n        const value = {};\n\n        change(modelPath, undefined, value);\n\n        expect(onModelChanged).toHaveBeenCalledWith({\n          ...model,\n          [modelPath]: value,\n        });\n      });\n    });\n\n    describe('onPromptChange', () => {\n      it('calls update model when prompt changes', () => {\n        let newItemStem = 'New item stem';\n\n        instance.onPromptChange(newItemStem);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          prompt: newItemStem,\n        });\n      });\n    });\n\n    describe('onRationaleChange', () => {\n      it('calls update model when prompt changes', () => {\n        let newRationale = 'New Rationale';\n\n        instance.onRationaleChange(newRationale);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          rationale: newRationale,\n        });\n      });\n    });\n\n    describe('onChoiceAreaLabelChange', () => {\n      it('calls update model when choice area label changes', () => {\n        let newChoiceAreaLabel = 'New Choice Area Label';\n\n        instance.onChoiceAreaLabelChange(newChoiceAreaLabel);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          choiceLabel: newChoiceAreaLabel,\n        });\n      });\n    });\n\n    describe('onAnswerAreaLabelChange', () => {\n      it('calls update model when answer area label changes', () => {\n        let newAnswerAreaLabel = 'New Answer Area Label';\n\n        instance.onAnswerAreaLabelChange(newAnswerAreaLabel);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          targetLabel: newAnswerAreaLabel,\n        });\n      });\n    });\n\n    describe('onFeedbackChange', () => {\n      it('calls update model when feedback changes', () => {\n        let newFeedback = {\n          correct: {\n            type: 'custom',\n            custom: 'CORRECT',\n          },\n          incorrect: {\n            type: 'custom',\n            custom: 'INCORRECT',\n          },\n          partial: {\n            type: 'custom',\n            custom: 'PARTIAL',\n          },\n        };\n\n        instance.onFeedbackChange(newFeedback);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          feedback: newFeedback,\n        });\n      });\n    });\n\n    describe('onChoiceEditorChange', () => {\n      it('calls update model when choices array changes', () => {\n        let choices = [\n          { id: 'c1', label: 'Choice 1' },\n          { id: 'c2', label: 'Choice 2' },\n        ];\n        let correctResponse = [{ id: 'c2' }, { id: 'c1' }];\n\n        instance.onChoiceEditorChange(choices, correctResponse);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...model,\n          choices,\n          correctResponse,\n        });\n      });\n    });\n\n    describe('onSettingsChange', () => {\n      it('renders with config layout', () => {\n        const { container } = render(\n          <Design\n            model={model}\n            configuration={configuration}\n            classes={{}}\n            className={'className'}\n            onModelChanged={onModelChanged}\n            onConfigurationChanged={onConfigurationChanged}\n          />,\n        );\n\n        // Check that ConfigLayout renders\n        const configLayout = container.querySelector('[data-testid=\"config-layout\"]');\n        expect(configLayout).toBeInTheDocument();\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}