@pie-element/categorize 13.1.7 → 13.1.9

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

@@ -0,0 +1,118 @@
+"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 _choices = require("../choices");
+jest.mock('../choice', () => ({
+  __esModule: true,
+  default: ({
+    label,
+    id
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": `choice-${id}`
+  }, label),
+  ChoiceType: {}
+}));
+jest.mock('@pie-lib/drag', () => ({
+  DraggableChoice: props => /*#__PURE__*/_react.default.createElement("div", props),
+  PlaceHolder: ({
+    children
+  }) => /*#__PURE__*/_react.default.createElement("div", null, children),
+  uid: {
+    withUid: jest.fn(input => input),
+    generateUid: jest.fn().mockReturnValue('1')
+  }
+}));
+const theme = (0, _styles.createTheme)();
+describe('Choices', () => {
+  const renderChoices = extras => {
+    const defaults = {
+      classes: {},
+      choices: [],
+      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(_choices.Choices, props)));
+  };
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderChoices();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when disabled', () => {
+      const {
+        container
+      } = renderChoices({
+        disabled: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders choices with their labels', () => {
+      renderChoices({
+        choices: [{
+          id: '1',
+          label: 'Choice One'
+        }, {
+          id: '2',
+          label: 'Choice Two'
+        }]
+      });
+      expect(_react2.screen.getByTestId('choice-1')).toBeInTheDocument();
+      expect(_react2.screen.getByTestId('choice-2')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Choice One')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Choice Two')).toBeInTheDocument();
+    });
+    it('does not render empty choices as visible elements', () => {
+      const {
+        container
+      } = renderChoices({
+        choices: [{
+          empty: true
+        }, {
+          id: '1',
+          label: 'Visible Choice'
+        }]
+      });
+      expect(_react2.screen.getByText('Visible Choice')).toBeInTheDocument();
+      // Empty choice renders as empty div
+      expect(container.querySelectorAll('[data-testid^="choice-"]').length).toBe(1);
+    });
+  });
+  describe('choices label', () => {
+    it('displays choices label when provided', () => {
+      renderChoices({
+        model: {
+          choicesLabel: 'Available Choices',
+          categoriesPerRow: 1
+        }
+      });
+      expect(_react2.screen.getByText('Available Choices')).toBeInTheDocument();
+    });
+    it('does not display label when choicesLabel is empty', () => {
+      renderChoices({
+        model: {
+          choicesLabel: '',
+          categoriesPerRow: 1
+        }
+      });
+      expect(_react2.screen.queryByText('Available Choices')).not.toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_choices","jest","mock","__esModule","default","label","id","createElement","ChoiceType","DraggableChoice","props","PlaceHolder","children","uid","withUid","fn","input","generateUid","mockReturnValue","theme","createTheme","describe","renderChoices","extras","defaults","classes","choices","onDropChoice","onRemoveChoice","grid","columns","rows","render","ThemeProvider","Choices","it","container","expect","toBeInTheDocument","disabled","screen","getByTestId","getByText","empty","querySelectorAll","length","toBe","model","choicesLabel","categoriesPerRow","queryByText","not"],"sources":["../../../src/categorize/__tests__/choices.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport { Choices } from '../choices';\n\njest.mock('../choice', () => ({\n  __esModule: true,\n  default: ({ label, id }) => <div data-testid={`choice-${id}`}>{label}</div>,\n  ChoiceType: {},\n}));\njest.mock('@pie-lib/drag', () => ({\n  DraggableChoice: (props) => <div {...props} />,\n  PlaceHolder: ({ children }) => <div>{children}</div>,\n  uid: {\n    withUid: jest.fn((input) => input),\n    generateUid: jest.fn().mockReturnValue('1'),\n  },\n}));\n\nconst theme = createTheme();\n\ndescribe('Choices', () => {\n  const renderChoices = (extras) => {\n    const defaults = {\n      classes: {},\n      choices: [],\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        <Choices {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderChoices();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders when disabled', () => {\n      const { container } = renderChoices({ disabled: true });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders choices with their labels', () => {\n      renderChoices({\n        choices: [\n          { id: '1', label: 'Choice One' },\n          { id: '2', label: 'Choice Two' },\n        ],\n      });\n      expect(screen.getByTestId('choice-1')).toBeInTheDocument();\n      expect(screen.getByTestId('choice-2')).toBeInTheDocument();\n      expect(screen.getByText('Choice One')).toBeInTheDocument();\n      expect(screen.getByText('Choice Two')).toBeInTheDocument();\n    });\n\n    it('does not render empty choices as visible elements', () => {\n      const { container } = renderChoices({\n        choices: [{ empty: true }, { id: '1', label: 'Visible Choice' }],\n      });\n      expect(screen.getByText('Visible Choice')).toBeInTheDocument();\n      // Empty choice renders as empty div\n      expect(container.querySelectorAll('[data-testid^=\"choice-\"]').length).toBe(1);\n    });\n  });\n\n  describe('choices label', () => {\n    it('displays choices label when provided', () => {\n      renderChoices({\n        model: { choicesLabel: 'Available Choices', categoriesPerRow: 1 },\n      });\n      expect(screen.getByText('Available Choices')).toBeInTheDocument();\n    });\n\n    it('does not display label when choicesLabel is empty', () => {\n      renderChoices({\n        model: { choicesLabel: '', categoriesPerRow: 1 },\n      });\n      expect(screen.queryByText('Available Choices')).not.toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/categorize/__tests__/droppable-placeholder.test.js

@@ -0,0 +1,96 @@
+"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 _droppablePlaceholder = _interopRequireDefault(require("../droppable-placeholder"));
+jest.mock('../grid-content', () => ({
+  GridContent: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('@dnd-kit/core', () => ({
+  useDroppable: () => ({
+    setNodeRef: jest.fn(),
+    isOver: false
+  })
+}));
+jest.mock('@pie-lib/drag', () => ({
+  PlaceHolder: ({
+    children,
+    isOver,
+    disabled
+  }) => /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "placeholder",
+    "data-is-over": isOver,
+    "data-disabled": disabled
+  }, children)
+}));
+const theme = (0, _styles.createTheme)();
+describe('DroppablePlaceholder', () => {
+  const renderPlaceholder = extras => {
+    const defaults = {
+      id: 'test-placeholder',
+      classes: {}
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_droppablePlaceholder.default, props, /*#__PURE__*/_react.default.createElement("span", null, "Child Content"))));
+  };
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderPlaceholder();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders children content', () => {
+      renderPlaceholder();
+      expect(_react2.screen.getByText('Child Content')).toBeInTheDocument();
+    });
+    it('renders the placeholder wrapper', () => {
+      renderPlaceholder();
+      expect(_react2.screen.getByTestId('placeholder')).toBeInTheDocument();
+    });
+  });
+  describe('disabled state', () => {
+    it('passes disabled prop to placeholder', () => {
+      renderPlaceholder({
+        disabled: true
+      });
+      const placeholder = _react2.screen.getByTestId('placeholder');
+      expect(placeholder).toHaveAttribute('data-disabled', 'true');
+    });
+    it('passes disabled=false when not disabled', () => {
+      renderPlaceholder({
+        disabled: false
+      });
+      const placeholder = _react2.screen.getByTestId('placeholder');
+      expect(placeholder).toHaveAttribute('data-disabled', 'false');
+    });
+  });
+  describe('minRowHeight', () => {
+    it('renders with default min height', () => {
+      const {
+        container
+      } = renderPlaceholder();
+      expect(container.firstChild).toHaveStyle({
+        minHeight: '80px'
+      });
+    });
+    it('applies custom minRowHeight', () => {
+      const {
+        container
+      } = renderPlaceholder({
+        minRowHeight: '120px'
+      });
+      expect(container.firstChild).toHaveStyle({
+        minHeight: '120px'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/categorize/__tests__/grid-content.test.js

@@ -0,0 +1,48 @@
+"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 _gridContent = require("../grid-content");
+const theme = (0, _styles.createTheme)();
+describe('grid-content', () => {
+  const renderGridContent = extras => {
+    const defaults = {
+      classes: {},
+      columns: 2
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_gridContent.GridContent, props, "content")));
+  };
+  describe('renders', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderGridContent();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders with different columns', () => {
+      const {
+        container
+      } = renderGridContent({
+        columns: 3
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders with className', () => {
+      const {
+        container
+      } = renderGridContent({
+        className: 'foo'
+      });
+      expect(container).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,250 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _index = _interopRequireWildcard(require("../index"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+jest.mock('@pie-lib/drag', () => ({
+  uid: {
+    withUid: jest.fn(a => a),
+    Provider: ({
+      children
+    }) => /*#__PURE__*/_react.default.createElement("div", null, children),
+    generateId: jest.fn().mockReturnValue('1')
+  },
+  withDragContext: jest.fn(n => n),
+  DragProvider: ({
+    children
+  }) => /*#__PURE__*/_react.default.createElement("div", null, children)
+}));
+jest.mock('@dnd-kit/core', () => ({
+  DragOverlay: ({
+    children
+  }) => /*#__PURE__*/_react.default.createElement("div", null, children),
+  useSensor: jest.fn(),
+  useSensors: jest.fn(() => []),
+  PointerSensor: jest.fn()
+}));
+jest.mock('../categories', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('../choices', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('../choice', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('@pie-lib/correct-answer-toggle', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('@pie-lib/categorize', () => ({
+  buildState: jest.fn(() => ({})),
+  removeChoiceFromCategory: jest.fn(() => []),
+  moveChoiceToCategory: jest.fn(() => [])
+}));
+jest.mock('@pie-lib/config-ui', () => ({
+  AlertDialog: props => /*#__PURE__*/_react.default.createElement("div", props)
+}));
+jest.mock('@pie-lib/render-ui', () => {
+  const React = require('react');
+  const UiLayout = React.forwardRef((props, ref) => /*#__PURE__*/React.createElement("div", (0, _extends2.default)({
+    ref: ref
+  }, props)));
+  UiLayout.displayName = 'UiLayout';
+  return {
+    Collapsible: ({
+      children
+    }) => /*#__PURE__*/React.createElement("div", null, children),
+    Feedback: props => /*#__PURE__*/React.createElement("div", props),
+    UiLayout,
+    hasText: jest.fn(() => false),
+    hasMedia: jest.fn(() => false),
+    PreviewPrompt: props => /*#__PURE__*/React.createElement("div", props),
+    color: {
+      text: () => '#000',
+      background: () => '#fff',
+      white: () => '#fff',
+      correct: () => '#00ff00',
+      incorrect: () => '#ff0000'
+    }
+  };
+});
+const theme = (0, _styles.createTheme)();
+describe('categorize', () => {
+  const defaultProps = {
+    classes: {},
+    session: {
+      answers: []
+    },
+    model: {
+      choices: [],
+      categories: []
+    }
+  };
+  let onAnswersChange;
+  let onShowCorrectToggle;
+  beforeEach(() => {
+    onAnswersChange = jest.fn();
+    onShowCorrectToggle = jest.fn();
+  });
+  const renderCategorize = extras => {
+    const defaults = {
+      ...defaultProps,
+      onAnswersChange,
+      onShowCorrectToggle
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react.default.createElement(_index.Categorize, props)));
+  };
+  describe('renders', () => {
+    it('renders without crashing', () => {
+      const {
+        container
+      } = renderCategorize();
+      expect(container).toBeInTheDocument();
+    });
+    it('renders with feedback', () => {
+      const {
+        container
+      } = renderCategorize({
+        model: {
+          ...defaultProps.model,
+          correctness: 'correct',
+          feedback: {
+            correct: {
+              type: 'default',
+              default: 'Correct'
+            },
+            incorrect: {
+              type: 'default',
+              default: 'Incorrect'
+            },
+            partial: {
+              type: 'default',
+              default: 'Nearly'
+            }
+          }
+        }
+      });
+      expect(container).toBeInTheDocument();
+    });
+    it('renders when incorrect', () => {
+      const {
+        container
+      } = renderCategorize({
+        incorrect: true
+      });
+      expect(container).toBeInTheDocument();
+    });
+  });
+  describe('provider onDragEnd', () => {
+    const createProvider = (extras = {}) => {
+      const instance = new _index.default({
+        ...defaultProps,
+        onAnswersChange: jest.fn(),
+        onShowCorrectToggle: jest.fn(),
+        resumeMathObserver: jest.fn(),
+        ...extras
+      });
+      instance.setState = jest.fn();
+      instance.categorizeRef = {
+        removeChoice: jest.fn(),
+        dropChoice: jest.fn()
+      };
+      return instance;
+    };
+    const dndEvent = ({
+      activeData,
+      overId,
+      overData
+    }) => ({
+      active: activeData ? {
+        data: {
+          current: activeData
+        }
+      } : null,
+      over: overId || overData ? {
+        id: overId,
+        data: {
+          current: overData
+        }
+      } : null
+    });
+    it('removes choice from source when dropped outside valid target', () => {
+      const provider = createProvider();
+      const event = dndEvent({
+        activeData: {
+          id: 'c1',
+          type: 'choice',
+          categoryId: 'cat-1',
+          choiceIndex: 0,
+          value: 'v1',
+          itemType: 'categorize'
+        }
+      });
+      provider.onDragEnd(event);
+      expect(provider.categorizeRef.removeChoice).toHaveBeenCalledWith(expect.objectContaining({
+        id: 'c1',
+        categoryId: 'cat-1',
+        choiceIndex: 0
+      }));
+      expect(provider.categorizeRef.dropChoice).not.toHaveBeenCalled();
+    });
+    it('removes choice from source when dropped on choices-board', () => {
+      const provider = createProvider();
+      const event = dndEvent({
+        overId: 'choices-board',
+        overData: {
+          itemType: 'categorize'
+        },
+        activeData: {
+          id: 'c2',
+          type: 'choice',
+          categoryId: 'cat-2',
+          choiceIndex: 1,
+          value: 'v2',
+          itemType: 'categorize'
+        }
+      });
+      provider.onDragEnd(event);
+      expect(provider.categorizeRef.removeChoice).toHaveBeenCalled();
+      expect(provider.categorizeRef.dropChoice).not.toHaveBeenCalled();
+    });
+    it('drops choice into category when valid category target exists', () => {
+      const provider = createProvider();
+      const event = dndEvent({
+        overId: 'cat-target',
+        overData: {
+          itemType: 'categorize'
+        },
+        activeData: {
+          id: 'c3',
+          type: 'choice',
+          categoryId: 'cat-source',
+          choiceIndex: 2,
+          value: 'v3',
+          itemType: 'categorize'
+        }
+      });
+      provider.onDragEnd(event);
+      expect(provider.categorizeRef.dropChoice).toHaveBeenCalledWith('cat-target', expect.objectContaining({
+        id: 'c3',
+        categoryId: 'cat-source',
+        choiceIndex: 2
+      }));
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_index","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","jest","mock","uid","withUid","fn","a","Provider","children","createElement","generateId","mockReturnValue","withDragContext","DragProvider","DragOverlay","useSensor","useSensors","PointerSensor","props","buildState","removeChoiceFromCategory","moveChoiceToCategory","AlertDialog","React","UiLayout","forwardRef","ref","_extends2","displayName","Collapsible","Feedback","hasText","hasMedia","PreviewPrompt","color","text","background","white","correct","incorrect","theme","createTheme","describe","defaultProps","classes","session","answers","model","choices","categories","onAnswersChange","onShowCorrectToggle","beforeEach","renderCategorize","extras","defaults","render","ThemeProvider","Categorize","it","container","expect","toBeInTheDocument","correctness","feedback","type","partial","createProvider","instance","CategorizeProvider","resumeMathObserver","setState","categorizeRef","removeChoice","dropChoice","dndEvent","activeData","overId","overData","active","data","current","over","id","provider","event","categoryId","choiceIndex","value","itemType","onDragEnd","toHaveBeenCalledWith","objectContaining","not","toHaveBeenCalled"],"sources":["../../../src/categorize/__tests__/index.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport { Categorize } from '../index';\nimport CategorizeProvider from '../index';\n\njest.mock('@pie-lib/drag', () => ({\n  uid: {\n    withUid: jest.fn((a) => a),\n    Provider: ({ children }) => <div>{children}</div>,\n    generateId: jest.fn().mockReturnValue('1'),\n  },\n  withDragContext: jest.fn((n) => n),\n  DragProvider: ({ children }) => <div>{children}</div>,\n}));\n\njest.mock('@dnd-kit/core', () => ({\n  DragOverlay: ({ children }) => <div>{children}</div>,\n  useSensor: jest.fn(),\n  useSensors: jest.fn(() => []),\n  PointerSensor: jest.fn(),\n}));\n\njest.mock('../categories', () => ({\n  __esModule: true,\n  default: (props) => <div {...props} />,\n}));\njest.mock('../choices', () => ({\n  __esModule: true,\n  default: (props) => <div {...props} />,\n}));\njest.mock('../choice', () => ({\n  __esModule: true,\n  default: (props) => <div {...props} />,\n}));\njest.mock('@pie-lib/correct-answer-toggle', () => ({\n  __esModule: true,\n  default: (props) => <div {...props} />,\n}));\njest.mock('@pie-lib/categorize', () => ({\n  buildState: jest.fn(() => ({})),\n  removeChoiceFromCategory: jest.fn(() => []),\n  moveChoiceToCategory: jest.fn(() => []),\n}));\njest.mock('@pie-lib/config-ui', () => ({\n  AlertDialog: (props) => <div {...props} />,\n}));\njest.mock('@pie-lib/render-ui', () => {\n  const React = require('react');\n  const UiLayout = React.forwardRef((props, ref) => <div ref={ref} {...props} />);\n  UiLayout.displayName = 'UiLayout';\n\n  return {\n    Collapsible: ({ children }) => <div>{children}</div>,\n    Feedback: (props) => <div {...props} />,\n    UiLayout,\n    hasText: jest.fn(() => false),\n    hasMedia: jest.fn(() => false),\n    PreviewPrompt: (props) => <div {...props} />,\n    color: {\n      text: () => '#000',\n      background: () => '#fff',\n      white: () => '#fff',\n      correct: () => '#00ff00',\n      incorrect: () => '#ff0000',\n    },\n  };\n});\n\nconst theme = createTheme();\n\ndescribe('categorize', () => {\n  const defaultProps = {\n    classes: {},\n    session: {\n      answers: [],\n    },\n    model: {\n      choices: [],\n      categories: [],\n    },\n  };\n  let onAnswersChange;\n  let onShowCorrectToggle;\n\n  beforeEach(() => {\n    onAnswersChange = jest.fn();\n    onShowCorrectToggle = jest.fn();\n  });\n\n  const renderCategorize = (extras) => {\n    const defaults = {\n      ...defaultProps,\n      onAnswersChange,\n      onShowCorrectToggle,\n    };\n    const props = { ...defaults, ...extras };\n\n    return render(\n      <ThemeProvider theme={theme}>\n        <Categorize {...props} />\n      </ThemeProvider>,\n    );\n  };\n\n  describe('renders', () => {\n    it('renders without crashing', () => {\n      const { container } = renderCategorize();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders with feedback', () => {\n      const { container } = renderCategorize({\n        model: {\n          ...defaultProps.model,\n          correctness: 'correct',\n          feedback: {\n            correct: {\n              type: 'default',\n              default: 'Correct',\n            },\n            incorrect: {\n              type: 'default',\n              default: 'Incorrect',\n            },\n            partial: {\n              type: 'default',\n              default: 'Nearly',\n            },\n          },\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders when incorrect', () => {\n      const { container } = renderCategorize({ incorrect: true });\n      expect(container).toBeInTheDocument();\n    });\n  });\n\n  describe('provider onDragEnd', () => {\n    const createProvider = (extras = {}) => {\n      const instance = new CategorizeProvider({\n        ...defaultProps,\n        onAnswersChange: jest.fn(),\n        onShowCorrectToggle: jest.fn(),\n        resumeMathObserver: jest.fn(),\n        ...extras,\n      });\n\n      instance.setState = jest.fn();\n      instance.categorizeRef = {\n        removeChoice: jest.fn(),\n        dropChoice: jest.fn(),\n      };\n\n      return instance;\n    };\n\n    const dndEvent = ({ activeData, overId, overData }) => ({\n      active: activeData ? { data: { current: activeData } } : null,\n      over: overId || overData ? { id: overId, data: { current: overData } } : null,\n    });\n\n    it('removes choice from source when dropped outside valid target', () => {\n      const provider = createProvider();\n      const event = dndEvent({\n        activeData: {\n          id: 'c1',\n          type: 'choice',\n          categoryId: 'cat-1',\n          choiceIndex: 0,\n          value: 'v1',\n          itemType: 'categorize',\n        },\n      });\n\n      provider.onDragEnd(event);\n\n      expect(provider.categorizeRef.removeChoice).toHaveBeenCalledWith(\n        expect.objectContaining({\n          id: 'c1',\n          categoryId: 'cat-1',\n          choiceIndex: 0,\n        }),\n      );\n      expect(provider.categorizeRef.dropChoice).not.toHaveBeenCalled();\n    });\n\n    it('removes choice from source when dropped on choices-board', () => {\n      const provider = createProvider();\n      const event = dndEvent({\n        overId: 'choices-board',\n        overData: { itemType: 'categorize' },\n        activeData: {\n          id: 'c2',\n          type: 'choice',\n          categoryId: 'cat-2',\n          choiceIndex: 1,\n          value: 'v2',\n          itemType: 'categorize',\n        },\n      });\n\n      provider.onDragEnd(event);\n\n      expect(provider.categorizeRef.removeChoice).toHaveBeenCalled();\n      expect(provider.categorizeRef.dropChoice).not.toHaveBeenCalled();\n    });\n\n    it('drops choice into category when valid category target exists', () => {\n      const provider = createProvider();\n      const event = dndEvent({\n        overId: 'cat-target',\n        overData: { itemType: 'categorize' },\n        activeData: {\n          id: 'c3',\n          type: 'choice',\n          categoryId: 'cat-source',\n          choiceIndex: 2,\n          value: 'v3',\n          itemType: 'categorize',\n        },\n      });\n\n      provider.onDragEnd(event);\n\n      expect(provider.categorizeRef.dropChoice).toHaveBeenCalledWith(\n        'cat-target',\n        expect.objectContaining({\n          id: 'c3',\n          categoryId: 'cat-source',\n          choiceIndex: 2,\n        }),\n      );\n    });\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAC,uBAAA,CAAAJ,OAAA;AAAsC,SAAAI,wBAAAC,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAH,uBAAA,YAAAA,CAAAC,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAGtCkB,IAAI,CAACC,IAAI,CAAC,eAAe,EAAE,OAAO;EAChCC,GAAG,EAAE;IACHC,OAAO,EAAEH,IAAI,CAACI,EAAE,CAAEC,CAAC,IAAKA,CAAC,CAAC;IAC1BC,QAAQ,EAAEA,CAAC;MAAEC;IAAS,CAAC,kBAAKjC,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,cAAMD,QAAc,CAAC;IACjDE,UAAU,EAAET,IAAI,CAACI,EAAE,CAAC,CAAC,CAACM,eAAe,CAAC,GAAG;EAC3C,CAAC;EACDC,eAAe,EAAEX,IAAI,CAACI,EAAE,CAAEnB,CAAC,IAAKA,CAAC,CAAC;EAClC2B,YAAY,EAAEA,CAAC;IAAEL;EAAS,CAAC,kBAAKjC,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,cAAMD,QAAc;AACtD,CAAC,CAAC,CAAC;AAEHP,IAAI,CAACC,IAAI,CAAC,eAAe,EAAE,OAAO;EAChCY,WAAW,EAAEA,CAAC;IAAEN;EAAS,CAAC,kBAAKjC,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,cAAMD,QAAc,CAAC;EACpDO,SAAS,EAAEd,IAAI,CAACI,EAAE,CAAC,CAAC;EACpBW,UAAU,EAAEf,IAAI,CAACI,EAAE,CAAC,MAAM,EAAE,CAAC;EAC7BY,aAAa,EAAEhB,IAAI,CAACI,EAAE,CAAC;AACzB,CAAC,CAAC,CAAC;AAEHJ,IAAI,CAACC,IAAI,CAAC,eAAe,EAAE,OAAO;EAChCf,UAAU,EAAE,IAAI;EAChBK,OAAO,EAAG0B,KAAK,iBAAK3C,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,QAASS,KAAQ;AACvC,CAAC,CAAC,CAAC;AACHjB,IAAI,CAACC,IAAI,CAAC,YAAY,EAAE,OAAO;EAC7Bf,UAAU,EAAE,IAAI;EAChBK,OAAO,EAAG0B,KAAK,iBAAK3C,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,QAASS,KAAQ;AACvC,CAAC,CAAC,CAAC;AACHjB,IAAI,CAACC,IAAI,CAAC,WAAW,EAAE,OAAO;EAC5Bf,UAAU,EAAE,IAAI;EAChBK,OAAO,EAAG0B,KAAK,iBAAK3C,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,QAASS,KAAQ;AACvC,CAAC,CAAC,CAAC;AACHjB,IAAI,CAACC,IAAI,CAAC,gCAAgC,EAAE,OAAO;EACjDf,UAAU,EAAE,IAAI;EAChBK,OAAO,EAAG0B,KAAK,iBAAK3C,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,QAASS,KAAQ;AACvC,CAAC,CAAC,CAAC;AACHjB,IAAI,CAACC,IAAI,CAAC,qBAAqB,EAAE,OAAO;EACtCiB,UAAU,EAAElB,IAAI,CAACI,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC/Be,wBAAwB,EAAEnB,IAAI,CAACI,EAAE,CAAC,MAAM,EAAE,CAAC;EAC3CgB,oBAAoB,EAAEpB,IAAI,CAACI,EAAE,CAAC,MAAM,EAAE;AACxC,CAAC,CAAC,CAAC;AACHJ,IAAI,CAACC,IAAI,CAAC,oBAAoB,EAAE,OAAO;EACrCoB,WAAW,EAAGJ,KAAK,iBAAK3C,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,QAASS,KAAQ;AAC3C,CAAC,CAAC,CAAC;AACHjB,IAAI,CAACC,IAAI,CAAC,oBAAoB,EAAE,MAAM;EACpC,MAAMqB,KAAK,GAAG9C,OAAO,CAAC,OAAO,CAAC;EAC9B,MAAM+C,QAAQ,GAAGD,KAAK,CAACE,UAAU,CAAC,CAACP,KAAK,EAAEQ,GAAG,kBAAKH,KAAA,CAAAd,aAAA,YAAAkB,SAAA,CAAAnC,OAAA;IAAKkC,GAAG,EAAEA;EAAI,GAAKR,KAAK,CAAG,CAAC,CAAC;EAC/EM,QAAQ,CAACI,WAAW,GAAG,UAAU;EAEjC,OAAO;IACLC,WAAW,EAAEA,CAAC;MAAErB;IAAS,CAAC,kBAAKe,KAAA,CAAAd,aAAA,cAAMD,QAAc,CAAC;IACpDsB,QAAQ,EAAGZ,KAAK,iBAAKK,KAAA,CAAAd,aAAA,QAASS,KAAQ,CAAC;IACvCM,QAAQ;IACRO,OAAO,EAAE9B,IAAI,CAACI,EAAE,CAAC,MAAM,KAAK,CAAC;IAC7B2B,QAAQ,EAAE/B,IAAI,CAACI,EAAE,CAAC,MAAM,KAAK,CAAC;IAC9B4B,aAAa,EAAGf,KAAK,iBAAKK,KAAA,CAAAd,aAAA,QAASS,KAAQ,CAAC;IAC5CgB,KAAK,EAAE;MACLC,IAAI,EAAEA,CAAA,KAAM,MAAM;MAClBC,UAAU,EAAEA,CAAA,KAAM,MAAM;MACxBC,KAAK,EAAEA,CAAA,KAAM,MAAM;MACnBC,OAAO,EAAEA,CAAA,KAAM,SAAS;MACxBC,SAAS,EAAEA,CAAA,KAAM;IACnB;EACF,CAAC;AACH,CAAC,CAAC;AAEF,MAAMC,KAAK,GAAG,IAAAC,mBAAW,EAAC,CAAC;AAE3BC,QAAQ,CAAC,YAAY,EAAE,MAAM;EAC3B,MAAMC,YAAY,GAAG;IACnBC,OAAO,EAAE,CAAC,CAAC;IACXC,OAAO,EAAE;MACPC,OAAO,EAAE;IACX,CAAC;IACDC,KAAK,EAAE;MACLC,OAAO,EAAE,EAAE;MACXC,UAAU,EAAE;IACd;EACF,CAAC;EACD,IAAIC,eAAe;EACnB,IAAIC,mBAAmB;EAEvBC,UAAU,CAAC,MAAM;IACfF,eAAe,GAAGjD,IAAI,CAACI,EAAE,CAAC,CAAC;IAC3B8C,mBAAmB,GAAGlD,IAAI,CAACI,EAAE,CAAC,CAAC;EACjC,CAAC,CAAC;EAEF,MAAMgD,gBAAgB,GAAIC,MAAM,IAAK;IACnC,MAAMC,QAAQ,GAAG;MACf,GAAGZ,YAAY;MACfO,eAAe;MACfC;IACF,CAAC;IACD,MAAMjC,KAAK,GAAG;MAAE,GAAGqC,QAAQ;MAAE,GAAGD;IAAO,CAAC;IAExC,OAAO,IAAAE,cAAM,eACXjF,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,CAAC9B,OAAA,CAAA8E,aAAa;MAACjB,KAAK,EAAEA;IAAM,gBAC1BjE,MAAA,CAAAiB,OAAA,CAAAiB,aAAA,CAAC7B,MAAA,CAAA8E,UAAU,EAAKxC,KAAQ,CACX,CACjB,CAAC;EACH,CAAC;EAEDwB,QAAQ,CAAC,SAAS,EAAE,MAAM;IACxBiB,EAAE,CAAC,0BAA0B,EAAE,MAAM;MACnC,MAAM;QAAEC;MAAU,CAAC,GAAGP,gBAAgB,CAAC,CAAC;MACxCQ,MAAM,CAACD,SAAS,CAAC,CAACE,iBAAiB,CAAC,CAAC;IACvC,CAAC,CAAC;IAEFH,EAAE,CAAC,uBAAuB,EAAE,MAAM;MAChC,MAAM;QAAEC;MAAU,CAAC,GAAGP,gBAAgB,CAAC;QACrCN,KAAK,EAAE;UACL,GAAGJ,YAAY,CAACI,KAAK;UACrBgB,WAAW,EAAE,SAAS;UACtBC,QAAQ,EAAE;YACR1B,OAAO,EAAE;cACP2B,IAAI,EAAE,SAAS;cACfzE,OAAO,EAAE;YACX,CAAC;YACD+C,SAAS,EAAE;cACT0B,IAAI,EAAE,SAAS;cACfzE,OAAO,EAAE;YACX,CAAC;YACD0E,OAAO,EAAE;cACPD,IAAI,EAAE,SAAS;cACfzE,OAAO,EAAE;YACX;UACF;QACF;MACF,CAAC,CAAC;MACFqE,MAAM,CAACD,SAAS,CAAC,CAACE,iBAAiB,CAAC,CAAC;IACvC,CAAC,CAAC;IAEFH,EAAE,CAAC,wBAAwB,EAAE,MAAM;MACjC,MAAM;QAAEC;MAAU,CAAC,GAAGP,gBAAgB,CAAC;QAAEd,SAAS,EAAE;MAAK,CAAC,CAAC;MAC3DsB,MAAM,CAACD,SAAS,CAAC,CAACE,iBAAiB,CAAC,CAAC;IACvC,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFpB,QAAQ,CAAC,oBAAoB,EAAE,MAAM;IACnC,MAAMyB,cAAc,GAAGA,CAACb,MAAM,GAAG,CAAC,CAAC,KAAK;MACtC,MAAMc,QAAQ,GAAG,IAAIC,cAAkB,CAAC;QACtC,GAAG1B,YAAY;QACfO,eAAe,EAAEjD,IAAI,CAACI,EAAE,CAAC,CAAC;QAC1B8C,mBAAmB,EAAElD,IAAI,CAACI,EAAE,CAAC,CAAC;QAC9BiE,kBAAkB,EAAErE,IAAI,CAACI,EAAE,CAAC,CAAC;QAC7B,GAAGiD;MACL,CAAC,CAAC;MAEFc,QAAQ,CAACG,QAAQ,GAAGtE,IAAI,CAACI,EAAE,CAAC,CAAC;MAC7B+D,QAAQ,CAACI,aAAa,GAAG;QACvBC,YAAY,EAAExE,IAAI,CAACI,EAAE,CAAC,CAAC;QACvBqE,UAAU,EAAEzE,IAAI,CAACI,EAAE,CAAC;MACtB,CAAC;MAED,OAAO+D,QAAQ;IACjB,CAAC;IAED,MAAMO,QAAQ,GAAGA,CAAC;MAAEC,UAAU;MAAEC,MAAM;MAAEC;IAAS,CAAC,MAAM;MACtDC,MAAM,EAAEH,UAAU,GAAG;QAAEI,IAAI,EAAE;UAAEC,OAAO,EAAEL;QAAW;MAAE,CAAC,GAAG,IAAI;MAC7DM,IAAI,EAAEL,MAAM,IAAIC,QAAQ,GAAG;QAAEK,EAAE,EAAEN,MAAM;QAAEG,IAAI,EAAE;UAAEC,OAAO,EAAEH;QAAS;MAAE,CAAC,GAAG;IAC3E,CAAC,CAAC;IAEFnB,EAAE,CAAC,8DAA8D,EAAE,MAAM;MACvE,MAAMyB,QAAQ,GAAGjB,cAAc,CAAC,CAAC;MACjC,MAAMkB,KAAK,GAAGV,QAAQ,CAAC;QACrBC,UAAU,EAAE;UACVO,EAAE,EAAE,IAAI;UACRlB,IAAI,EAAE,QAAQ;UACdqB,UAAU,EAAE,OAAO;UACnBC,WAAW,EAAE,CAAC;UACdC,KAAK,EAAE,IAAI;UACXC,QAAQ,EAAE;QACZ;MACF,CAAC,CAAC;MAEFL,QAAQ,CAACM,SAAS,CAACL,KAAK,CAAC;MAEzBxB,MAAM,CAACuB,QAAQ,CAACZ,aAAa,CAACC,YAAY,CAAC,CAACkB,oBAAoB,CAC9D9B,MAAM,CAAC+B,gBAAgB,CAAC;QACtBT,EAAE,EAAE,IAAI;QACRG,UAAU,EAAE,OAAO;QACnBC,WAAW,EAAE;MACf,CAAC,CACH,CAAC;MACD1B,MAAM,CAACuB,QAAQ,CAACZ,aAAa,CAACE,UAAU,CAAC,CAACmB,GAAG,CAACC,gBAAgB,CAAC,CAAC;IAClE,CAAC,CAAC;IAEFnC,EAAE,CAAC,0DAA0D,EAAE,MAAM;MACnE,MAAMyB,QAAQ,GAAGjB,cAAc,CAAC,CAAC;MACjC,MAAMkB,KAAK,GAAGV,QAAQ,CAAC;QACrBE,MAAM,EAAE,eAAe;QACvBC,QAAQ,EAAE;UAAEW,QAAQ,EAAE;QAAa,CAAC;QACpCb,UAAU,EAAE;UACVO,EAAE,EAAE,IAAI;UACRlB,IAAI,EAAE,QAAQ;UACdqB,UAAU,EAAE,OAAO;UACnBC,WAAW,EAAE,CAAC;UACdC,KAAK,EAAE,IAAI;UACXC,QAAQ,EAAE;QACZ;MACF,CAAC,CAAC;MAEFL,QAAQ,CAACM,SAAS,CAACL,KAAK,CAAC;MAEzBxB,MAAM,CAACuB,QAAQ,CAACZ,aAAa,CAACC,YAAY,CAAC,CAACqB,gBAAgB,CAAC,CAAC;MAC9DjC,MAAM,CAACuB,QAAQ,CAACZ,aAAa,CAACE,UAAU,CAAC,CAACmB,GAAG,CAACC,gBAAgB,CAAC,CAAC;IAClE,CAAC,CAAC;IAEFnC,EAAE,CAAC,8DAA8D,EAAE,MAAM;MACvE,MAAMyB,QAAQ,GAAGjB,cAAc,CAAC,CAAC;MACjC,MAAMkB,KAAK,GAAGV,QAAQ,CAAC;QACrBE,MAAM,EAAE,YAAY;QACpBC,QAAQ,EAAE;UAAEW,QAAQ,EAAE;QAAa,CAAC;QACpCb,UAAU,EAAE;UACVO,EAAE,EAAE,IAAI;UACRlB,IAAI,EAAE,QAAQ;UACdqB,UAAU,EAAE,YAAY;UACxBC,WAAW,EAAE,CAAC;UACdC,KAAK,EAAE,IAAI;UACXC,QAAQ,EAAE;QACZ;MACF,CAAC,CAAC;MAEFL,QAAQ,CAACM,SAAS,CAACL,KAAK,CAAC;MAEzBxB,MAAM,CAACuB,QAAQ,CAACZ,aAAa,CAACE,UAAU,CAAC,CAACiB,oBAAoB,CAC5D,YAAY,EACZ9B,MAAM,CAAC+B,gBAAgB,CAAC;QACtBT,EAAE,EAAE,IAAI;QACRG,UAAU,EAAE,YAAY;QACxBC,WAAW,EAAE;MACf,CAAC,CACH,CAAC;IACH,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "13.1.7",
+  "version": "13.1.9",
   "description": "",
   "author": "pie framework developers",
   "license": "ISC",
@@ -16,7 +16,7 @@
     "@mui/material": "^7.3.4",
     "@pie-framework/pie-player-events": "^0.1.0",
     "@pie-lib/categorize": "2.0.2",
-    "@pie-lib/config-ui": "13.0.12",
+    "@pie-lib/config-ui": "13.0.13",
     "@pie-lib/correct-answer-toggle": "4.0.5",
     "@pie-lib/drag": "4.0.6",
     "@pie-lib/math-rendering": "5.1.0",
@@ -28,7 +28,7 @@
     "react": "18.3.1",
     "react-dom": "18.3.1"
   },
-  "gitHead": "15b95b0767ae81eec579967743dbc954450acf7a",
+  "gitHead": "3da9547e82ab80b9119ef5854e3593c3e040309d",
   "scripts": {
     "postpublish": "../../scripts/postpublish"
   },