@pie-lib/editable-html-tip-tap 2.1.20-beta.6 → 2.1.20-beta.8

package/lib/extensions/__tests__/responseArea.test.js

@@ -0,0 +1,736 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _responseArea = require("../responseArea");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+jest.mock('@tiptap/core', function () {
+  return {
+    Extension: {
+      create: jest.fn(function (config) {
+        return config;
+      })
+    },
+    Node: {
+      create: jest.fn(function (config) {
+        return config;
+      })
+    }
+  };
+});
+jest.mock('@tiptap/react', function () {
+  return {
+    Node: {
+      create: jest.fn(function (config) {
+        return config;
+      })
+    },
+    ReactNodeViewRenderer: jest.fn(function (component) {
+      return component;
+    })
+  };
+});
+jest.mock('prosemirror-state', function () {
+  return {
+    Plugin: jest.fn(function (config) {
+      return config;
+    }),
+    PluginKey: jest.fn(function (key) {
+      this.key = key;
+    }),
+    TextSelection: {
+      near: jest.fn(function (pos, dir) {
+        return {
+          type: 'text',
+          pos: pos,
+          dir: dir
+        };
+      }),
+      create: jest.fn(function (doc, pos) {
+        return {
+          type: 'text',
+          pos: pos
+        };
+      })
+    },
+    NodeSelection: {
+      create: jest.fn(function (doc, pos) {
+        return {
+          type: 'node',
+          pos: pos
+        };
+      })
+    }
+  };
+});
+jest.mock('../../components/respArea/ExplicitConstructedResponse', function () {
+  return {
+    __esModule: true,
+    "default": jest.fn(function () {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "explicit-constructed-response"
+      });
+    })
+  };
+});
+jest.mock('../../components/respArea/DragInTheBlank/DragInTheBlank', function () {
+  return {
+    __esModule: true,
+    "default": jest.fn(function () {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "drag-in-the-blank"
+      });
+    })
+  };
+});
+jest.mock('../../components/respArea/InlineDropdown', function () {
+  return {
+    __esModule: true,
+    "default": jest.fn(function () {
+      return /*#__PURE__*/React.createElement("div", {
+        "data-testid": "inline-dropdown"
+      });
+    })
+  };
+});
+describe('ResponseAreaExtension', function () {
+  describe('configuration', function () {
+    it('has correct name', function () {
+      expect(_responseArea.ResponseAreaExtension.name).toBe('responseArea');
+    });
+  });
+  describe('addOptions', function () {
+    it('returns default options', function () {
+      var options = _responseArea.ResponseAreaExtension.addOptions();
+      expect(options).toHaveProperty('maxResponseAreas', null);
+      expect(options).toHaveProperty('error', null);
+      expect(options).toHaveProperty('options', null);
+      expect(options).toHaveProperty('respAreaToolbar', null);
+      expect(options).toHaveProperty('onHandleAreaChange', null);
+    });
+  });
+  describe('addProseMirrorPlugins', function () {
+    it('returns empty array when no type specified', function () {
+      var context = {
+        options: {}
+      };
+      var plugins = _responseArea.ResponseAreaExtension.addProseMirrorPlugins.call(context);
+      expect(Array.isArray(plugins)).toBe(true);
+      expect(plugins).toHaveLength(0);
+    });
+    it('returns plugin array when type is specified', function () {
+      var context = {
+        options: {
+          type: 'explicit-constructed-response',
+          maxResponseAreas: 5
+        }
+      };
+      var plugins = _responseArea.ResponseAreaExtension.addProseMirrorPlugins.call(context);
+      expect(Array.isArray(plugins)).toBe(true);
+      expect(plugins).toHaveLength(1);
+      expect(plugins[0]).toHaveProperty('key');
+      expect(plugins[0]).toHaveProperty('view');
+    });
+  });
+  describe('addCommands', function () {
+    it('returns insertResponseArea command', function () {
+      var commands = _responseArea.ResponseAreaExtension.addCommands();
+      expect(commands).toHaveProperty('insertResponseArea');
+      expect((0, _typeof2["default"])(commands.insertResponseArea)).toBe('function');
+    });
+    it('returns refreshResponseArea command', function () {
+      var commands = _responseArea.ResponseAreaExtension.addCommands();
+      expect(commands).toHaveProperty('refreshResponseArea');
+      expect((0, _typeof2["default"])(commands.refreshResponseArea)).toBe('function');
+    });
+    it('refreshResponseArea handles node with attrs safely', function () {
+      var context = {
+        options: {
+          type: 'explicit-constructed-response',
+          maxResponseAreas: 5
+        }
+      };
+      var commands = _responseArea.ResponseAreaExtension.addCommands.call(context);
+      var refreshCommand = commands.refreshResponseArea();
+
+      // Mock transaction and state
+      var mockNode = {
+        attrs: {
+          index: '0',
+          value: 'test'
+        }
+      };
+      var mockTr = {
+        setNodeMarkup: jest.fn(),
+        setSelection: jest.fn()
+      };
+      var mockState = {
+        selection: {
+          from: 0,
+          $from: {
+            nodeAfter: mockNode
+          }
+        },
+        tr: mockTr
+      };
+      var mockCommands = {
+        focus: jest.fn()
+      };
+      var mockDispatch = jest.fn();
+      refreshCommand({
+        tr: mockTr,
+        state: mockState,
+        commands: mockCommands,
+        dispatch: mockDispatch
+      });
+      expect(mockTr.setNodeMarkup).toHaveBeenCalled();
+    });
+    it('refreshResponseArea handles node without attrs safely (optional chaining)', function () {
+      var context = {
+        options: {
+          type: 'explicit-constructed-response',
+          maxResponseAreas: 5
+        }
+      };
+      var commands = _responseArea.ResponseAreaExtension.addCommands.call(context);
+      var refreshCommand = commands.refreshResponseArea();
+
+      // Mock transaction and state with node that has no attrs
+      var mockNode = null;
+      var mockTr = {
+        setNodeMarkup: jest.fn(),
+        setSelection: jest.fn()
+      };
+      var mockState = {
+        selection: {
+          from: 0,
+          $from: {
+            nodeAfter: mockNode
+          }
+        },
+        tr: mockTr
+      };
+      var mockCommands = {
+        focus: jest.fn()
+      };
+      var mockDispatch = jest.fn();
+
+      // This should not throw an error due to optional chaining on node?.attrs
+      expect(function () {
+        refreshCommand({
+          tr: mockTr,
+          state: mockState,
+          commands: mockCommands,
+          dispatch: mockDispatch
+        });
+      }).not.toThrow();
+    });
+    it('refreshResponseArea updates timestamp in node attributes', function () {
+      var context = {
+        options: {
+          type: 'explicit-constructed-response',
+          maxResponseAreas: 5
+        }
+      };
+      var commands = _responseArea.ResponseAreaExtension.addCommands.call(context);
+      var refreshCommand = commands.refreshResponseArea();
+      var mockNode = {
+        attrs: {
+          index: '0',
+          value: 'test',
+          updated: '1234567890'
+        }
+      };
+      var mockTr = {
+        setNodeMarkup: jest.fn(function (pos, type, attrs) {
+          // Verify that updated timestamp is being set
+          expect(attrs.updated).toBeDefined();
+          expect(attrs.updated).not.toBe('1234567890');
+        }),
+        setSelection: jest.fn()
+      };
+      var mockState = {
+        selection: {
+          from: 0,
+          $from: {
+            nodeAfter: mockNode
+          }
+        },
+        tr: mockTr
+      };
+      var mockCommands = {
+        focus: jest.fn()
+      };
+      var mockDispatch = jest.fn();
+      refreshCommand({
+        tr: mockTr,
+        state: mockState,
+        commands: mockCommands,
+        dispatch: mockDispatch
+      });
+      expect(mockTr.setNodeMarkup).toHaveBeenCalled();
+    });
+    describe('insertResponseArea', function () {
+      beforeEach(function () {
+        jest.resetModules();
+      });
+      var buildInsertCommand = function buildInsertCommand() {
+        var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'inline-dropdown';
+        var _require = require('../responseArea'),
+          ResponseAreaExtension = _require.ResponseAreaExtension;
+        var context = {
+          options: {
+            type: type,
+            maxResponseAreas: 5
+          }
+        };
+        var commands = ResponseAreaExtension.addCommands.call(context);
+        return commands.insertResponseArea(type);
+      };
+      var createDoc = function createDoc(existingCount) {
+        var typeName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'inline_dropdown';
+        return {
+          descendants: jest.fn(function (callback) {
+            for (var i = 0; i < existingCount; i += 1) {
+              callback({
+                type: {
+                  name: typeName
+                }
+              }, i);
+            }
+          }),
+          content: {
+            size: 50
+          }
+        };
+      };
+      it('assigns index 1 and id 1 on the first insert', function () {
+        var insert = buildInsertCommand();
+        var mockInlineNode = {
+          nodeSize: 1
+        };
+        var create = jest.fn(function () {
+          return mockInlineNode;
+        });
+        var mockDoc = createDoc(0);
+        var mockTr = {
+          insert: jest.fn(),
+          doc: mockDoc,
+          setSelection: jest.fn()
+        };
+        var state = {
+          schema: {
+            nodes: {
+              inline_dropdown: {
+                create: create
+              }
+            }
+          },
+          doc: mockDoc,
+          selection: {
+            from: 5
+          }
+        };
+        var mockDispatch = jest.fn();
+        var mockCommands = {
+          focus: jest.fn()
+        };
+        var result = insert({
+          tr: mockTr,
+          state: state,
+          dispatch: mockDispatch,
+          commands: mockCommands
+        });
+        expect(result).toBe(true);
+        expect(create).toHaveBeenCalledWith({
+          index: '1',
+          id: '1',
+          value: ''
+        });
+        expect(mockTr.insert).toHaveBeenCalledWith(5, mockInlineNode);
+        expect(mockDispatch).toHaveBeenCalled();
+      });
+      it('assigns consecutive indices on repeated inserts', function () {
+        var insert = buildInsertCommand();
+        var mockInlineNode = {
+          nodeSize: 1
+        };
+        var create = jest.fn(function () {
+          return mockInlineNode;
+        });
+        var mockDoc = createDoc(0);
+        var runOnce = function runOnce() {
+          var mockTr = {
+            insert: jest.fn(),
+            doc: mockDoc,
+            setSelection: jest.fn()
+          };
+          var state = {
+            schema: {
+              nodes: {
+                inline_dropdown: {
+                  create: create
+                }
+              }
+            },
+            doc: mockDoc,
+            selection: {
+              from: 1
+            }
+          };
+          insert({
+            tr: mockTr,
+            state: state,
+            dispatch: jest.fn(),
+            commands: {
+              focus: jest.fn()
+            }
+          });
+        };
+        runOnce();
+        runOnce();
+        expect(create.mock.calls[0][0]).toEqual({
+          index: '1',
+          id: '1',
+          value: ''
+        });
+        expect(create.mock.calls[1][0]).toEqual({
+          index: '2',
+          id: '2',
+          value: ''
+        });
+      });
+      it('returns false when maxResponseAreas is reached', function () {
+        var insert = buildInsertCommand();
+        var mockInlineNode = {
+          nodeSize: 1
+        };
+        var create = jest.fn(function () {
+          return mockInlineNode;
+        });
+        var mockDoc = createDoc(5);
+        var mockTr = {
+          insert: jest.fn(),
+          doc: mockDoc,
+          setSelection: jest.fn()
+        };
+        var state = {
+          schema: {
+            nodes: {
+              inline_dropdown: {
+                create: create
+              }
+            }
+          },
+          doc: mockDoc,
+          selection: {
+            from: 5
+          }
+        };
+        var result = insert({
+          tr: mockTr,
+          state: state,
+          dispatch: jest.fn(),
+          commands: {
+            focus: jest.fn()
+          }
+        });
+        expect(result).toBe(false);
+        expect(create).not.toHaveBeenCalled();
+        expect(mockTr.insert).not.toHaveBeenCalled();
+      });
+      describe('selection after insert', function () {
+        var buildStateAndTr = function buildStateAndTr(typeName) {
+          var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+            _ref$withResolve = _ref.withResolve,
+            withResolve = _ref$withResolve === void 0 ? false : _ref$withResolve;
+          var mockInlineNode = {
+            nodeSize: 1
+          };
+          var create = jest.fn(function () {
+            return mockInlineNode;
+          });
+          var mockDoc = _objectSpread({
+            descendants: jest.fn(),
+            content: {
+              size: 50
+            }
+          }, withResolve ? {
+            resolve: jest.fn(function (pos) {
+              return {
+                resolved: pos
+              };
+            })
+          } : {});
+          var mockTr = {
+            insert: jest.fn(),
+            doc: mockDoc,
+            setSelection: jest.fn()
+          };
+          var state = {
+            schema: {
+              nodes: (0, _defineProperty2["default"])({}, typeName, {
+                create: create
+              })
+            },
+            doc: mockDoc,
+            selection: {
+              from: 5
+            }
+          };
+          return {
+            mockTr: mockTr,
+            state: state
+          };
+        };
+        it.each(['inline-dropdown', 'explicit-constructed-response'])('sets a NodeSelection on the inserted node for %s', function (type) {
+          var insert = buildInsertCommand(type);
+          var typeName = type.replace(/-/g, '_');
+          var _buildStateAndTr = buildStateAndTr(typeName),
+            mockTr = _buildStateAndTr.mockTr,
+            state = _buildStateAndTr.state;
+          var _require2 = require('prosemirror-state'),
+            NodeSelection = _require2.NodeSelection,
+            TextSelection = _require2.TextSelection;
+          insert({
+            tr: mockTr,
+            state: state,
+            dispatch: jest.fn(),
+            commands: {
+              focus: jest.fn()
+            }
+          });
+          expect(NodeSelection.create).toHaveBeenCalledWith(mockTr.doc, 5);
+          expect(TextSelection.near).not.toHaveBeenCalled();
+          expect(mockTr.setSelection).toHaveBeenCalledWith({
+            type: 'node',
+            pos: 5
+          });
+        });
+        it('sets a TextSelection just after the inserted node for math-templated (no NodeSelection)', function () {
+          var insert = buildInsertCommand('math-templated');
+          var _buildStateAndTr2 = buildStateAndTr('math_templated', {
+              withResolve: true
+            }),
+            mockTr = _buildStateAndTr2.mockTr,
+            state = _buildStateAndTr2.state;
+          var _require3 = require('prosemirror-state'),
+            NodeSelection = _require3.NodeSelection,
+            TextSelection = _require3.TextSelection;
+          insert({
+            tr: mockTr,
+            state: state,
+            dispatch: jest.fn(),
+            commands: {
+              focus: jest.fn()
+            }
+          });
+          expect(NodeSelection.create).not.toHaveBeenCalled();
+          // usedPos (5) + nodeSize (1) === 6
+          expect(mockTr.doc.resolve).toHaveBeenCalledWith(6);
+          expect(TextSelection.near).toHaveBeenCalledWith({
+            resolved: 6
+          }, 1);
+          expect(mockTr.setSelection).toHaveBeenCalledWith({
+            type: 'text',
+            pos: {
+              resolved: 6
+            },
+            dir: 1
+          });
+        });
+      });
+    });
+  });
+});
+describe('ExplicitConstructedResponseNode', function () {
+  describe('configuration', function () {
+    it('has correct name', function () {
+      expect(_responseArea.ExplicitConstructedResponseNode.name).toBe('explicit_constructed_response');
+    });
+    it('is inline', function () {
+      expect(_responseArea.ExplicitConstructedResponseNode.inline).toBe(true);
+    });
+    it('is in inline group', function () {
+      expect(_responseArea.ExplicitConstructedResponseNode.group).toBe('inline');
+    });
+    it('is atomic', function () {
+      expect(_responseArea.ExplicitConstructedResponseNode.atom).toBe(true);
+    });
+  });
+  describe('addAttributes', function () {
+    it('returns required attributes', function () {
+      var attributes = _responseArea.ExplicitConstructedResponseNode.addAttributes();
+      expect(attributes).toHaveProperty('index');
+      expect(attributes).toHaveProperty('value');
+      expect(attributes).toHaveProperty('updated');
+      expect(attributes.index).toEqual({
+        "default": null
+      });
+      expect(attributes.value).toEqual({
+        "default": ''
+      });
+      expect(attributes.updated).toEqual({
+        "default": ''
+      });
+    });
+  });
+  describe('parseHTML', function () {
+    it('returns parsing rules', function () {
+      var rules = _responseArea.ExplicitConstructedResponseNode.parseHTML();
+      expect(Array.isArray(rules)).toBe(true);
+      expect(rules).toHaveLength(1);
+      expect(rules[0]).toHaveProperty('tag');
+    });
+  });
+  describe('renderHTML', function () {
+    it('renders span with attributes', function () {
+      var result = _responseArea.ExplicitConstructedResponseNode.renderHTML({
+        HTMLAttributes: {
+          index: '1',
+          id: '1',
+          value: 'test'
+        }
+      });
+      expect(result[0]).toBe('span');
+      expect(result[1]).toHaveProperty('data-type', 'explicit_constructed_response');
+    });
+  });
+  describe('addNodeView', function () {
+    it('returns ReactNodeViewRenderer result', function () {
+      var result = _responseArea.ExplicitConstructedResponseNode.addNodeView();
+      expect(result).toBeDefined();
+    });
+  });
+});
+describe('DragInTheBlankNode', function () {
+  describe('configuration', function () {
+    it('has correct name', function () {
+      expect(_responseArea.DragInTheBlankNode.name).toBe('drag_in_the_blank');
+    });
+    it('is inline', function () {
+      expect(_responseArea.DragInTheBlankNode.inline).toBe(true);
+    });
+    it('is in inline group', function () {
+      expect(_responseArea.DragInTheBlankNode.group).toBe('inline');
+    });
+    it('is atomic', function () {
+      expect(_responseArea.DragInTheBlankNode.atom).toBe(true);
+    });
+  });
+  describe('addAttributes', function () {
+    it('returns required attributes', function () {
+      var attributes = _responseArea.DragInTheBlankNode.addAttributes();
+      expect(attributes).toHaveProperty('index');
+      expect(attributes).toHaveProperty('id');
+      expect(attributes).toHaveProperty('value');
+      expect(attributes).toHaveProperty('inTable');
+      expect(attributes).toHaveProperty('updated');
+      expect(attributes.index).toEqual({
+        "default": null
+      });
+      expect(attributes.id).toEqual({
+        "default": null
+      });
+      expect(attributes.value).toEqual({
+        "default": ''
+      });
+      expect(attributes.inTable).toEqual({
+        "default": null
+      });
+      expect(attributes.updated).toEqual({
+        "default": ''
+      });
+    });
+  });
+  describe('parseHTML', function () {
+    it('returns parsing rules', function () {
+      var rules = _responseArea.DragInTheBlankNode.parseHTML();
+      expect(Array.isArray(rules)).toBe(true);
+      expect(rules).toHaveLength(1);
+      expect(rules[0]).toHaveProperty('tag');
+    });
+  });
+  describe('renderHTML', function () {
+    it('renders span with attributes', function () {
+      var result = _responseArea.DragInTheBlankNode.renderHTML({
+        HTMLAttributes: {
+          index: '1',
+          id: '1',
+          value: 'test'
+        }
+      });
+      expect(result[0]).toBe('span');
+      expect(result[1]).toHaveProperty('data-type', 'drag_in_the_blank');
+    });
+  });
+  describe('addNodeView', function () {
+    it('returns ReactNodeViewRenderer result', function () {
+      var result = _responseArea.DragInTheBlankNode.addNodeView();
+      expect(result).toBeDefined();
+    });
+  });
+});
+describe('InlineDropdownNode', function () {
+  describe('configuration', function () {
+    it('has correct name', function () {
+      expect(_responseArea.InlineDropdownNode.name).toBe('inline_dropdown');
+    });
+    it('is inline', function () {
+      expect(_responseArea.InlineDropdownNode.inline).toBe(true);
+    });
+    it('is in inline group', function () {
+      expect(_responseArea.InlineDropdownNode.group).toBe('inline');
+    });
+    it('is atomic', function () {
+      expect(_responseArea.InlineDropdownNode.atom).toBe(true);
+    });
+  });
+  describe('addAttributes', function () {
+    it('returns required attributes', function () {
+      var attributes = _responseArea.InlineDropdownNode.addAttributes();
+      expect(attributes).toHaveProperty('index');
+      expect(attributes).toHaveProperty('value');
+      expect(attributes).toHaveProperty('updated');
+      expect(attributes.index).toEqual({
+        "default": null
+      });
+      expect(attributes.value).toEqual({
+        "default": ''
+      });
+      expect(attributes.updated).toEqual({
+        "default": ''
+      });
+    });
+  });
+  describe('parseHTML', function () {
+    it('returns parsing rules', function () {
+      var rules = _responseArea.InlineDropdownNode.parseHTML();
+      expect(Array.isArray(rules)).toBe(true);
+      expect(rules).toHaveLength(1);
+      expect(rules[0]).toHaveProperty('tag');
+    });
+  });
+  describe('renderHTML', function () {
+    it('renders span with attributes', function () {
+      var result = _responseArea.InlineDropdownNode.renderHTML({
+        HTMLAttributes: {
+          index: '1',
+          id: '1',
+          value: 'test'
+        }
+      });
+      expect(result[0]).toBe('span');
+      expect(result[1]).toHaveProperty('data-type', 'inline_dropdown');
+    });
+  });
+  describe('addNodeView', function () {
+    it('returns ReactNodeViewRenderer result', function () {
+      var result = _responseArea.InlineDropdownNode.addNodeView();
+      expect(result).toBeDefined();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_responseArea","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","Extension","create","fn","config","Node","ReactNodeViewRenderer","component","Plugin","PluginKey","key","TextSelection","near","pos","dir","type","doc","NodeSelection","__esModule","React","createElement","describe","it","expect","ResponseAreaExtension","name","toBe","options","addOptions","toHaveProperty","context","plugins","addProseMirrorPlugins","call","Array","isArray","toHaveLength","maxResponseAreas","commands","addCommands","_typeof2","insertResponseArea","refreshResponseArea","refreshCommand","mockNode","attrs","index","value","mockTr","setNodeMarkup","setSelection","mockState","selection","from","$from","nodeAfter","tr","mockCommands","focus","mockDispatch","state","dispatch","toHaveBeenCalled","not","toThrow","updated","toBeDefined","beforeEach","resetModules","buildInsertCommand","undefined","_require","createDoc","existingCount","typeName","descendants","callback","i","content","size","insert","mockInlineNode","nodeSize","mockDoc","schema","nodes","inline_dropdown","result","toHaveBeenCalledWith","id","runOnce","calls","toEqual","buildStateAndTr","_ref","_ref$withResolve","withResolve","resolve","resolved","each","replace","_buildStateAndTr","_require2","_buildStateAndTr2","_require3","ExplicitConstructedResponseNode","inline","group","atom","attributes","addAttributes","rules","parseHTML","renderHTML","HTMLAttributes","addNodeView","DragInTheBlankNode","inTable","InlineDropdownNode"],"sources":["../../../src/extensions/__tests__/responseArea.test.js"],"sourcesContent":["import {\n  DragInTheBlankNode,\n  ExplicitConstructedResponseNode,\n  InlineDropdownNode,\n  ResponseAreaExtension,\n} from '../responseArea';\n\njest.mock('@tiptap/core', () => ({\n  Extension: { create: jest.fn((config) => config) },\n  Node: { create: jest.fn((config) => config) },\n}));\n\njest.mock('@tiptap/react', () => ({\n  Node: { create: jest.fn((config) => config) },\n  ReactNodeViewRenderer: jest.fn((component) => component),\n}));\n\njest.mock('prosemirror-state', () => ({\n  Plugin: jest.fn(function (config) {\n    return config;\n  }),\n  PluginKey: jest.fn(function (key) {\n    this.key = key;\n  }),\n  TextSelection: {\n    near: jest.fn((pos, dir) => ({ type: 'text', pos, dir })),\n    create: jest.fn((doc, pos) => ({ type: 'text', pos })),\n  },\n  NodeSelection: {\n    create: jest.fn((doc, pos) => ({ type: 'node', pos })),\n  },\n}));\n\njest.mock('../../components/respArea/ExplicitConstructedResponse', () => ({\n  __esModule: true,\n  default: jest.fn(() => <div data-testid=\"explicit-constructed-response\" />),\n}));\n\njest.mock('../../components/respArea/DragInTheBlank/DragInTheBlank', () => ({\n  __esModule: true,\n  default: jest.fn(() => <div data-testid=\"drag-in-the-blank\" />),\n}));\n\njest.mock('../../components/respArea/InlineDropdown', () => ({\n  __esModule: true,\n  default: jest.fn(() => <div data-testid=\"inline-dropdown\" />),\n}));\n\ndescribe('ResponseAreaExtension', () => {\n  describe('configuration', () => {\n    it('has correct name', () => {\n      expect(ResponseAreaExtension.name).toBe('responseArea');\n    });\n  });\n\n  describe('addOptions', () => {\n    it('returns default options', () => {\n      const options = ResponseAreaExtension.addOptions();\n\n      expect(options).toHaveProperty('maxResponseAreas', null);\n      expect(options).toHaveProperty('error', null);\n      expect(options).toHaveProperty('options', null);\n      expect(options).toHaveProperty('respAreaToolbar', null);\n      expect(options).toHaveProperty('onHandleAreaChange', null);\n    });\n  });\n\n  describe('addProseMirrorPlugins', () => {\n    it('returns empty array when no type specified', () => {\n      const context = {\n        options: {},\n      };\n\n      const plugins = ResponseAreaExtension.addProseMirrorPlugins.call(context);\n\n      expect(Array.isArray(plugins)).toBe(true);\n      expect(plugins).toHaveLength(0);\n    });\n\n    it('returns plugin array when type is specified', () => {\n      const context = {\n        options: {\n          type: 'explicit-constructed-response',\n          maxResponseAreas: 5,\n        },\n      };\n\n      const plugins = ResponseAreaExtension.addProseMirrorPlugins.call(context);\n\n      expect(Array.isArray(plugins)).toBe(true);\n      expect(plugins).toHaveLength(1);\n      expect(plugins[0]).toHaveProperty('key');\n      expect(plugins[0]).toHaveProperty('view');\n    });\n  });\n\n  describe('addCommands', () => {\n    it('returns insertResponseArea command', () => {\n      const commands = ResponseAreaExtension.addCommands();\n\n      expect(commands).toHaveProperty('insertResponseArea');\n      expect(typeof commands.insertResponseArea).toBe('function');\n    });\n\n    it('returns refreshResponseArea command', () => {\n      const commands = ResponseAreaExtension.addCommands();\n\n      expect(commands).toHaveProperty('refreshResponseArea');\n      expect(typeof commands.refreshResponseArea).toBe('function');\n    });\n\n    it('refreshResponseArea handles node with attrs safely', () => {\n      const context = {\n        options: {\n          type: 'explicit-constructed-response',\n          maxResponseAreas: 5,\n        },\n      };\n\n      const commands = ResponseAreaExtension.addCommands.call(context);\n      const refreshCommand = commands.refreshResponseArea();\n\n      // Mock transaction and state\n      const mockNode = {\n        attrs: {\n          index: '0',\n          value: 'test',\n        },\n      };\n\n      const mockTr = {\n        setNodeMarkup: jest.fn(),\n        setSelection: jest.fn(),\n      };\n\n      const mockState = {\n        selection: {\n          from: 0,\n          $from: {\n            nodeAfter: mockNode,\n          },\n        },\n        tr: mockTr,\n      };\n\n      const mockCommands = {\n        focus: jest.fn(),\n      };\n\n      const mockDispatch = jest.fn();\n\n      refreshCommand({\n        tr: mockTr,\n        state: mockState,\n        commands: mockCommands,\n        dispatch: mockDispatch,\n      });\n\n      expect(mockTr.setNodeMarkup).toHaveBeenCalled();\n    });\n\n    it('refreshResponseArea handles node without attrs safely (optional chaining)', () => {\n      const context = {\n        options: {\n          type: 'explicit-constructed-response',\n          maxResponseAreas: 5,\n        },\n      };\n\n      const commands = ResponseAreaExtension.addCommands.call(context);\n      const refreshCommand = commands.refreshResponseArea();\n\n      // Mock transaction and state with node that has no attrs\n      const mockNode = null;\n\n      const mockTr = {\n        setNodeMarkup: jest.fn(),\n        setSelection: jest.fn(),\n      };\n\n      const mockState = {\n        selection: {\n          from: 0,\n          $from: {\n            nodeAfter: mockNode,\n          },\n        },\n        tr: mockTr,\n      };\n\n      const mockCommands = {\n        focus: jest.fn(),\n      };\n\n      const mockDispatch = jest.fn();\n\n      // This should not throw an error due to optional chaining on node?.attrs\n      expect(() => {\n        refreshCommand({\n          tr: mockTr,\n          state: mockState,\n          commands: mockCommands,\n          dispatch: mockDispatch,\n        });\n      }).not.toThrow();\n    });\n\n    it('refreshResponseArea updates timestamp in node attributes', () => {\n      const context = {\n        options: {\n          type: 'explicit-constructed-response',\n          maxResponseAreas: 5,\n        },\n      };\n\n      const commands = ResponseAreaExtension.addCommands.call(context);\n      const refreshCommand = commands.refreshResponseArea();\n\n      const mockNode = {\n        attrs: {\n          index: '0',\n          value: 'test',\n          updated: '1234567890',\n        },\n      };\n\n      const mockTr = {\n        setNodeMarkup: jest.fn((pos, type, attrs) => {\n          // Verify that updated timestamp is being set\n          expect(attrs.updated).toBeDefined();\n          expect(attrs.updated).not.toBe('1234567890');\n        }),\n        setSelection: jest.fn(),\n      };\n\n      const mockState = {\n        selection: {\n          from: 0,\n          $from: {\n            nodeAfter: mockNode,\n          },\n        },\n        tr: mockTr,\n      };\n\n      const mockCommands = {\n        focus: jest.fn(),\n      };\n\n      const mockDispatch = jest.fn();\n\n      refreshCommand({\n        tr: mockTr,\n        state: mockState,\n        commands: mockCommands,\n        dispatch: mockDispatch,\n      });\n\n      expect(mockTr.setNodeMarkup).toHaveBeenCalled();\n    });\n\n    describe('insertResponseArea', () => {\n      beforeEach(() => {\n        jest.resetModules();\n      });\n\n      const buildInsertCommand = (type = 'inline-dropdown') => {\n        const { ResponseAreaExtension } = require('../responseArea');\n        const context = {\n          options: {\n            type,\n            maxResponseAreas: 5,\n          },\n        };\n        const commands = ResponseAreaExtension.addCommands.call(context);\n        return commands.insertResponseArea(type);\n      };\n\n      const createDoc = (existingCount, typeName = 'inline_dropdown') => ({\n        descendants: jest.fn((callback) => {\n          for (let i = 0; i < existingCount; i += 1) {\n            callback({ type: { name: typeName } }, i);\n          }\n        }),\n        content: { size: 50 },\n      });\n\n      it('assigns index 1 and id 1 on the first insert', () => {\n        const insert = buildInsertCommand();\n        const mockInlineNode = { nodeSize: 1 };\n        const create = jest.fn(() => mockInlineNode);\n        const mockDoc = createDoc(0);\n        const mockTr = {\n          insert: jest.fn(),\n          doc: mockDoc,\n          setSelection: jest.fn(),\n        };\n        const state = {\n          schema: {\n            nodes: {\n              inline_dropdown: { create },\n            },\n          },\n          doc: mockDoc,\n          selection: { from: 5 },\n        };\n        const mockDispatch = jest.fn();\n        const mockCommands = { focus: jest.fn() };\n\n        const result = insert({\n          tr: mockTr,\n          state,\n          dispatch: mockDispatch,\n          commands: mockCommands,\n        });\n\n        expect(result).toBe(true);\n        expect(create).toHaveBeenCalledWith({\n          index: '1',\n          id: '1',\n          value: '',\n        });\n        expect(mockTr.insert).toHaveBeenCalledWith(5, mockInlineNode);\n        expect(mockDispatch).toHaveBeenCalled();\n      });\n\n      it('assigns consecutive indices on repeated inserts', () => {\n        const insert = buildInsertCommand();\n        const mockInlineNode = { nodeSize: 1 };\n        const create = jest.fn(() => mockInlineNode);\n        const mockDoc = createDoc(0);\n\n        const runOnce = () => {\n          const mockTr = {\n            insert: jest.fn(),\n            doc: mockDoc,\n            setSelection: jest.fn(),\n          };\n          const state = {\n            schema: {\n              nodes: {\n                inline_dropdown: { create },\n              },\n            },\n            doc: mockDoc,\n            selection: { from: 1 },\n          };\n          insert({\n            tr: mockTr,\n            state,\n            dispatch: jest.fn(),\n            commands: { focus: jest.fn() },\n          });\n        };\n\n        runOnce();\n        runOnce();\n\n        expect(create.mock.calls[0][0]).toEqual({ index: '1', id: '1', value: '' });\n        expect(create.mock.calls[1][0]).toEqual({ index: '2', id: '2', value: '' });\n      });\n\n      it('returns false when maxResponseAreas is reached', () => {\n        const insert = buildInsertCommand();\n        const mockInlineNode = { nodeSize: 1 };\n        const create = jest.fn(() => mockInlineNode);\n        const mockDoc = createDoc(5);\n        const mockTr = {\n          insert: jest.fn(),\n          doc: mockDoc,\n          setSelection: jest.fn(),\n        };\n        const state = {\n          schema: {\n            nodes: {\n              inline_dropdown: { create },\n            },\n          },\n          doc: mockDoc,\n          selection: { from: 5 },\n        };\n\n        const result = insert({\n          tr: mockTr,\n          state,\n          dispatch: jest.fn(),\n          commands: { focus: jest.fn() },\n        });\n\n        expect(result).toBe(false);\n        expect(create).not.toHaveBeenCalled();\n        expect(mockTr.insert).not.toHaveBeenCalled();\n      });\n\n      describe('selection after insert', () => {\n        const buildStateAndTr = (typeName, { withResolve = false } = {}) => {\n          const mockInlineNode = { nodeSize: 1 };\n          const create = jest.fn(() => mockInlineNode);\n          const mockDoc = {\n            descendants: jest.fn(),\n            content: { size: 50 },\n            ...(withResolve ? { resolve: jest.fn((pos) => ({ resolved: pos })) } : {}),\n          };\n          const mockTr = {\n            insert: jest.fn(),\n            doc: mockDoc,\n            setSelection: jest.fn(),\n          };\n          const state = {\n            schema: { nodes: { [typeName]: { create } } },\n            doc: mockDoc,\n            selection: { from: 5 },\n          };\n\n          return { mockTr, state };\n        };\n\n        it.each(['inline-dropdown', 'explicit-constructed-response'])(\n          'sets a NodeSelection on the inserted node for %s',\n          (type) => {\n            const insert = buildInsertCommand(type);\n            const typeName = type.replace(/-/g, '_');\n            const { mockTr, state } = buildStateAndTr(typeName);\n            const { NodeSelection, TextSelection } = require('prosemirror-state');\n\n            insert({ tr: mockTr, state, dispatch: jest.fn(), commands: { focus: jest.fn() } });\n\n            expect(NodeSelection.create).toHaveBeenCalledWith(mockTr.doc, 5);\n            expect(TextSelection.near).not.toHaveBeenCalled();\n            expect(mockTr.setSelection).toHaveBeenCalledWith({ type: 'node', pos: 5 });\n          },\n        );\n\n        it('sets a TextSelection just after the inserted node for math-templated (no NodeSelection)', () => {\n          const insert = buildInsertCommand('math-templated');\n          const { mockTr, state } = buildStateAndTr('math_templated', { withResolve: true });\n          const { NodeSelection, TextSelection } = require('prosemirror-state');\n\n          insert({ tr: mockTr, state, dispatch: jest.fn(), commands: { focus: jest.fn() } });\n\n          expect(NodeSelection.create).not.toHaveBeenCalled();\n          // usedPos (5) + nodeSize (1) === 6\n          expect(mockTr.doc.resolve).toHaveBeenCalledWith(6);\n          expect(TextSelection.near).toHaveBeenCalledWith({ resolved: 6 }, 1);\n          expect(mockTr.setSelection).toHaveBeenCalledWith({ type: 'text', pos: { resolved: 6 }, dir: 1 });\n        });\n      });\n    });\n  });\n});\n\ndescribe('ExplicitConstructedResponseNode', () => {\n  describe('configuration', () => {\n    it('has correct name', () => {\n      expect(ExplicitConstructedResponseNode.name).toBe('explicit_constructed_response');\n    });\n\n    it('is inline', () => {\n      expect(ExplicitConstructedResponseNode.inline).toBe(true);\n    });\n\n    it('is in inline group', () => {\n      expect(ExplicitConstructedResponseNode.group).toBe('inline');\n    });\n\n    it('is atomic', () => {\n      expect(ExplicitConstructedResponseNode.atom).toBe(true);\n    });\n  });\n\n  describe('addAttributes', () => {\n    it('returns required attributes', () => {\n      const attributes = ExplicitConstructedResponseNode.addAttributes();\n\n      expect(attributes).toHaveProperty('index');\n      expect(attributes).toHaveProperty('value');\n      expect(attributes).toHaveProperty('updated');\n\n      expect(attributes.index).toEqual({ default: null });\n      expect(attributes.value).toEqual({ default: '' });\n      expect(attributes.updated).toEqual({ default: '' });\n    });\n  });\n\n  describe('parseHTML', () => {\n    it('returns parsing rules', () => {\n      const rules = ExplicitConstructedResponseNode.parseHTML();\n\n      expect(Array.isArray(rules)).toBe(true);\n      expect(rules).toHaveLength(1);\n      expect(rules[0]).toHaveProperty('tag');\n    });\n  });\n\n  describe('renderHTML', () => {\n    it('renders span with attributes', () => {\n      const result = ExplicitConstructedResponseNode.renderHTML({\n        HTMLAttributes: {\n          index: '1',\n          id: '1',\n          value: 'test',\n        },\n      });\n\n      expect(result[0]).toBe('span');\n      expect(result[1]).toHaveProperty('data-type', 'explicit_constructed_response');\n    });\n  });\n\n  describe('addNodeView', () => {\n    it('returns ReactNodeViewRenderer result', () => {\n      const result = ExplicitConstructedResponseNode.addNodeView();\n\n      expect(result).toBeDefined();\n    });\n  });\n});\n\ndescribe('DragInTheBlankNode', () => {\n  describe('configuration', () => {\n    it('has correct name', () => {\n      expect(DragInTheBlankNode.name).toBe('drag_in_the_blank');\n    });\n\n    it('is inline', () => {\n      expect(DragInTheBlankNode.inline).toBe(true);\n    });\n\n    it('is in inline group', () => {\n      expect(DragInTheBlankNode.group).toBe('inline');\n    });\n\n    it('is atomic', () => {\n      expect(DragInTheBlankNode.atom).toBe(true);\n    });\n  });\n\n  describe('addAttributes', () => {\n    it('returns required attributes', () => {\n      const attributes = DragInTheBlankNode.addAttributes();\n\n      expect(attributes).toHaveProperty('index');\n      expect(attributes).toHaveProperty('id');\n      expect(attributes).toHaveProperty('value');\n      expect(attributes).toHaveProperty('inTable');\n      expect(attributes).toHaveProperty('updated');\n\n      expect(attributes.index).toEqual({ default: null });\n      expect(attributes.id).toEqual({ default: null });\n      expect(attributes.value).toEqual({ default: '' });\n      expect(attributes.inTable).toEqual({ default: null });\n      expect(attributes.updated).toEqual({ default: '' });\n    });\n  });\n\n  describe('parseHTML', () => {\n    it('returns parsing rules', () => {\n      const rules = DragInTheBlankNode.parseHTML();\n\n      expect(Array.isArray(rules)).toBe(true);\n      expect(rules).toHaveLength(1);\n      expect(rules[0]).toHaveProperty('tag');\n    });\n  });\n\n  describe('renderHTML', () => {\n    it('renders span with attributes', () => {\n      const result = DragInTheBlankNode.renderHTML({\n        HTMLAttributes: {\n          index: '1',\n          id: '1',\n          value: 'test',\n        },\n      });\n\n      expect(result[0]).toBe('span');\n      expect(result[1]).toHaveProperty('data-type', 'drag_in_the_blank');\n    });\n  });\n\n  describe('addNodeView', () => {\n    it('returns ReactNodeViewRenderer result', () => {\n      const result = DragInTheBlankNode.addNodeView();\n\n      expect(result).toBeDefined();\n    });\n  });\n});\n\ndescribe('InlineDropdownNode', () => {\n  describe('configuration', () => {\n    it('has correct name', () => {\n      expect(InlineDropdownNode.name).toBe('inline_dropdown');\n    });\n\n    it('is inline', () => {\n      expect(InlineDropdownNode.inline).toBe(true);\n    });\n\n    it('is in inline group', () => {\n      expect(InlineDropdownNode.group).toBe('inline');\n    });\n\n    it('is atomic', () => {\n      expect(InlineDropdownNode.atom).toBe(true);\n    });\n  });\n\n  describe('addAttributes', () => {\n    it('returns required attributes', () => {\n      const attributes = InlineDropdownNode.addAttributes();\n\n      expect(attributes).toHaveProperty('index');\n      expect(attributes).toHaveProperty('value');\n      expect(attributes).toHaveProperty('updated');\n\n      expect(attributes.index).toEqual({ default: null });\n      expect(attributes.value).toEqual({ default: '' });\n      expect(attributes.updated).toEqual({ default: '' });\n    });\n  });\n\n  describe('parseHTML', () => {\n    it('returns parsing rules', () => {\n      const rules = InlineDropdownNode.parseHTML();\n\n      expect(Array.isArray(rules)).toBe(true);\n      expect(rules).toHaveLength(1);\n      expect(rules[0]).toHaveProperty('tag');\n    });\n  });\n\n  describe('renderHTML', () => {\n    it('renders span with attributes', () => {\n      const result = InlineDropdownNode.renderHTML({\n        HTMLAttributes: {\n          index: '1',\n          id: '1',\n          value: 'test',\n        },\n      });\n\n      expect(result[0]).toBe('span');\n      expect(result[1]).toHaveProperty('data-type', 'inline_dropdown');\n    });\n  });\n\n  describe('addNodeView', () => {\n    it('returns ReactNodeViewRenderer result', () => {\n      const result = InlineDropdownNode.addNodeView();\n\n      expect(result).toBeDefined();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}