@pie-element/categorize 11.3.4-next.3 → 12.0.0-beta.1

package/docs/demo/pie.manifest.json

@@ -0,0 +1,11 @@
+{
+  "hash": "-1338235779",
+  "info": [
+    {
+      "pie": "@pie-element/categorize",
+      "version": {
+        "requested": "latest"
+      }
+    }
+  ]
+}

package/lib/__tests__/index.test.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _index = _interopRequireDefault(require("../index"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _piePlayerEvents = require("@pie-framework/pie-player-events");
+var _index2 = require("../categorize/index");
+jest.mock('@pie-lib/math-rendering', () => ({
+  renderMath: jest.fn()
+}));
+const mockRender = jest.fn();
+const mockUnmount = jest.fn();
+jest.mock('react-dom/client', () => ({
+  createRoot: jest.fn(() => ({
+    render: mockRender,
+    unmount: mockUnmount
+  }))
+}));
+const theme = (0, _styles.createTheme)();
+describe('categorize', () => {
+  describe('renders', () => {
+    const renderCategorize = props => {
+      const defaultProps = {
+        model: {
+          categories: [],
+          choices: [],
+          correctResponse: [],
+          ...props
+        },
+        session: {},
+        classes: {},
+        onAnswersChange: jest.fn(),
+        onShowCorrectToggle: jest.fn()
+      };
+      return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+        theme: theme
+      }, /*#__PURE__*/_react.default.createElement(_index2.Categorize, defaultProps)));
+    };
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderCategorize();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders with rationale', () => {
+      const {
+        container
+      } = renderCategorize({
+        rationale: 'This is rationale'
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders with teacherInstructions', () => {
+      const {
+        container
+      } = renderCategorize({
+        teacherInstructions: 'These are teacher instructions'
+      });
+      expect(container).toBeInTheDocument();
+    });
+  });
+  describe('events', () => {
+    let el;
+    beforeEach(() => {
+      // Register custom element if not already registered
+      if (!customElements.get('categorize-el')) {
+        customElements.define('categorize-el', _index.default);
+      }
+
+      // Create element via createElement to properly initialize it
+      el = document.createElement('categorize-el');
+
+      // Mock dispatchEvent
+      el.dispatchEvent = jest.fn();
+    });
+    describe('model', () => {
+      it('dispatches model set event', () => {
+        el.model = {};
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.ModelSetEvent('categorize-el', false, true));
+      });
+    });
+    describe('changeAnswers', () => {
+      it('dispatches session changed event - add answer', () => {
+        el.model = {
+          responseAreasToBeFilled: 2,
+          hasUnplacedChoices: true
+        };
+        el.session = {
+          answers: []
+        };
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', false));
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }, {
+          category: 'id-vegetables',
+          choices: ['carrot']
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', true));
+      });
+      it('dispatches session changed event - remove answer', () => {
+        el.model = {
+          responseAreasToBeFilled: 1
+        };
+        el.session = {
+          answers: [{
+            category: 'id-fruits',
+            choices: ['apple']
+          }]
+        };
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: []
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', false));
+      });
+      it('dispatches session changed event - add/remove answer', () => {
+        el.model = {
+          responseAreasToBeFilled: 2,
+          hasUnplacedChoices: true
+        };
+        el.session = {
+          answers: [{
+            category: 'id-fruits',
+            choices: ['apple']
+          }, {
+            category: 'id-vegetables',
+            choices: ['carrot', 'onion']
+          }]
+        };
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }, {
+          category: 'id-vegetables',
+          choices: ['carrot']
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', true));
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }, {
+          category: 'id-vegetables',
+          choices: []
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', false));
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: []
+        }, {
+          category: 'id-vegetables',
+          choices: []
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', false));
+      });
+      it('dispatches session changed event - add/remove answer - no unplaced choices', () => {
+        el.model = {
+          responseAreasToBeFilled: 2,
+          hasUnplacedChoices: false,
+          possibleResponses: [['apple', 'carrot', 'onion']]
+        };
+        el.session = {
+          answers: [{
+            category: 'id-fruits',
+            choices: ['apple']
+          }, {
+            category: 'id-vegetables',
+            choices: []
+          }]
+        };
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }, {
+          category: 'id-vegetables',
+          choices: ['carrot']
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', false));
+        el.changeAnswers([{
+          category: 'id-fruits',
+          choices: ['apple']
+        }, {
+          category: 'id-vegetables',
+          choices: ['carrot', 'onion']
+        }]);
+        expect(el.dispatchEvent).toBeCalledWith(new _piePlayerEvents.SessionChangedEvent('categorize-el', true));
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_index","_react2","_styles","_piePlayerEvents","_index2","jest","mock","renderMath","fn","mockRender","mockUnmount","createRoot","render","unmount","theme","createTheme","describe","renderCategorize","props","defaultProps","model","categories","choices","correctResponse","session","classes","onAnswersChange","onShowCorrectToggle","default","createElement","ThemeProvider","Categorize","it","container","expect","toBeInTheDocument","rationale","teacherInstructions","el","beforeEach","customElements","get","define","document","dispatchEvent","toBeCalledWith","ModelSetEvent","responseAreasToBeFilled","hasUnplacedChoices","answers","changeAnswers","category","SessionChangedEvent","possibleResponses"],"sources":["../../src/__tests__/index.test.js"],"sourcesContent":["import React from 'react';\nimport Categorize from '../index';\nimport { render } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport { ModelSetEvent, SessionChangedEvent } from '@pie-framework/pie-player-events';\nimport { Categorize as UnStyledCategorize } from '../categorize/index';\n\njest.mock('@pie-lib/math-rendering', () => ({ renderMath: jest.fn() }));\nconst mockRender = jest.fn();\nconst mockUnmount = jest.fn();\njest.mock('react-dom/client', () => ({\n  createRoot: jest.fn(() => ({\n    render: mockRender,\n    unmount: mockUnmount,\n  })),\n}));\n\nconst theme = createTheme();\n\ndescribe('categorize', () => {\n  describe('renders', () => {\n    const renderCategorize = (props) => {\n      const defaultProps = {\n        model: {\n          categories: [],\n          choices: [],\n          correctResponse: [],\n          ...props,\n        },\n        session: {},\n        classes: {},\n        onAnswersChange: jest.fn(),\n        onShowCorrectToggle: jest.fn(),\n      };\n      return render(\n        <ThemeProvider theme={theme}>\n          <UnStyledCategorize {...defaultProps} />\n        </ThemeProvider>\n      );\n    };\n\n    it('renders without crashing', () => {\n      const { container } = renderCategorize();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders with rationale', () => {\n      const { container} = renderCategorize({ rationale: 'This is rationale' });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders with teacherInstructions', () => {\n      const { container } = renderCategorize({ teacherInstructions: 'These are teacher instructions' });\n      expect(container).toBeInTheDocument();\n    });\n  });\n\n  describe('events', () => {\n    let el;\n\n    beforeEach(() => {\n      // Register custom element if not already registered\n      if (!customElements.get('categorize-el')) {\n        customElements.define('categorize-el', Categorize);\n      }\n\n      // Create element via createElement to properly initialize it\n      el = document.createElement('categorize-el');\n\n      // Mock dispatchEvent\n      el.dispatchEvent = jest.fn();\n    });\n\n    describe('model', () => {\n      it('dispatches model set event', () => {\n        el.model = {};\n        expect(el.dispatchEvent).toBeCalledWith(new ModelSetEvent('categorize-el', false, true));\n      });\n    });\n\n    describe('changeAnswers', () => {\n      it('dispatches session changed event - add answer', () => {\n        el.model = {\n          responseAreasToBeFilled: 2,\n          hasUnplacedChoices: true,\n        };\n        el.session = { answers: [] };\n        el.changeAnswers([{ category: 'id-fruits', choices: ['apple'] }]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', false));\n        el.changeAnswers([\n          { category: 'id-fruits', choices: ['apple'] },\n          { category: 'id-vegetables', choices: ['carrot'] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', true));\n      });\n\n      it('dispatches session changed event - remove answer', () => {\n        el.model = {\n          responseAreasToBeFilled: 1,\n        };\n        el.session = { answers: [{ category: 'id-fruits', choices: ['apple'] }] };\n        el.changeAnswers([{ category: 'id-fruits', choices: [] }]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', false));\n      });\n\n      it('dispatches session changed event - add/remove answer', () => {\n        el.model = {\n          responseAreasToBeFilled: 2,\n          hasUnplacedChoices: true,\n        };\n        el.session = {\n          answers: [\n            { category: 'id-fruits', choices: ['apple'] },\n            { category: 'id-vegetables', choices: ['carrot', 'onion'] },\n          ],\n        };\n        el.changeAnswers([\n          { category: 'id-fruits', choices: ['apple'] },\n          { category: 'id-vegetables', choices: ['carrot'] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', true));\n\n        el.changeAnswers([\n          { category: 'id-fruits', choices: ['apple'] },\n          { category: 'id-vegetables', choices: [] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', false));\n\n        el.changeAnswers([\n          { category: 'id-fruits', choices: [] },\n          { category: 'id-vegetables', choices: [] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', false));\n      });\n\n      it('dispatches session changed event - add/remove answer - no unplaced choices', () => {\n        el.model = {\n          responseAreasToBeFilled: 2,\n          hasUnplacedChoices: false,\n          possibleResponses: [['apple', 'carrot', 'onion']],\n        };\n        el.session = {\n          answers: [\n            { category: 'id-fruits', choices: ['apple'] },\n            { category: 'id-vegetables', choices: [] },\n          ],\n        };\n\n        el.changeAnswers([\n          { category: 'id-fruits', choices: ['apple'] },\n          { category: 'id-vegetables', choices: ['carrot'] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', false));\n\n        el.changeAnswers([\n          { category: 'id-fruits', choices: ['apple'] },\n          { category: 'id-vegetables', choices: ['carrot', 'onion'] },\n        ]);\n        expect(el.dispatchEvent).toBeCalledWith(new SessionChangedEvent('categorize-el', true));\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/categorize/__tests__/categories.test.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _categories = require("../categories");
+jest.mock('../category', () => ({
+  __esModule: true,
+  default: ({
+    id,
+    label
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": `category-${id}`
+  }, label),
+  CategoryType: {}
+}));
+jest.mock('../grid-content', () => ({
+  __esModule: true,
+  default: ({
+    children,
+    columns
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "grid-content",
+    "data-columns": columns
+  }, children)
+}));
+const theme = (0, _styles.createTheme)();
+describe('Categories', () => {
+  const renderCategories = extras => {
+    const defaults = {
+      classes: {},
+      categories: [{
+        choices: [],
+        id: '1',
+        label: 'Category One'
+      }],
+      onDropChoice: jest.fn(),
+      onRemoveChoice: jest.fn(),
+      id: '1',
+      label: 'Category Label',
+      grid: {
+        columns: 1,
+        rows: 1
+      }
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_categories.Categories, props)));
+  };
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderCategories();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when disabled', () => {
+      const {
+        container
+      } = renderCategories({
+        disabled: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders the grid content wrapper', () => {
+      renderCategories();
+      expect(_react2.screen.getByTestId('grid-content')).toBeInTheDocument();
+    });
+  });
+  describe('category labels', () => {
+    it('displays category labels', () => {
+      renderCategories({
+        categories: [{
+          id: '1',
+          label: 'First Category',
+          choices: []
+        }, {
+          id: '2',
+          label: 'Second Category',
+          choices: []
+        }]
+      });
+      // Multiple elements may contain the same text (label + category mock)
+      expect(_react2.screen.getAllByText('First Category').length).toBeGreaterThan(0);
+      expect(_react2.screen.getAllByText('Second Category').length).toBeGreaterThan(0);
+    });
+  });
+  describe('categories per row', () => {
+    it('respects categoriesPerRow setting', () => {
+      renderCategories({
+        categories: [{
+          id: '1',
+          label: 'Cat 1',
+          choices: []
+        }, {
+          id: '2',
+          label: 'Cat 2',
+          choices: []
+        }],
+        model: {
+          categoriesPerRow: 2
+        }
+      });
+      const grid = _react2.screen.getByTestId('grid-content');
+      expect(grid).toHaveAttribute('data-columns', '2');
+    });
+  });
+  describe('row labels', () => {
+    it('renders row labels when provided', () => {
+      renderCategories({
+        categories: [{
+          id: '1',
+          label: 'Category',
+          choices: []
+        }],
+        rowLabels: ['Row 1 Label']
+      });
+      expect(_react2.screen.getByText('Row 1 Label')).toBeInTheDocument();
+    });
+    it('does not render row labels when empty', () => {
+      renderCategories({
+        categories: [{
+          id: '1',
+          label: 'Category',
+          choices: []
+        }],
+        rowLabels: []
+      });
+      expect(_react2.screen.queryByText('Row 1 Label')).not.toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_categories","jest","mock","__esModule","default","id","label","createElement","CategoryType","children","columns","theme","createTheme","describe","renderCategories","extras","defaults","classes","categories","choices","onDropChoice","fn","onRemoveChoice","grid","rows","props","render","ThemeProvider","Categories","it","container","expect","toBeInTheDocument","disabled","screen","getByTestId","getAllByText","length","toBeGreaterThan","model","categoriesPerRow","toHaveAttribute","rowLabels","getByText","queryByText","not"],"sources":["../../../src/categorize/__tests__/categories.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport { Categories } from '../categories';\n\njest.mock('../category', () => ({\n  __esModule: true,\n  default: ({ id, label }) => <div data-testid={`category-${id}`}>{label}</div>,\n  CategoryType: {},\n}));\n\njest.mock('../grid-content', () => ({\n  __esModule: true,\n  default: ({ children, columns }) => (\n    <div data-testid=\"grid-content\" data-columns={columns}>\n      {children}\n    </div>\n  ),\n}));\n\nconst theme = createTheme();\n\ndescribe('Categories', () => {\n  const renderCategories = (extras) => {\n    const defaults = {\n      classes: {},\n      categories: [{ choices: [], id: '1', label: 'Category One' }],\n      onDropChoice: jest.fn(),\n      onRemoveChoice: jest.fn(),\n      id: '1',\n      label: 'Category Label',\n      grid: { columns: 1, rows: 1 },\n    };\n\n    const props = { ...defaults, ...extras };\n    return render(\n      <ThemeProvider theme={theme}>\n        <Categories {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderCategories();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders when disabled', () => {\n      const { container } = renderCategories({ disabled: true });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders the grid content wrapper', () => {\n      renderCategories();\n      expect(screen.getByTestId('grid-content')).toBeInTheDocument();\n    });\n  });\n\n  describe('category labels', () => {\n    it('displays category labels', () => {\n      renderCategories({\n        categories: [\n          { id: '1', label: 'First Category', choices: [] },\n          { id: '2', label: 'Second Category', choices: [] },\n        ],\n      });\n      // Multiple elements may contain the same text (label + category mock)\n      expect(screen.getAllByText('First Category').length).toBeGreaterThan(0);\n      expect(screen.getAllByText('Second Category').length).toBeGreaterThan(0);\n    });\n  });\n\n  describe('categories per row', () => {\n    it('respects categoriesPerRow setting', () => {\n      renderCategories({\n        categories: [\n          { id: '1', label: 'Cat 1', choices: [] },\n          { id: '2', label: 'Cat 2', choices: [] },\n        ],\n        model: { categoriesPerRow: 2 },\n      });\n      const grid = screen.getByTestId('grid-content');\n      expect(grid).toHaveAttribute('data-columns', '2');\n    });\n  });\n\n  describe('row labels', () => {\n    it('renders row labels when provided', () => {\n      renderCategories({\n        categories: [{ id: '1', label: 'Category', choices: [] }],\n        rowLabels: ['Row 1 Label'],\n      });\n      expect(screen.getByText('Row 1 Label')).toBeInTheDocument();\n    });\n\n    it('does not render row labels when empty', () => {\n      renderCategories({\n        categories: [{ id: '1', label: 'Category', choices: [] }],\n        rowLabels: [],\n      });\n      expect(screen.queryByText('Row 1 Label')).not.toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/categorize/__tests__/category.test.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _category = require("../category");
+jest.mock('../droppable-placeholder', () => ({
+  __esModule: true,
+  default: ({
+    children,
+    id,
+    correct
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": `placeholder-${id}`,
+    "data-correct": correct !== undefined ? String(correct) : undefined
+  }, children)
+}));
+jest.mock('../choice', () => ({
+  __esModule: true,
+  default: ({
+    id,
+    label,
+    categoryId
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": `choice-${id}`,
+    "data-category": categoryId
+  }, label)
+}));
+const theme = (0, _styles.createTheme)();
+describe('Category', () => {
+  const renderCategory = extras => {
+    const defaults = {
+      classes: {
+        label: 'label',
+        incorrect: 'incorrect',
+        placeholder: 'placeholder',
+        category: 'category'
+      },
+      choices: [],
+      id: 'category-1',
+      label: 'Category Label',
+      grid: {
+        columns: 1,
+        rows: 1
+      }
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_category.Category, props)));
+  };
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderCategory();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders the placeholder with correct id', () => {
+      renderCategory({
+        id: 'test-category'
+      });
+      expect(_react2.screen.getByTestId('placeholder-test-category')).toBeInTheDocument();
+    });
+    it('renders when disabled', () => {
+      const {
+        container
+      } = renderCategory({
+        disabled: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+  });
+  describe('choices rendering', () => {
+    it('renders choices within the category', () => {
+      renderCategory({
+        id: 'cat-1',
+        choices: [{
+          id: 'choice-1',
+          label: 'First Choice'
+        }, {
+          id: 'choice-2',
+          label: 'Second Choice'
+        }]
+      });
+      expect(_react2.screen.getByTestId('choice-choice-1')).toBeInTheDocument();
+      expect(_react2.screen.getByTestId('choice-choice-2')).toBeInTheDocument();
+      expect(_react2.screen.getByText('First Choice')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Second Choice')).toBeInTheDocument();
+    });
+    it('renders empty category when no choices', () => {
+      renderCategory({
+        choices: []
+      });
+      expect(_react2.screen.queryByTestId(/^choice-/)).not.toBeInTheDocument();
+    });
+  });
+  describe('correctness state', () => {
+    // Note: StyledPlaceHolder uses shouldForwardProp to prevent 'correct' from being
+    // forwarded to the underlying component - it's only used for styling.
+    // We test that rendering doesn't crash with different correctness values.
+    it('renders correctly when correct=false (incorrect answer)', () => {
+      const {
+        container
+      } = renderCategory({
+        id: 'cat-1',
+        correct: false
+      });
+      expect(container).toBeInTheDocument();
+      expect(_react2.screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();
+    });
+    it('renders correctly when correct=true (correct answer)', () => {
+      const {
+        container
+      } = renderCategory({
+        id: 'cat-1',
+        correct: true
+      });
+      expect(container).toBeInTheDocument();
+      expect(_react2.screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();
+    });
+    it('renders correctly when correct is undefined', () => {
+      const {
+        container
+      } = renderCategory({
+        id: 'cat-1'
+      });
+      expect(container).toBeInTheDocument();
+      expect(_react2.screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_category","jest","mock","__esModule","default","children","id","correct","createElement","undefined","String","label","categoryId","theme","createTheme","describe","renderCategory","extras","defaults","classes","incorrect","placeholder","category","choices","grid","columns","rows","props","render","ThemeProvider","Category","it","container","expect","toBeInTheDocument","screen","getByTestId","disabled","getByText","queryByTestId","not"],"sources":["../../../src/categorize/__tests__/category.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport { Category } from '../category';\n\njest.mock('../droppable-placeholder', () => ({\n  __esModule: true,\n  default: ({ children, id, correct }) => (\n    <div \n      data-testid={`placeholder-${id}`} \n      data-correct={correct !== undefined ? String(correct) : undefined}\n    >\n      {children}\n    </div>\n  ),\n}));\njest.mock('../choice', () => ({\n  __esModule: true,\n  default: ({ id, label, categoryId }) => (\n    <div data-testid={`choice-${id}`} data-category={categoryId}>\n      {label}\n    </div>\n  ),\n}));\n\nconst theme = createTheme();\n\ndescribe('Category', () => {\n  const renderCategory = (extras) => {\n    const defaults = {\n      classes: {\n        label: 'label',\n        incorrect: 'incorrect',\n        placeholder: 'placeholder',\n        category: 'category',\n      },\n      choices: [],\n      id: 'category-1',\n      label: 'Category Label',\n      grid: { columns: 1, rows: 1 },\n    };\n\n    const props = { ...defaults, ...extras };\n    return render(\n      <ThemeProvider theme={theme}>\n        <Category {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderCategory();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders the placeholder with correct id', () => {\n      renderCategory({ id: 'test-category' });\n      expect(screen.getByTestId('placeholder-test-category')).toBeInTheDocument();\n    });\n\n    it('renders when disabled', () => {\n      const { container } = renderCategory({ disabled: true });\n      expect(container).toBeInTheDocument();\n    });\n  });\n\n  describe('choices rendering', () => {\n    it('renders choices within the category', () => {\n      renderCategory({\n        id: 'cat-1',\n        choices: [\n          { id: 'choice-1', label: 'First Choice' },\n          { id: 'choice-2', label: 'Second Choice' },\n        ],\n      });\n      expect(screen.getByTestId('choice-choice-1')).toBeInTheDocument();\n      expect(screen.getByTestId('choice-choice-2')).toBeInTheDocument();\n      expect(screen.getByText('First Choice')).toBeInTheDocument();\n      expect(screen.getByText('Second Choice')).toBeInTheDocument();\n    });\n\n    it('renders empty category when no choices', () => {\n      renderCategory({ choices: [] });\n      expect(screen.queryByTestId(/^choice-/)).not.toBeInTheDocument();\n    });\n  });\n\n  describe('correctness state', () => {\n    // Note: StyledPlaceHolder uses shouldForwardProp to prevent 'correct' from being\n    // forwarded to the underlying component - it's only used for styling.\n    // We test that rendering doesn't crash with different correctness values.\n    it('renders correctly when correct=false (incorrect answer)', () => {\n      const { container } = renderCategory({ id: 'cat-1', correct: false });\n      expect(container).toBeInTheDocument();\n      expect(screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();\n    });\n\n    it('renders correctly when correct=true (correct answer)', () => {\n      const { container } = renderCategory({ id: 'cat-1', correct: true });\n      expect(container).toBeInTheDocument();\n      expect(screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();\n    });\n\n    it('renders correctly when correct is undefined', () => {\n      const { container } = renderCategory({ id: 'cat-1' });\n      expect(container).toBeInTheDocument();\n      expect(screen.getByTestId('placeholder-cat-1')).toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _choice = require("../choice");
+jest.mock('@pie-lib/render-ui', () => ({
+  HtmlAndMath: props => /*#__PURE__*/_react.default.createElement("div", null, props.text),
+  color: {
+    text: () => '#000',
+    background: () => '#fff',
+    white: () => '#fff',
+    correct: () => '#00ff00',
+    incorrect: () => '#ff0000'
+  }
+}));
+const theme = (0, _styles.createTheme)();
+describe('Layout', () => {
+  const renderLayout = extras => {
+    const defaults = {
+      classes: {},
+      content: 'Choice Content'
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_choice.Layout, props)));
+  };
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderLayout();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders the choice content', () => {
+      renderLayout({
+        content: 'Test Choice Text'
+      });
+      expect(_react2.screen.getByText('Test Choice Text')).toBeInTheDocument();
+    });
+    it('renders HTML content', () => {
+      renderLayout({
+        content: '<strong>Bold Text</strong>'
+      });
+      expect(_react2.screen.getByText('Bold Text')).toBeInTheDocument();
+    });
+  });
+  describe('states', () => {
+    it('renders when disabled', () => {
+      const {
+        container
+      } = renderLayout({
+        disabled: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when correct', () => {
+      const {
+        container
+      } = renderLayout({
+        correct: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when incorrect', () => {
+      const {
+        container
+      } = renderLayout({
+        correct: false
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when dragging', () => {
+      const {
+        container
+      } = renderLayout({
+        isDragging: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9yZWFjdDIiLCJfc3R5bGVzIiwiX2Nob2ljZSIsImplc3QiLCJtb2NrIiwiSHRtbEFuZE1hdGgiLCJwcm9wcyIsImRlZmF1bHQiLCJjcmVhdGVFbGVtZW50IiwidGV4dCIsImNvbG9yIiwiYmFja2dyb3VuZCIsIndoaXRlIiwiY29ycmVjdCIsImluY29ycmVjdCIsInRoZW1lIiwiY3JlYXRlVGhlbWUiLCJkZXNjcmliZSIsInJlbmRlckxheW91dCIsImV4dHJhcyIsImRlZmF1bHRzIiwiY2xhc3NlcyIsImNvbnRlbnQiLCJyZW5kZXIiLCJUaGVtZVByb3ZpZGVyIiwiTGF5b3V0IiwiaXQiLCJjb250YWluZXIiLCJleHBlY3QiLCJ0b0JlSW5UaGVEb2N1bWVudCIsInNjcmVlbiIsImdldEJ5VGV4dCIsImRpc2FibGVkIiwiaXNEcmFnZ2luZyJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jYXRlZ29yaXplL19fdGVzdHNfXy9jaG9pY2UudGVzdC5qc3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7IHJlbmRlciwgc2NyZWVuIH0gZnJvbSAnQHRlc3RpbmctbGlicmFyeS9yZWFjdCc7XG5pbXBvcnQgeyBUaGVtZVByb3ZpZGVyLCBjcmVhdGVUaGVtZSB9IGZyb20gJ0BtdWkvbWF0ZXJpYWwvc3R5bGVzJztcbmltcG9ydCB7IExheW91dCB9IGZyb20gJy4uL2Nob2ljZSc7XG5cbmplc3QubW9jaygnQHBpZS1saWIvcmVuZGVyLXVpJywgKCkgPT4gKHtcbiAgSHRtbEFuZE1hdGg6IChwcm9wcykgPT4gPGRpdj57cHJvcHMudGV4dH08L2Rpdj4sXG4gIGNvbG9yOiB7XG4gICAgdGV4dDogKCkgPT4gJyMwMDAnLFxuICAgIGJhY2tncm91bmQ6ICgpID0+ICcjZmZmJyxcbiAgICB3aGl0ZTogKCkgPT4gJyNmZmYnLFxuICAgIGNvcnJlY3Q6ICgpID0+ICcjMDBmZjAwJyxcbiAgICBpbmNvcnJlY3Q6ICgpID0+ICcjZmYwMDAwJyxcbiAgfSxcbn0pKTtcblxuY29uc3QgdGhlbWUgPSBjcmVhdGVUaGVtZSgpO1xuXG5kZXNjcmliZSgnTGF5b3V0JywgKCkgPT4ge1xuICBjb25zdCByZW5kZXJMYXlvdXQgPSAoZXh0cmFzKSA9PiB7XG4gICAgY29uc3QgZGVmYXVsdHMgPSB7XG4gICAgICBjbGFzc2VzOiB7fSxcbiAgICAgIGNvbnRlbnQ6ICdDaG9pY2UgQ29udGVudCcsXG4gICAgfTtcbiAgICBjb25zdCBwcm9wcyA9IHsgLi4uZGVmYXVsdHMsIC4uLmV4dHJhcyB9O1xuICAgIHJldHVybiByZW5kZXIoXG4gICAgICA8VGhlbWVQcm92aWRlciB0aGVtZT17dGhlbWV9PlxuICAgICAgICA8TGF5b3V0IHsuLi5wcm9wc30gLz5cbiAgICAgIDwvVGhlbWVQcm92aWRlcj5cbiAgICApO1xuICB9O1xuXG4gIGRlc2NyaWJlKCdyZW5kZXJpbmcnLCAoKSA9PiB7XG4gICAgaXQoJ3JlbmRlcnMgd2l0aG91dCBjcmFzaGluZycsICgpID0+IHtcbiAgICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXJMYXlvdXQoKTtcbiAgICAgIGV4cGVjdChjb250YWluZXIpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gICAgfSk7XG5cbiAgICBpdCgncmVuZGVycyB0aGUgY2hvaWNlIGNvbnRlbnQnLCAoKSA9PiB7XG4gICAgICByZW5kZXJMYXlvdXQoeyBjb250ZW50OiAnVGVzdCBDaG9pY2UgVGV4dCcgfSk7XG4gICAgICBleHBlY3Qoc2NyZWVuLmdldEJ5VGV4dCgnVGVzdCBDaG9pY2UgVGV4dCcpKS50b0JlSW5UaGVEb2N1bWVudCgpO1xuICAgIH0pO1xuXG4gICAgaXQoJ3JlbmRlcnMgSFRNTCBjb250ZW50JywgKCkgPT4ge1xuICAgICAgcmVuZGVyTGF5b3V0KHsgY29udGVudDogJzxzdHJvbmc+Qm9sZCBUZXh0PC9zdHJvbmc+JyB9KTtcbiAgICAgIGV4cGVjdChzY3JlZW4uZ2V0QnlUZXh0KCdCb2xkIFRleHQnKSkudG9CZUluVGhlRG9jdW1lbnQoKTtcbiAgICB9KTtcbiAgfSk7XG5cbiAgZGVzY3JpYmUoJ3N0YXRlcycsICgpID0+IHtcbiAgICBpdCgncmVuZGVycyB3aGVuIGRpc2FibGVkJywgKCkgPT4ge1xuICAgICAgY29uc3QgeyBjb250YWluZXIgfSA9IHJlbmRlckxheW91dCh7IGRpc2FibGVkOiB0cnVlIH0pO1xuICAgICAgZXhwZWN0KGNvbnRhaW5lcikudG9CZUluVGhlRG9jdW1lbnQoKTtcbiAgICB9KTtcblxuICAgIGl0KCdyZW5kZXJzIHdoZW4gY29ycmVjdCcsICgpID0+IHtcbiAgICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXJMYXlvdXQoeyBjb3JyZWN0OiB0cnVlIH0pO1xuICAgICAgZXhwZWN0KGNvbnRhaW5lcikudG9CZUluVGhlRG9jdW1lbnQoKTtcbiAgICB9KTtcblxuICAgIGl0KCdyZW5kZXJzIHdoZW4gaW5jb3JyZWN0JywgKCkgPT4ge1xuICAgICAgY29uc3QgeyBjb250YWluZXIgfSA9IHJlbmRlckxheW91dCh7IGNvcnJlY3Q6IGZhbHNlIH0pO1xuICAgICAgZXhwZWN0KGNvbnRhaW5lcikudG9CZUluVGhlRG9jdW1lbnQoKTtcbiAgICB9KTtcblxuICAgIGl0KCdyZW5kZXJzIHdoZW4gZHJhZ2dpbmcnLCAoKSA9PiB7XG4gICAgICBjb25zdCB7IGNvbnRhaW5lciB9ID0gcmVuZGVyTGF5b3V0KHsgaXNEcmFnZ2luZzogdHJ1ZSB9KTtcbiAgICAgIGV4cGVjdChjb250YWluZXIpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gICAgfSk7XG4gIH0pO1xufSk7XG5cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsSUFBQUEsTUFBQSxHQUFBQyxzQkFBQSxDQUFBQyxPQUFBO0FBQ0EsSUFBQUMsT0FBQSxHQUFBRCxPQUFBO0FBQ0EsSUFBQUUsT0FBQSxHQUFBRixPQUFBO0FBQ0EsSUFBQUcsT0FBQSxHQUFBSCxPQUFBO0FBRUFJLElBQUksQ0FBQ0MsSUFBSSxDQUFDLG9CQUFvQixFQUFFLE9BQU87RUFDckNDLFdBQVcsRUFBR0MsS0FBSyxpQkFBS1QsTUFBQSxDQUFBVSxPQUFBLENBQUFDLGFBQUEsY0FBTUYsS0FBSyxDQUFDRyxJQUFVLENBQUM7RUFDL0NDLEtBQUssRUFBRTtJQUNMRCxJQUFJLEVBQUVBLENBQUEsS0FBTSxNQUFNO0lBQ2xCRSxVQUFVLEVBQUVBLENBQUEsS0FBTSxNQUFNO0lBQ3hCQyxLQUFLLEVBQUVBLENBQUEsS0FBTSxNQUFNO0lBQ25CQyxPQUFPLEVBQUVBLENBQUEsS0FBTSxTQUFTO0lBQ3hCQyxTQUFTLEVBQUVBLENBQUEsS0FBTTtFQUNuQjtBQUNGLENBQUMsQ0FBQyxDQUFDO0FBRUgsTUFBTUMsS0FBSyxHQUFHLElBQUFDLG1CQUFXLEVBQUMsQ0FBQztBQUUzQkMsUUFBUSxDQUFDLFFBQVEsRUFBRSxNQUFNO0VBQ3ZCLE1BQU1DLFlBQVksR0FBSUMsTUFBTSxJQUFLO0lBQy9CLE1BQU1DLFFBQVEsR0FBRztNQUNmQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO01BQ1hDLE9BQU8sRUFBRTtJQUNYLENBQUM7SUFDRCxNQUFNaEIsS0FBSyxHQUFHO01BQUUsR0FBR2MsUUFBUTtNQUFFLEdBQUdEO0lBQU8sQ0FBQztJQUN4QyxPQUFPLElBQUFJLGNBQU0sZUFDWDFCLE1BQUEsQ0FBQVUsT0FBQSxDQUFBQyxhQUFBLENBQUNQLE9BQUEsQ0FBQXVCLGFBQWE7TUFBQ1QsS0FBSyxFQUFFQTtJQUFNLGdCQUMxQmxCLE1BQUEsQ0FBQVUsT0FBQSxDQUFBQyxhQUFBLENBQUNOLE9BQUEsQ0FBQXVCLE1BQU0sRUFBS25CLEtBQVEsQ0FDUCxDQUNqQixDQUFDO0VBQ0gsQ0FBQztFQUVEVyxRQUFRLENBQUMsV0FBVyxFQUFFLE1BQU07SUFDMUJTLEVBQUUsQ0FBQywwQkFBMEIsRUFBRSxNQUFNO01BQ25DLE1BQU07UUFBRUM7TUFBVSxDQUFDLEdBQUdULFlBQVksQ0FBQyxDQUFDO01BQ3BDVSxNQUFNLENBQUNELFNBQVMsQ0FBQyxDQUFDRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQztJQUVGSCxFQUFFLENBQUMsNEJBQTRCLEVBQUUsTUFBTTtNQUNyQ1IsWUFBWSxDQUFDO1FBQUVJLE9BQU8sRUFBRTtNQUFtQixDQUFDLENBQUM7TUFDN0NNLE1BQU0sQ0FBQ0UsY0FBTSxDQUFDQyxTQUFTLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxDQUFDRixpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xFLENBQUMsQ0FBQztJQUVGSCxFQUFFLENBQUMsc0JBQXNCLEVBQUUsTUFBTTtNQUMvQlIsWUFBWSxDQUFDO1FBQUVJLE9BQU8sRUFBRTtNQUE2QixDQUFDLENBQUM7TUFDdkRNLE1BQU0sQ0FBQ0UsY0FBTSxDQUFDQyxTQUFTLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQ0YsaUJBQWlCLENBQUMsQ0FBQztJQUMzRCxDQUFDLENBQUM7RUFDSixDQUFDLENBQUM7RUFFRlosUUFBUSxDQUFDLFFBQVEsRUFBRSxNQUFNO0lBQ3ZCUyxFQUFFLENBQUMsdUJBQXVCLEVBQUUsTUFBTTtNQUNoQyxNQUFNO1FBQUVDO01BQVUsQ0FBQyxHQUFHVCxZQUFZLENBQUM7UUFBRWMsUUFBUSxFQUFFO01BQUssQ0FBQyxDQUFDO01BQ3RESixNQUFNLENBQUNELFNBQVMsQ0FBQyxDQUFDRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQztJQUVGSCxFQUFFLENBQUMsc0JBQXNCLEVBQUUsTUFBTTtNQUMvQixNQUFNO1FBQUVDO01BQVUsQ0FBQyxHQUFHVCxZQUFZLENBQUM7UUFBRUwsT0FBTyxFQUFFO01BQUssQ0FBQyxDQUFDO01BQ3JEZSxNQUFNLENBQUNELFNBQVMsQ0FBQyxDQUFDRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQztJQUVGSCxFQUFFLENBQUMsd0JBQXdCLEVBQUUsTUFBTTtNQUNqQyxNQUFNO1FBQUVDO01BQVUsQ0FBQyxHQUFHVCxZQUFZLENBQUM7UUFBRUwsT0FBTyxFQUFFO01BQU0sQ0FBQyxDQUFDO01BQ3REZSxNQUFNLENBQUNELFNBQVMsQ0FBQyxDQUFDRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQztJQUVGSCxFQUFFLENBQUMsdUJBQXVCLEVBQUUsTUFBTTtNQUNoQyxNQUFNO1FBQUVDO01BQVUsQ0FBQyxHQUFHVCxZQUFZLENBQUM7UUFBRWUsVUFBVSxFQUFFO01BQUssQ0FBQyxDQUFDO01BQ3hETCxNQUFNLENBQUNELFNBQVMsQ0FBQyxDQUFDRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3ZDLENBQUMsQ0FBQztFQUNKLENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==